code stringlengths 1 1.05M | repo_name stringlengths 6 83 | path stringlengths 3 242 | language stringclasses 222 values | license stringclasses 20 values | size int64 1 1.05M |
|---|---|---|---|---|---|
#ifndef TEST_CONFIG_H
#define TEST_CONFIG_H
#ifdef HITLS_CRYPTO_SHA256
#undef HITLS_CRYPTO_SHA256
#endif
#ifndef HITLS_CRYPTO_MD
#define HITLS_CRYPTO_MD
#endif
#endif | 2302_82127028/openHiTLS-examples_1508 | testcode/script/mini_test_config/test_config.h | C | unknown | 180 |
# This file is part of the openHiTLS project.
#
# openHiTLS is licensed under the Mulan PSL v2.
# You can use this software according to the terms and conditions of the Mulan PSL v2.
# You may obtain a copy of Mulan PSL v2 at:
#
# http://license.coscl.org.cn/MulanPSL2
#
# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
# See the Mulan PSL v2 for more details.
message(STATUS "Enable bsl: ${ENABLE_BSL}")
message(STATUS "Enable fail repeat: ${ENABLE_FAIL_REPEAT}")
message(STATUS "Enable print: ${ENABLE_PRINT}")
set(TEST_SOURCE
${openHiTLS_SRC}/testcode/framework/gen_test/helper.c
${openHiTLS_SRC}/testcode/framework/gen_test/test.c
${openHiTLS_SRC}/testcode/framework/crypto/alg_check.c
${openHiTLS_SRC}/testcode/framework/crypto/crypto_test_util.c
${openHiTLS_SRC}/testcode/framework/stub/stub_replace.c
)
add_library(TEST_INTF INTERFACE)
add_library(TEST_INTF_SHARED INTERFACE)
if(ENABLE_PRINT)
target_compile_options(TEST_INTF INTERFACE -DPRINT_TO_TERMINAL)
target_compile_options(TEST_INTF_SHARED INTERFACE -DPRINT_TO_TERMINAL)
endif()
if(ENABLE_FAIL_REPEAT)
target_compile_options(TEST_INTF INTERFACE -DFAIL_REPEAT_RUN)
target_compile_options(TEST_INTF_SHARED INTERFACE -DFAIL_REPEAT_RUN)
endif()
target_link_directories(TEST_INTF INTERFACE
${openHiTLS_SRC}/build
${openHiTLS_SRC}/testcode/output/lib
${openHiTLS_SRC}/platform/Secure_C/lib
)
target_link_directories(TEST_INTF_SHARED INTERFACE
${openHiTLS_SRC}/build
${openHiTLS_SRC}/testcode/output/lib
${openHiTLS_SRC}/platform/Secure_C/lib
)
# link libs
set(TEST_INTF_LIBS "")
set(TEST_INTF_SHARED_LIBS "")
if(APPS)
list(APPEND TEST_INTF_LIBS hitls_apps)
endif()
if(ENABLE_TLS AND ${BUILD_TLS} GREATER -1)
list(APPEND TEST_INTF_LIBS tls_hlt tls_frame libhitls_tls.a rec_wrapper)
list(APPEND TEST_INTF_SHARED_LIBS tls_hlt tls_frame libhitls_tls.so rec_wrapper)
endif()
if(ENABLE_PKI AND ${BUILD_PKI} GREATER -1)
list(APPEND TEST_INTF_LIBS libhitls_pki.a)
list(APPEND TEST_INTF_SHARED_LIBS libhitls_pki.so)
endif()
if(ENABLE_AUTH AND ${BUILD_AUTH} GREATER -1)
list(APPEND TEST_INTF_LIBS libhitls_auth.a)
list(APPEND TEST_INTF_SHARED_LIBS libhitls_auth.so)
endif()
if(ENABLE_CRYPTO AND ${BUILD_CRYPTO} GREATER -1)
list(APPEND TEST_INTF_LIBS libhitls_crypto.a)
list(APPEND TEST_INTF_SHARED_LIBS libhitls_crypto.so)
endif()
list(APPEND TEST_INTF_LIBS libhitls_bsl.a boundscheck pthread dl)
list(APPEND TEST_INTF_SHARED_LIBS libhitls_bsl.so boundscheck pthread dl)
target_link_libraries(TEST_INTF INTERFACE ${TEST_INTF_LIBS})
target_link_libraries(TEST_INTF_SHARED INTERFACE ${TEST_INTF_SHARED_LIBS})
set(TEST_INTF_INCLUDE_DIRS
${openHiTLS_SRC}/platform/Secure_C/include
${openHiTLS_SRC}/include
${openHiTLS_SRC}/testcode/framework/include
${openHiTLS_SRC}/testcode/framework/crypto
${openHiTLS_SRC}/testcode/framework/stub
${openHiTLS_SRC}/testcode/framework/tls/func_wrapper/include
${openHiTLS_SRC}/testcode/framework/tls/include
${openHiTLS_SRC}/testcode/framework/tls/callback/include
${openHiTLS_SRC}/testcode/framework/tls/base/include
${openHiTLS_SRC}/testcode/framework/tls/resource/include
${openHiTLS_SRC}/testcode/framework/tls/rpc/include
${openHiTLS_SRC}/testcode/framework/tls/process/include
${openHiTLS_SRC}/testcode/framework/tls/crypt/include
${openHiTLS_SRC}/testcode/framework/tls/transfer/include
${openHiTLS_SRC}/testcode/framework/tls/frame/src
${openHiTLS_SRC}/testcode/framework/tls/msg/include
${openHiTLS_SRC}/testcode/framework/tls/io/include
${openHiTLS_SRC}/testcode/framework/tls/io/src
${openHiTLS_SRC}/bsl/sal/include
${openHiTLS_SRC}/bsl/tlv/include
${openHiTLS_SRC}/include/bsl
${openHiTLS_SRC}/include/tls
${openHiTLS_SRC}/include/auth
${openHiTLS_SRC}/bsl/log/include
${openHiTLS_SRC}/bsl/hash/include
${openHiTLS_SRC}/bsl/base64/include
${openHiTLS_SRC}/bsl/pem/include
${openHiTLS_SRC}/bsl/list/include
${openHiTLS_SRC}/bsl/obj/include
${openHiTLS_SRC}/bsl/include
${openHiTLS_SRC}/bsl/sal/src
${openHiTLS_SRC}/bsl/conf/include
${openHiTLS_SRC}/include/crypto/
${openHiTLS_SRC}/crypto/bn/include/
${openHiTLS_SRC}/crypto/bn/src/
${openHiTLS_SRC}/crypto/entropy/include/
${openHiTLS_SRC}/crypto/sm3/include
${openHiTLS_SRC}/crypto/sha3/include
${openHiTLS_SRC}/crypto/sha2/include
${openHiTLS_SRC}/crypto/sha2/src
${openHiTLS_SRC}/crypto/sha1/include
${openHiTLS_SRC}/crypto/md5/include
${openHiTLS_SRC}/crypto/pbkdf2/include
${openHiTLS_SRC}/crypto/provider/include
${openHiTLS_SRC}/crypto/provider/src/mgr
${openHiTLS_SRC}/crypto/hkdf/include
${openHiTLS_SRC}/crypto/kdf/include
${openHiTLS_SRC}/crypto/scrypt/include
${openHiTLS_SRC}/crypto/hmac/include
${openHiTLS_SRC}/crypto/siphash/include
${openHiTLS_SRC}/crypto/aes/include
${openHiTLS_SRC}/crypto/sm4/include
${openHiTLS_SRC}/crypto/drbg/include
${openHiTLS_SRC}/crypto/drbg/src
${openHiTLS_SRC}/crypto/include
${openHiTLS_SRC}/crypto/rsa/include
${openHiTLS_SRC}/crypto/rsa/src
${openHiTLS_SRC}/crypto/eal/src
${openHiTLS_SRC}/crypto/eal/include
${openHiTLS_SRC}/crypto/ealinit/include
${openHiTLS_SRC}/crypto/ealinit/src
${openHiTLS_SRC}/crypto/dsa/src
${openHiTLS_SRC}/crypto/curve25519/src
${openHiTLS_SRC}/crypto/curve25519/include
${openHiTLS_SRC}/crypto/chacha20/include
${openHiTLS_SRC}/crypto/dsa/include
${openHiTLS_SRC}/crypto/dsa/src
${openHiTLS_SRC}/crypto/dh/include
${openHiTLS_SRC}/crypto/dh/src
${openHiTLS_SRC}/crypto/ecc/include
${openHiTLS_SRC}/crypto/ecc/src
${openHiTLS_SRC}/crypto/ecdh/include
${openHiTLS_SRC}/crypto/ecdsa/include
${openHiTLS_SRC}/crypto/modes/include
${openHiTLS_SRC}/crypto/modes/src
${openHiTLS_SRC}/crypto/ecdh/include
${openHiTLS_SRC}/crypto/ecdsa/include
${openHiTLS_SRC}/crypto/sm2/include
${openHiTLS_SRC}/crypto/sm2/src
${openHiTLS_SRC}/crypto/paillier/include
${openHiTLS_SRC}/crypto/paillier/src
${openHiTLS_SRC}/crypto/elgamal/include
${openHiTLS_SRC}/crypto/elgamal/src
${openHiTLS_SRC}/crypto/encode/include
${openHiTLS_SRC}/crypto/codecskey/include
${openHiTLS_SRC}/crypto/codecskey/src
${openHiTLS_SRC}/crypto/entropy/src
${openHiTLS_SRC}/crypto/provider/src/cmvp/cmvp_utils
${openHiTLS_SRC}/bsl/err/include
${openHiTLS_SRC}/bsl/err/src
${openHiTLS_SRC}/include/tls
${openHiTLS_SRC}/tls/include
${openHiTLS_SRC}/tls/cert/include
${openHiTLS_SRC}/tls/cm/include
${openHiTLS_SRC}/tls/config/include
${openHiTLS_SRC}/tls/crypt/include
${openHiTLS_SRC}/tls/app/include
${openHiTLS_SRC}/tls/app/src
${openHiTLS_SRC}/tls/ccs/include
${openHiTLS_SRC}/tls/alert/include
${openHiTLS_SRC}/bsl/uio/include
${openHiTLS_SRC}/tls/record/include
${openHiTLS_SRC}/tls/record/src
${openHiTLS_SRC}/bsl/uio/src
${openHiTLS_SRC}/bsl/asn1/include
${openHiTLS_SRC}/bsl/buffer/include
${openHiTLS_SRC}/include/pki
${openHiTLS_SRC}/pki/x509_cert/include
${openHiTLS_SRC}/pki/x509_csr/include
${openHiTLS_SRC}/pki/x509_common/include
${openHiTLS_SRC}/pki/x509_crl/include
${openHiTLS_SRC}/pki/pkcs12/include
${openHiTLS_SRC}/pki/cms/include
${openHiTLS_SRC}/pki/x509_verify/include
${openHiTLS_SRC}/pki/print/include
${openHiTLS_SRC}/config/macro_config
${openHiTLS_SRC}/tls/handshake/include
${openHiTLS_SRC}/tls/handshake/common/include
${openHiTLS_SRC}/tls/handshake/cookie/include
${openHiTLS_SRC}/tls/handshake/parse/include
${openHiTLS_SRC}/tls/handshake/pack/include
${openHiTLS_SRC}/tls/handshake/pack/src
${openHiTLS_SRC}/tls/handshake/send/src
${openHiTLS_SRC}/tls/handshake/recv/src
${openHiTLS_SRC}/tls/handshake/recv/include
${openHiTLS_SRC}/tls/handshake/common/src
${openHiTLS_SRC}/tls/feature/session/src
${openHiTLS_SRC}/tls/cert/include
${openHiTLS_SRC}/tls/cert/cert_adapt
${openHiTLS_SRC}/tls/cert/hitls_x509_adapt
${openHiTLS_SRC}/tls/crypt/crypt_self
${openHiTLS_SRC}/config/macro_config
${openHiTLS_SRC}/tls/handshake/parse/src
${openHiTLS_SRC}/auth/privpass_token/include
${openHiTLS_SRC}/config/macro_config
${openHiTLS_SRC}/codecs/include
${openHiTLS_SRC}/tls/feature/custom_extensions/include
${openHiTLS_SRC}/crypto/mlkem/include
${openHiTLS_SRC}/crypto/mlkem/src
${openHiTLS_SRC}/crypto/mldsa/include
${openHiTLS_SRC}/crypto/mldsa/src
${openHiTLS_SRC}/apps/include
${openHiTLS_SRC}/apps/src
${openHiTLS_SRC}/bsl/ui/include
${openHiTLS_SRC}/bsl/print/include
)
target_include_directories(TEST_INTF
INTERFACE
${TEST_INTF_INCLUDE_DIRS}
)
target_include_directories(TEST_INTF_SHARED
INTERFACE
${TEST_INTF_INCLUDE_DIRS}
)
add_library(TESTCASE_PRE ${TEST_SOURCE})
add_library(TESTCASE_PRE_SHARED ${TEST_SOURCE})
target_link_libraries(TESTCASE_PRE PRIVATE TEST_INTF)
target_link_libraries(TESTCASE_PRE_SHARED PRIVATE TEST_INTF_SHARED)
if(GEN_TEST_FILES)
# test1 test2 ...
string(REPLACE " " ";" GEN_TEST_FILES ${GEN_TEST_FILES})
foreach(gen_test_suite ${GEN_TEST_FILES})
get_filename_component(suite ${gen_test_suite} NAME)
execute_process(COMMAND touch ${openHiTLS_SRC}/testcode/output/${suite}.c
WORKING_DIRECTORY ${openHiTLS_SRC}/testcode/output
)
add_custom_target(${suite}_phony
COMMAND ./gen_testcase ${gen_test_suite}
DEPENDS gen_testcase
WORKING_DIRECTORY ${openHiTLS_SRC}/testcode/output)
message(STATUS "${suite}: ${gen_test_suite}")
set(TEST_FILES "${TEST_FILES};${gen_test_suite}")
endforeach()
else()
message(STATUS "No file needs to be generated")
endif()
# Set library type for each test case
set(TEST_SHARED_LIBS
test_suite_sdv_hlt_provider
test_suite_sdv_frame_provider
test_suite_sdv_hlt_base_connect
test_suite_sdv_hlt_tlcp_ciphersuite
)
# Create test cases
foreach(test_suite ${TEST_FILES})
get_filename_component(sdv_exe ${test_suite} NAME_WE)
add_executable(${sdv_exe} ${openHiTLS_SRC}/testcode/output/${sdv_exe}.c)
target_link_options(${sdv_exe} PRIVATE "LINKER:-z,noexecstack")
add_dependencies(${sdv_exe} ${sdv_exe}_phony)
set_target_properties(${sdv_exe} PROPERTIES
RUNTIME_OUTPUT_DIRECTORY "${openHiTLS_SRC}/testcode/output"
)
# Choose between static and shared libraries based on test case
if(${sdv_exe} IN_LIST TEST_SHARED_LIBS)
target_link_libraries(${sdv_exe} PRIVATE TEST_INTF_SHARED TESTCASE_PRE_SHARED)
else()
target_link_libraries(${sdv_exe} PRIVATE TEST_INTF TESTCASE_PRE)
endif()
endforeach()
if("${APPS}" STREQUAL "ON")
SET(APPS_LIB "hitls_apps")
aux_source_directory(${openHiTLS_SRC}/apps/src APPS_SRC)
add_library(${APPS_LIB} STATIC ${APPS_SRC})
target_link_libraries(${APPS_LIB} PRIVATE TEST_INTF)
target_compile_options(${APPS_LIB} PRIVATE -O0 -g3 -gdwarf-2)
set_target_properties(${APPS_LIB}
PROPERTIES
ARCHIVE_OUTPUT_DIRECTORY "${openHiTLS_SRC}/testcode/output/lib"
)
endif()
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/CMakeLists.txt | CMake | unknown | 11,505 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdint.h>
#include "hitls_pki_errno.h"
#include "hitls_csr_local.h"
#include "app_errno.h"
#include "app_conf.h"
/* END_HEADER */
#define MAX_STR_CNT (10)
/* BEGIN_CASE */
void UT_HITLS_APP_SplitString_Api_TC001(void)
{
char *res[MAX_STR_CNT] = {0};
uint32_t cnt = 0;
char *in = "Aa,Bb";
char separator = ',';
ASSERT_EQ(HITLS_APP_SplitString(NULL, separator, 1, res, MAX_STR_CNT, &cnt), HITLS_APP_INVALID_ARG);
ASSERT_EQ(HITLS_APP_SplitString("", separator, 1, res, MAX_STR_CNT, &cnt), HITLS_APP_INVALID_ARG);
ASSERT_EQ(HITLS_APP_SplitString(in, ' ', 1, res, MAX_STR_CNT, &cnt), HITLS_APP_INVALID_ARG);
ASSERT_EQ(HITLS_APP_SplitString(in, separator, 1, NULL, MAX_STR_CNT, &cnt), HITLS_APP_INVALID_ARG);
ASSERT_EQ(HITLS_APP_SplitString(in, separator, 1, res, 0, &cnt), HITLS_APP_INVALID_ARG);
ASSERT_EQ(HITLS_APP_SplitString(in, separator, 1, res, MAX_STR_CNT, NULL), HITLS_APP_INVALID_ARG);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_SplitString_Func_TC001(
char *in, int allowEmpty, int expectCnt, char *expect1, char *expect2, char *expect3)
{
char *res[MAX_STR_CNT] = {0};
uint32_t cnt = 0;
char separator = ',';
char *expect[MAX_STR_CNT] = {expect1, expect2, expect3};
ASSERT_EQ(HITLS_APP_SplitString(in, separator, allowEmpty, res, MAX_STR_CNT, &cnt), HITLS_APP_SUCCESS);
ASSERT_EQ(cnt, expectCnt);
for (uint32_t i = 0; i < cnt; i++) {
ASSERT_EQ(strcmp(expect[i], res[i]), 0);
}
EXIT:
BSL_SAL_Free(res[0]);
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_SplitString_Error_TC001(char *in, int allowEmpty)
{
char *res[MAX_STR_CNT] = {0};
uint32_t cnt = 0;
char separator = ',';
ASSERT_EQ(HITLS_APP_SplitString(in, separator, allowEmpty, res, MAX_STR_CNT, &cnt), HITLS_APP_CONF_FAIL);
EXIT:
BSL_SAL_FREE(res[0]);
}
/* END_CASE */
#define HITLS_X509_CSR_GEN_FLAG 0x02
/* BEGIN_CASE */
void UT_HITLS_APP_conf_subj_TC001(char *subjectName, int expectRet, int expectCnt, Hex *expectEncode)
{
HITLS_X509_Csr *csr = HITLS_X509_CsrNew();
ASSERT_NE(csr, NULL);
BslList *csrSubject = NULL;
BSL_ASN1_Buffer name = {0};
BSL_Buffer nameEncoded = {0};
ASSERT_EQ(HITLS_APP_CFG_ProcDnName(subjectName, HiTLS_AddSubjDnNameToCsr, csr), expectRet);
if (expectRet == HITLS_APP_SUCCESS) {
ASSERT_EQ(HITLS_X509_CsrCtrl(csr, HITLS_X509_GET_SUBJECT_DN, &csrSubject, sizeof(BslList *)), 0);
ASSERT_EQ(BSL_LIST_COUNT(csrSubject), expectCnt);
if (expectCnt != 0) {
ASSERT_EQ(HITLS_X509_EncodeNameList(csrSubject, &name), 0);
BSL_ASN1_TemplateItem item = {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0};
BSL_ASN1_Template templ = {&item, 1};
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &name, 1, &nameEncoded.data, &nameEncoded.dataLen), 0);
ASSERT_EQ(expectEncode->len, nameEncoded.dataLen);
ASSERT_EQ(memcmp(expectEncode->x, nameEncoded.data, expectEncode->len), 0);
}
}
EXIT:
BSL_SAL_FREE(nameEncoded.data);
BSL_SAL_FREE(name.buff);
HITLS_X509_CsrFree(csr);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_conf_subj_TC002(void)
{
HITLS_X509_Csr *csr = HITLS_X509_CsrNew();
ASSERT_NE(csr, NULL);
ASSERT_EQ(HITLS_APP_CFG_ProcDnName(NULL, HiTLS_AddSubjDnNameToCsr, csr), HITLS_APP_INVALID_ARG);
ASSERT_EQ(HITLS_APP_CFG_ProcDnName("/ABC=1", NULL, NULL), HITLS_APP_INVALID_ARG);
ASSERT_EQ(HITLS_APP_CFG_ProcDnName("/ABC=1", HiTLS_AddSubjDnNameToCsr, NULL), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_APP_CFG_ProcDnName("/pseudonym=testabc#", HiTLS_AddSubjDnNameToCsr, NULL), HITLS_APP_INVALID_ARG);
ASSERT_EQ(HITLS_APP_CFG_ProcDnName("ABC", HiTLS_AddSubjDnNameToCsr, csr), HITLS_APP_INVALID_ARG);
ASSERT_EQ(HITLS_APP_CFG_ProcDnName("/", HiTLS_AddSubjDnNameToCsr, csr), HITLS_APP_INVALID_ARG);
EXIT:
HITLS_X509_CsrFree(csr);
return;
}
/* END_CASE */
static int32_t ProcExt(BslCid cid, void *val, void *ctx)
{
HITLS_X509_Ext *ext = ctx;
switch (cid) {
case BSL_CID_CE_SUBJECTALTNAME:
return HITLS_X509_ExtCtrl(ext, HITLS_X509_EXT_SET_SAN, val, sizeof(HITLS_X509_ExtSan));
case BSL_CID_CE_BASICCONSTRAINTS:
return HITLS_X509_ExtCtrl(ext, HITLS_X509_EXT_SET_BCONS, val, sizeof(HITLS_X509_ExtBCons));
case BSL_CID_CE_KEYUSAGE:
return HITLS_X509_ExtCtrl(ext, HITLS_X509_EXT_SET_KUSAGE, val, sizeof(HITLS_X509_ExtKeyUsage));
case BSL_CID_CE_EXTKEYUSAGE:
return HITLS_X509_ExtCtrl(ext, HITLS_X509_EXT_SET_EXKUSAGE, val, sizeof(HITLS_X509_ExtExKeyUsage));
default:
return HITLS_APP_CONF_FAIL;
}
}
/* BEGIN_CASE */
void UT_HITLS_APP_conf_X509Ext_TC001(char *confPath, int expectLoadRet, int expectResult, Hex *expectAsn)
{
BSL_CONF *conf = NULL;
BSL_ASN1_Buffer asnExt = {0};
HITLS_X509_Ext *ext = HITLS_X509_ExtNew(HITLS_X509_EXT_TYPE_CSR);
ASSERT_NE(ext, NULL);
conf = BSL_CONF_New(BSL_CONF_DefaultMethod());
ASSERT_NE(conf, NULL);
ASSERT_EQ(BSL_CONF_Load(conf, confPath), expectLoadRet);
if (expectLoadRet == HITLS_APP_SUCCESS) {
ASSERT_EQ(HITLS_APP_CONF_ProcExt(conf, "SAN", ProcExt, ext), expectResult);
if (expectResult == HITLS_APP_SUCCESS) {
ASSERT_EQ(HITLS_X509_EncodeExt(BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SET, ext->extList, &asnExt),
HITLS_PKI_SUCCESS);
ASSERT_EQ(asnExt.len, expectAsn->len);
ASSERT_EQ(memcmp(asnExt.buff, expectAsn->x, expectAsn->len), 0);
}
}
EXIT:
BSL_SAL_FREE(asnExt.buff);
HITLS_X509_ExtFree(ext);
BSL_CONF_Free(conf);
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_conf_X509Ext_TC002(void)
{
HITLS_X509_Ext *ext = HITLS_X509_ExtNew(HITLS_X509_EXT_TYPE_CSR);
BSL_CONF conf = {};
ASSERT_NE(ext, NULL);
ASSERT_EQ(HITLS_APP_CONF_ProcExt(NULL, "SAN", ProcExt, ext), HITLS_APP_CONF_FAIL);
ASSERT_EQ(HITLS_APP_CONF_ProcExt(&conf, NULL, ProcExt, ext), HITLS_APP_CONF_FAIL);
ASSERT_EQ(HITLS_APP_CONF_ProcExt(&conf, "SAN", NULL, ext), HITLS_APP_CONF_FAIL);
ASSERT_EQ(HITLS_APP_CONF_ProcExt(&conf, "SAN", ProcExt, NULL), HITLS_APP_CONF_FAIL);
conf.data = NULL;
ASSERT_EQ(HITLS_APP_CONF_ProcExt(&conf, "SAN", ProcExt, ext), HITLS_APP_CONF_FAIL);
EXIT:
HITLS_X509_ExtFree(ext);
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/apps/test_suite_ut_app_conf.c | C | unknown | 7,007 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "app_crl.h"
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_types.h"
#include "hitls_pki_errno.h"
#include "hitls_x509_local.h"
#include "hitls_crl_local.h"
#include "bsl_errno.h"
#include "crypt_eal_pkey.h"
#include "app_opt.h"
#include "app_function.h"
#include "app_errno.h"
#include "app_help.h"
#include "app_print.h"
#include "app_utils.h"
#include "stub_replace.h"
#define MAX_CRLFILE_SIZE (256 * 1024)
#define DEFAULT_CERT_SIZE 1024U
/* END_HEADER */
#define CRL_PATH "../testdata/certificate/crlAndCert/crl.crt"
#define CRL_ASN1_PATH "../testdata/cert/asn1/sm2_crl/crl_v2.v1.der"
#define CERT_PATH "../testdata/certificate/crlAndCert/CA.crt"
#define ERR_CRL_PATH "../testdata/certificate/crlAndCert/emptyCRL.crt"
#define ERR_CERT_PATH "../testdata/certificate/crlAndCert/errCA.crt"
#define CRL_PEM_PATH "./crl.pem"
#define CRL_DER_PATH "./crl.der"
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_crl.c
${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c */
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
/**
* @test UT_HITLS_APP_crl_TC001
* @spec -
* @title Test the UT_HITLS_APP_crl_TC001 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_crl_TC001(void)
{
char *argv[][10] = {
{"crl", "-in", CRL_PATH, "-noout", "-CAfile", CERT_PATH},
{"crl", "-in", CRL_PATH, "-noout"},
{"crl", "-in", CRL_PATH, "-noout", "-nextupdate"},
{"crl", "-in", CRL_PATH, "-noout", "-out", "tmp.txt", "-nextupdate"},
{"crl", "-in", CRL_PATH, "-noout", "-CAfile", ERR_CRL_PATH},
{"crl", "-in", ERR_CRL_PATH, "-noout", "-CAfile", CERT_PATH},
{"crl", "-in", CRL_ASN1_PATH, "-inform", "DER", "-out", CRL_PEM_PATH, "-outform", "PEM"},
{"crl", "-in", CRL_PATH, "-inform", "PEM", "-out", CRL_DER_PATH, "-outform", "DER"},
};
OptTestData testData[] = {
{6, argv[0], HITLS_APP_SUCCESS},
{4, argv[1], HITLS_APP_SUCCESS},
{5, argv[2], HITLS_APP_SUCCESS},
{7, argv[3], HITLS_APP_SUCCESS},
{6, argv[4], HITLS_APP_UIO_FAIL},
{6, argv[5], HITLS_APP_UIO_FAIL},
{9, argv[6], HITLS_APP_SUCCESS},
{9, argv[7], HITLS_APP_SUCCESS}
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_CrlMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_crl_TC002
* @spec -
* @title Test the UT_HITLS_APP_crl_TC002 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_crl_TC002(void)
{
char *argv[][10] = {
{"crl", "-in"},
{"crl", "-in", ERR_CRL_PATH},
{"crl", "-in", CRL_PATH, "-in", ERR_CRL_PATH},
{"crl", "-in", ERR_CRL_PATH, "-noout", "-CAfile"},
{"crl", "-in", CRL_PATH, "-noout", "-CAfile", ERR_CRL_PATH},
{"crl", "-in", CRL_PATH, "-noout", "-CAfile", CERT_PATH, "-CAfile", ERR_CRL_PATH},
};
OptTestData testData[] = {{2, argv[0], HITLS_APP_OPT_UNKOWN},
{3, argv[1], HITLS_APP_UIO_FAIL},
{5, argv[2], HITLS_APP_UIO_FAIL},
{5, argv[3], HITLS_APP_OPT_UNKOWN},
{6, argv[4], HITLS_APP_UIO_FAIL},
{8, argv[5], HITLS_APP_UIO_FAIL}};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_CrlMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_crl_TC003
* @spec -
* @title Test the UT_HITLS_APP_crl_TC003 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_crl_TC003(void)
{
char *argv[][2] = {
{"crl", "-help"},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_HELP},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_CrlMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
int32_t STUB_HITLS_APP_OptBegin(int32_t argc, char **argv, const HITLS_CmdOption *opts)
{
(void)argc;
(void)argv;
(void)opts;
return HITLS_APP_OPT_UNKOWN;
}
/**
* @test UT_HITLS_APP_crl_TC004
* @spec -
* @title Test the UT_HITLS_APP_crl_TC004 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_crl_TC004(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptBegin, STUB_HITLS_APP_OptBegin);
char *argv[][10] = {
{"crl", "-in", CRL_PATH, "-noout", "-CAfile", CERT_PATH},
};
OptTestData testData[] = {
{6, argv[0], HITLS_APP_OPT_UNKOWN},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_CrlMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_BSL_UIO_Ctrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *parg)
{
(void)uio;
(void)cmd;
(void)larg;
(void)parg;
return BSL_UIO_FAIL;
}
/**
* @test UT_HITLS_APP_crl_TC005
* @spec -
* @title Test the UT_HITLS_APP_crl_TC005 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_crl_TC005(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UIO_Ctrl, STUB_BSL_UIO_Ctrl);
char *argv[][50] = {{"crl", "-in", CRL_PATH, "-noout", "-CAfile", CERT_PATH}};
OptTestData testData[] = {
{6, argv[0], HITLS_APP_UIO_FAIL},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_CrlMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
char *STUB_HITLS_APP_OptGetValueStr(void)
{
return NULL;
}
/**
* @test UT_HITLS_APP_crl_TC006
* @spec -
* @title Test the UT_HITLS_APP_crl_TC006 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_crl_TC006(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptGetValueStr, STUB_HITLS_APP_OptGetValueStr);
char *argv[][50] = {{"crl", "-in", CRL_PATH, "-noout", "-CAfile", CERT_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_OPT_VALUE_INVALID},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_CrlMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_HITLS_APP_OptWriteUio(BSL_UIO *uio, uint8_t *buf, uint32_t outLen, int32_t format)
{
(void)uio;
(void)buf;
(void)outLen;
(void)format;
return HITLS_APP_UIO_FAIL;
}
/**
* @test UT_HITLS_APP_crl_TC007
* @spec -
* @title Test the UT_HITLS_APP_crl_TC007 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_crl_TC007(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptWriteUio, STUB_HITLS_APP_OptWriteUio);
char *argv[][50] = {{"crl", "-in", CRL_PATH, "-CAfile", CERT_PATH}};
OptTestData testData[] = {
{5, argv[0], HITLS_APP_UIO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_CrlMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
bool IsFileExist(const char *fileName)
{
FILE *f = fopen(fileName, "r");
if (f == NULL) {
return false;
}
fclose(f);
return true;
}
/**
* @test UT_HITLS_APP_crl_TC008
* @spec -
* @title Test the UT_HITLS_APP_crl_TC008 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_crl_TC008(void)
{
char *filename = "_APP_crl_T008.txt";
char *argv[][10] = {{"crl", "-in", CRL_PATH, "-out", filename, "-CAfile", CERT_PATH}};
OptTestData testData[] = {{7, argv[0], HITLS_APP_SUCCESS}};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
ASSERT_TRUE(IsFileExist(filename) == false);
int ret = HITLS_CrlMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
ASSERT_TRUE(IsFileExist(filename));
remove(filename);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
int32_t STUB_X509_extractPublicKey(HITLS_X509_Cert *cert, int32_t cmd, void *val, uint32_t valLen)
{
(void)cert;
(void)cmd;
(void)val;
(void)valLen;
return HITLS_X509_ERR_INVALID_PARAM;
}
/**
* @test UT_HITLS_APP_crl_TC0010
* @spec -
* @titleTest UT_HITLS_APP_crl_TC0010 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_crl_TC0010(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_X509_CertCtrl, STUB_X509_extractPublicKey);
char *argv[][50] = {{"crl", "-in", CRL_PATH, "-noout", "-CAfile", CERT_PATH}};
OptTestData testData[] = {
{6, argv[0], HITLS_APP_DECODE_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_CrlMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_PEM_encode(HITLS_X509_Crl *crl, uint8_t **encode, uint32_t *encodeLen)
{
(void)crl;
(void)encode;
(void)encodeLen;
return HITLS_APP_ENCODE_FAIL;
} | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/apps/test_suite_ut_app_crl.c | C | unknown | 10,819 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "app_opt.h"
#include "app_print.h"
#include "bsl_uio.h"
#include "uio_abstraction.h"
#include "app_errno.h"
#include "crypt_errno.h"
#include "app_genpkey.h"
#include "app_function.h"
#include "securec.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "stub_replace.h"
/* END_HEADER */
#define GENPKEY_TEST_FILE_PATH "out_test.pem"
#define GENPKEY_TEST_DIR_PATH "./genpkey_dir"
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_genpkey.c
${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c */
/**
* @test UT_HITLS_APP_GENPKEY_TC001
* @spec -
* @title 测试UT_HITLS_APP_GENPKEY_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_GENPKEY_TC001()
{
char *argv[][20] = {
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:P-224"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:P-256"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:P-384"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:P-521"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:brainpoolp256r1"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:brainpoolp384r1"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:brainpoolp512r1"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:sm2"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:sm2", "-out", GENPKEY_TEST_FILE_PATH},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:sm2", "-aes256-cbc", "-pass", "pass:123456"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:sm2", "-aes256-cbc", "-pass", "pass:123456", "-out", GENPKEY_TEST_FILE_PATH},
{"genpkey", "-algorithm", "RSA"},
{"genpkey", "-algorithm", "RSA", "-pkeyopt", "rsa_keygen_bits:1024"},
{"genpkey", "-algorithm", "RSA", "-pkeyopt", "rsa_keygen_bits:2048"},
{"genpkey", "-algorithm", "RSA", "-pkeyopt", "rsa_keygen_bits:3072"},
{"genpkey", "-algorithm", "RSA", "-pkeyopt", "rsa_keygen_bits:4096"},
{"genpkey", "-algorithm", "RSA", "-pkeyopt", "rsa_keygen_bits:4096", "-out", "out_test.pem"},
{"genpkey", "-algorithm", "RSA", "-pkeyopt", "rsa_keygen_bits:4096", "-aes256-cbc", "-pass", "pass:123456"},
{"genpkey", "-algorithm", "RSA", "-pkeyopt", "rsa_keygen_bits:4096", "-aes256-cbc", "-pass", "pass:123456", "-out", GENPKEY_TEST_FILE_PATH},
};
OptTestData testData[] = {
{5, argv[0], HITLS_APP_SUCCESS},
{5, argv[1], HITLS_APP_SUCCESS},
{5, argv[2], HITLS_APP_SUCCESS},
{5, argv[3], HITLS_APP_SUCCESS},
{5, argv[4], HITLS_APP_SUCCESS},
{5, argv[5], HITLS_APP_SUCCESS},
{5, argv[6], HITLS_APP_SUCCESS},
{5, argv[7], HITLS_APP_SUCCESS},
{7, argv[8], HITLS_APP_SUCCESS},
{8, argv[9], HITLS_APP_SUCCESS},
{10, argv[10], HITLS_APP_SUCCESS},
{3, argv[11], HITLS_APP_SUCCESS},
{5, argv[12], HITLS_APP_SUCCESS},
{5, argv[13], HITLS_APP_SUCCESS},
{5, argv[14], HITLS_APP_SUCCESS},
{5, argv[15], HITLS_APP_SUCCESS},
{7, argv[16], HITLS_APP_SUCCESS},
{8, argv[17], HITLS_APP_SUCCESS},
{10, argv[18], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_GenPkeyMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
remove(GENPKEY_TEST_FILE_PATH);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_GENPKEY_TC002
* @spec -
* @title 测试UT_HITLS_APP_GENPKEY_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_GENPKEY_TC002()
{
mkdir(GENPKEY_TEST_DIR_PATH, 0775);
char *argv[][20] = {
{"genpkey", "-ttt"},
{"genpkey", "-algorithm", "ttt"},
{"genpkey", "-algorithm", "RSA", "-pass", "err:12"},
{"genpkey", "-algorithm", "RSA", "-pkeyopt", "ec_paramgen_curve:sm2"},
{"genpkey", "-algorithm", "RSA", "-pkeyopt", "ttt"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "rsa_keygen_bits:1024"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ttt"},
{"genpkey", "-algorithm", "RSA", "-aes256-cbc", "-pass", "pass:"},
{"genpkey", "-algorithm", "RSA", "-out", GENPKEY_TEST_DIR_PATH},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_OPT_UNKOWN},
{3, argv[1], HITLS_APP_INVALID_ARG},
{5, argv[2], HITLS_APP_PASSWD_FAIL},
{5, argv[3], HITLS_APP_INVALID_ARG},
{5, argv[4], HITLS_APP_INVALID_ARG},
{5, argv[5], HITLS_APP_INVALID_ARG},
{5, argv[6], HITLS_APP_INVALID_ARG},
{6, argv[7], HITLS_APP_PASSWD_FAIL},
{5, argv[8], HITLS_APP_UIO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_GenPkeyMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
rmdir(GENPKEY_TEST_DIR_PATH);
remove(GENPKEY_TEST_FILE_PATH);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_GENPKEY_TC003
* @spec -
* @title 测试UT_HITLS_APP_GENPKEY_TC003函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_GENPKEY_TC003(char *cipherOpt)
{
mkdir(GENPKEY_TEST_DIR_PATH, 0775);
char *argv[][20] = {
{"genpkey", "-algorithm", "RSA", cipherOpt, "-pass", "pass:123456"},
};
OptTestData testData[] = {
{6, argv[0], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_GenPkeyMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
rmdir(GENPKEY_TEST_DIR_PATH);
remove(GENPKEY_TEST_FILE_PATH);
return;
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/apps/test_suite_ut_app_genpkey.c | C | unknown | 7,101 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "securec.h"
#include <stddef.h>
#include "app_genrsa.h"
#include "app_rsa.h"
#include "app_errno.h"
#include "app_help.h"
#include "app_print.h"
#include "app_opt.h"
#include "app_utils.h"
#include "bsl_uio.h"
#include "stub_replace.h"
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_genrsa.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c */
/* END_HEADER */
#define BSL_SUCCESS 0
typedef struct {
int argc;
char **argv;
int expect;
} GenrsaTestData;
int32_t STUB_HITLS_APP_Passwd(char *buf, int32_t bufMaxLen, int32_t flag, void *userdata)
{
(void)flag;
(void)userdata;
(void)memcpy_s(buf, bufMaxLen, "12345678", 8);
return 8;
}
/**
* @test UT_HITLS_APP_genrsa_TC001
* @spec -
* @title test UT_HITLS_APP_genrsa_TC001 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_genrsa_TC001(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_Passwd, STUB_HITLS_APP_Passwd);
char *argv[][10] = {
{"genrsa", "-help"},
{"genrsa", "-cipher", "aes128-cbc", "1024"},
{"genrsa", "-cipher", "aes128-ctr", "-out", "GenrsaOutFile_1", "2048"},
{"genrsa", "-cipher", "aes128-xts", "-out", "GenrsaOutFile_2", "3072"},
{"genrsa", "-cipher", "sm4-cfb", "-out", "GenrsaOutFile_3", "4096"},
{"genrsa", "-cipher", "rc2-ofb", "-out", "GenrsaOutFile_4", "1024"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_5", "1024"},
{"genrsa", "-cipher", "aes666-cbc", "3072"},
{"genrsa", "-cipher", "aes128-cbc", "1234"}
};
GenrsaTestData testData[] = {
{2, argv[0], HITLS_APP_HELP},
{4, argv[1], HITLS_APP_SUCCESS},
{6, argv[2], HITLS_APP_OPT_VALUE_INVALID},
{6, argv[3], HITLS_APP_SUCCESS},
{6, argv[4], HITLS_APP_SUCCESS},
{6, argv[5], HITLS_APP_OPT_VALUE_INVALID},
{6, argv[6], HITLS_APP_SUCCESS},
{4, argv[7], HITLS_APP_OPT_VALUE_INVALID},
{4, argv[8], HITLS_APP_OPT_VALUE_INVALID}
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(GenrsaTestData)); ++i) {
int ret = HITLS_GenRSAMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_genrsa_TC002(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_Passwd, STUB_HITLS_APP_Passwd);
char *argv[][10] = {
{"", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "2048"},
{"genrsa", "", "aes128-cbc", "-out", "GenrsaOutFile_1", "2048"},
{"genrsa", "-cipher", "", "-out", "GenrsaOutFile_1", "2048"},
{"genrsa", "-cipher", "aes128-cbc", "", "GenrsaOutFile_1", "2048"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "", "2048"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", ""},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[0]), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[1]), HITLS_APP_OPT_UNKOWN);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[2]), HITLS_APP_OPT_VALUE_INVALID);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[3]), HITLS_APP_OPT_UNKOWN);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[4]), HITLS_APP_OPT_VALUE_INVALID);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[5]), HITLS_APP_OPT_VALUE_INVALID);
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_genrsa_TC003(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_Passwd, STUB_HITLS_APP_Passwd);
char *argv[][10] = {
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "2048"},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_GenRSAMain(5, argv[0]), HITLS_APP_OPT_UNKOWN);
ASSERT_EQ(HITLS_GenRSAMain(7, argv[0]), HITLS_APP_OPT_UNKOWN);
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_genrsa_TC004(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_Passwd, STUB_HITLS_APP_Passwd);
char *argv[][10] = {
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "1023"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "1025"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "2047"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "2049"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "3071"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "3073"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "4095"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "4097"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "abcdefgh"},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[0]), HITLS_APP_OPT_VALUE_INVALID);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[1]), HITLS_APP_OPT_VALUE_INVALID);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[2]), HITLS_APP_OPT_VALUE_INVALID);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[3]), HITLS_APP_OPT_VALUE_INVALID);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[4]), HITLS_APP_OPT_VALUE_INVALID);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[5]), HITLS_APP_OPT_VALUE_INVALID);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[6]), HITLS_APP_OPT_VALUE_INVALID);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[7]), HITLS_APP_OPT_VALUE_INVALID);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[8]), HITLS_APP_OPT_VALUE_INVALID);
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_genrsa_TC005(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_Passwd, STUB_HITLS_APP_Passwd);
char *argv[][10] = {
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "aes192-cbc", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "aes256-cbc", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "aes128-xts", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "aes256-xts", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "sm4-xts", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "sm4-cbc", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "sm4-ctr", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "sm4-cfb", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "sm4-ofb", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "aes128-cfb", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "aes192-cfb", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "aes256-cfb", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "aes128-ofb", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "aes192-ofb", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "aes256-ofb", "-out", "GenrsaOutFile", "1024"},
};
char *rsaArg[][10] = {
{"rsa", "-in", "GenrsaOutFile", "-noout"},
};
int32_t ret;
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (uint32_t i = 0; i < sizeof(argv) / sizeof(argv[0]); i++) {
ret = HITLS_GenRSAMain(6, argv[i]);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = HITLS_RsaMain(4, rsaArg[0]);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/apps/test_suite_ut_app_genrsa.c | C | unknown | 8,682 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <linux/limits.h>
#include "securec.h"
#include "stub_replace.h"
#include "test.h"
#include "bsl_uio.h"
#include "bsl_types.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "sal_file.h"
#include "string.h"
#include "uio_abstraction.h"
#include "crypt_errno.h"
#include "app_opt.h"
#include "app_print.h"
#include "app_errno.h"
#include "app_function.h"
#include "app_provider.h"
#include "app_kdf.h"
/* END_HEADER */
#define KDF_MAX_ARGC 22
#define MAX_BUFSIZE (1024 * 8)
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
static void PreProcArgs(char *args, int *argc, char **argv)
{
uint32_t len = strlen(args);
argv[(*argc)++] = args;
for (uint32_t i = 0; i < len; i++) {
if (args[i] == ' ') {
args[i] = '\0';
argv[(*argc)++] = args + i + 1;
}
}
if (APP_GetCurrent_LibCtx() == NULL) {
if (APP_Create_LibCtx() == NULL) {
(void)AppPrintError("Create g_libCtx failed\n");
}
}
}
static int32_t CompareOutByData(char *file1, Hex *data)
{
int ret = 1;
BSL_Buffer buff = {0};
char hexStr[2 * MAX_BUFSIZE + 1] = {0};
for (uint32_t i = 0; i < data->len; ++i) {
sprintf(hexStr + 2 * i, "%02x", data->x[i]);
}
uint32_t hexLen = strlen(hexStr);
ASSERT_EQ(BSL_SAL_ReadFile(file1, &buff.data, &buff.dataLen), 0);
ASSERT_EQ(buff.dataLen, hexLen);
ASSERT_COMPARE("Compare out data", buff.data, buff.dataLen, hexStr, hexLen);
ret = 0;
EXIT:
BSL_SAL_Free(buff.data);
return ret;
}
/**
* @test UT_HITLS_APP_KDF_InvalidOpt_TC001
* @title Test the invalid parameters of the kdf command.
* @brief Enter parameters and return the error code expectRet.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KDF_InvalidOpt_TC001(char *opts, int expectRet)
{
int argc = 0;
char *argv[KDF_MAX_ARGC] = {0};
char *tmp = strdup(opts);
ASSERT_NE(tmp, NULL);
PreProcArgs(tmp, &argc, argv);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_KdfMain(argc, argv), expectRet);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(tmp);
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KDF_NormalOpt_TC001
* @title Test the normal parameters of the kdf command.
* @brief Enter parameters and return HITLS_APP_SUCCESS.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KDF_NormalOpt_TC001(char *opts, char *outFile, Hex *expectData)
{
int argc = 0;
char *argv[KDF_MAX_ARGC] = {0};
char *tmp = strdup(opts);
ASSERT_NE(tmp, NULL);
PreProcArgs(tmp, &argc, argv);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_KdfMain(argc, argv), HITLS_APP_SUCCESS);
ASSERT_EQ(CompareOutByData(outFile, expectData), HITLS_APP_SUCCESS);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(tmp);
remove(outFile);
}
/* END_CASE */
/**
* @test UT_HITLS_APP_kdf_TC002
* @spec -
* @title 测试UT_HITLS_APP_kdf_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_kdf_TC002(void)
{
char *argv[][2] = {
{"kdf", "-help"},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_HELP},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_KdfMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/apps/test_suite_ut_app_kdf.c | C | unknown | 4,066 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <string.h>
#include "app_opt.h"
#include "app_print.h"
#include "bsl_uio.h"
#include "bsl_types.h"
#include "uio_abstraction.h"
#include "app_errno.h"
#include "crypt_errno.h"
#include "crypt_eal_codecs.h"
#include "crypt_util_rand.h"
#include "crypt_eal_pkey.h"
#include "app_genpkey.h"
#include "app_pkey.h"
#include "app_function.h"
#include "securec.h"
#include "bsl_err.h"
#include "bsl_sal.h"
#include "stub_replace.h"
#include "bsl_params.h"
#include "crypt_params_key.h"
/* END_HEADER */
#define TMP_BUFF_LEN 2048
#define GENPKEY_PRV_FILE_PATH "genpkey_prv.pem"
#define GENPKEY_ENC_PRV_FILE_PATH "genpkey_enc_prv.pem"
#define PKEY_PRV_FILE_PATH "pkey_prv.pem"
#define PKEY_ENC_PRV_FILE_PATH "pkey_enc_prv.pem"
#define PKEY_PUB_FILE_PATH "pkey_pub.pem"
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_genpkey.c
* ${HITLS_ROOT_PATH}/apps/src/app_pkey.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c
*/
static void SetRsaKeyInfo(CRYPT_EAL_PkeyCtx *pkey)
{
uint32_t keyLen = CRYPT_EAL_PkeyGetKeyLen(pkey);
ASSERT_NE(keyLen, 0);
uint8_t *prv = (uint8_t *)BSL_SAL_Malloc(keyLen * 8);
ASSERT_NE(prv, NULL);
CRYPT_EAL_PkeyPrv rsaPrv = { 0 };
rsaPrv.id = CRYPT_PKEY_RSA;
rsaPrv.key.rsaPrv.d = prv;
rsaPrv.key.rsaPrv.n = prv + keyLen;
rsaPrv.key.rsaPrv.p = prv + keyLen * 2; // 2nd buffer
rsaPrv.key.rsaPrv.q = prv + keyLen * 3; // 3rd buffer
rsaPrv.key.rsaPrv.dP = prv + keyLen * 4; // 4th buffer
rsaPrv.key.rsaPrv.dQ = prv + keyLen * 5; // 5th buffer
rsaPrv.key.rsaPrv.qInv = prv + keyLen * 6; // 6th buffer
rsaPrv.key.rsaPrv.e = prv + keyLen * 7; // 7th buffer
rsaPrv.key.rsaPrv.dLen = keyLen;
rsaPrv.key.rsaPrv.nLen = keyLen;
rsaPrv.key.rsaPrv.pLen = keyLen;
rsaPrv.key.rsaPrv.qLen = keyLen;
rsaPrv.key.rsaPrv.dPLen = keyLen;
rsaPrv.key.rsaPrv.dQLen = keyLen;
rsaPrv.key.rsaPrv.qInvLen = keyLen;
rsaPrv.key.rsaPrv.eLen = keyLen;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &rsaPrv), CRYPT_SUCCESS);
CRYPT_EAL_PkeyPub rsaPub;
rsaPub.id = CRYPT_PKEY_RSA;
rsaPub.key.rsaPub.n = rsaPrv.key.rsaPrv.n;
rsaPub.key.rsaPub.nLen = rsaPrv.key.rsaPrv.nLen;
rsaPub.key.rsaPub.e = rsaPrv.key.rsaPrv.e;
rsaPub.key.rsaPub.eLen = rsaPrv.key.rsaPrv.eLen;
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &rsaPub), CRYPT_SUCCESS);
EXIT:
BSL_SAL_ClearFree(prv, keyLen * 8); // 8 items
}
/**
* @test UT_HITLS_APP_KEY_TC001
* @spec -
* @title 测试UT_HITLS_APP_KEY_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEY_TC001(char *algorithm, char *pkeyopt, int hashId)
{
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
char *genpkeyPrv[20] = {"genpkey", "-algorithm", algorithm, "-pkeyopt", pkeyopt, "-out", GENPKEY_PRV_FILE_PATH};
char *pkeyPrv[20] = {"pkey", "-in", GENPKEY_PRV_FILE_PATH, "-out", PKEY_PRV_FILE_PATH};
char *pkeyPub[20] = {"pkey", "-in", PKEY_PRV_FILE_PATH, "-pubout", "-out", PKEY_PUB_FILE_PATH};
ASSERT_EQ(HITLS_GenPkeyMain(7, genpkeyPrv), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_PkeyMain(5, pkeyPrv), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_PkeyMain(6, pkeyPub), HITLS_APP_SUCCESS);
CRYPT_RandRegist(TestSimpleRand);
CRYPT_RandRegistEx(TestSimpleRandEx);
CRYPT_EAL_PkeyCtx *pkeyPrvCtx = NULL;
CRYPT_EAL_PkeyCtx *pkeyPubCtx = NULL;
ASSERT_EQ(CRYPT_EAL_DecodeFileKey(BSL_FORMAT_PEM, CRYPT_PRIKEY_PKCS8_UNENCRYPT, PKEY_PRV_FILE_PATH, NULL, 0,
&pkeyPrvCtx),
CRYPT_SUCCESS);
ASSERT_EQ(
CRYPT_EAL_DecodeFileKey(BSL_FORMAT_PEM, CRYPT_PUBKEY_SUBKEY, PKEY_PUB_FILE_PATH, NULL, 0, &pkeyPubCtx),
CRYPT_SUCCESS);
if (strcasecmp(algorithm, "RSA") == 0) {
SetRsaKeyInfo(pkeyPrvCtx);
CRYPT_RSA_PkcsV15Para pkcsv15 = { CRYPT_MD_SHA256 };
ASSERT_EQ(
CRYPT_EAL_PkeyCtrl(pkeyPrvCtx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(CRYPT_RSA_PkcsV15Para)),
0);
ASSERT_EQ(
CRYPT_EAL_PkeyCtrl(pkeyPubCtx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(CRYPT_RSA_PkcsV15Para)),
0);
}
uint32_t signLen = CRYPT_EAL_PkeyGetSignLen(pkeyPrvCtx);
uint8_t *signdata = (uint8_t *)BSL_SAL_Malloc(signLen);
ASSERT_TRUE(signdata != NULL);
uint8_t data[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09};
uint32_t dataLen = sizeof(data);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyPrvCtx, hashId, data, dataLen, signdata, &signLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkeyPubCtx, hashId, data, dataLen, signdata, signLen), CRYPT_SUCCESS);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(signdata);
CRYPT_EAL_PkeyFreeCtx(pkeyPrvCtx);
CRYPT_EAL_PkeyFreeCtx(pkeyPubCtx);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
remove(GENPKEY_PRV_FILE_PATH);
remove(PKEY_PRV_FILE_PATH);
remove(PKEY_PUB_FILE_PATH);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KEY_TC002
* @spec -
* @title 测试UT_HITLS_APP_KEY_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEY_TC002(char *algorithm, char *pkeyopt)
{
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
char *genpkeyPrv[20] = {"genpkey", "-algorithm", algorithm, "-pkeyopt", pkeyopt, "-out", GENPKEY_PRV_FILE_PATH};
char *pkeyPrv[20] = {"pkey", "-in", GENPKEY_PRV_FILE_PATH, "-out", PKEY_PRV_FILE_PATH};
ASSERT_EQ(HITLS_GenPkeyMain(7, genpkeyPrv), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_PkeyMain(5, pkeyPrv), HITLS_APP_SUCCESS);
CRYPT_EAL_ProviderRandInitCtx(NULL, CRYPT_RAND_AES128_CTR, "provider=default", NULL, 0, NULL);
CRYPT_EAL_PkeyCtx *pkeyPrvCtx = NULL;
ASSERT_EQ(CRYPT_EAL_DecodeFileKey(BSL_FORMAT_PEM, CRYPT_PRIKEY_PKCS8_UNENCRYPT, PKEY_PRV_FILE_PATH, NULL, 0,
&pkeyPrvCtx),
CRYPT_SUCCESS);
if (strcasecmp(algorithm, "RSA") == 0) {
SetRsaKeyInfo(pkeyPrvCtx);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyPrvCtx, CRYPT_CTRL_SET_RSA_OAEP_LABEL, NULL, 0), CRYPT_SUCCESS);
int32_t hashId = CRYPT_MD_SHA1;
BSL_Param oaepParam[3] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &hashId, sizeof(hashId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &hashId, sizeof(hashId), 0},
BSL_PARAM_END};
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyPrvCtx, CRYPT_CTRL_SET_RSA_RSAES_OAEP, oaepParam, 0),
CRYPT_SUCCESS);
} else if (strcasecmp(algorithm, "EC") == 0) {
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyPrvCtx, CRYPT_CTRL_GEN_ECC_PUBLICKEY, NULL, 0), CRYPT_SUCCESS);
}
uint8_t data[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09};
uint32_t dataLen = sizeof(data);
uint8_t encrypt[TMP_BUFF_LEN];
uint32_t encryptLen = TMP_BUFF_LEN;
ASSERT_EQ(CRYPT_EAL_PkeyEncrypt(pkeyPrvCtx, data, dataLen, encrypt, &encryptLen), CRYPT_SUCCESS);
uint8_t decrypt[TMP_BUFF_LEN];
uint32_t decryptLen = TMP_BUFF_LEN;
ASSERT_EQ(CRYPT_EAL_PkeyDecrypt(pkeyPrvCtx, encrypt, encryptLen, decrypt, &decryptLen), CRYPT_SUCCESS);
ASSERT_TRUE(dataLen == decryptLen);
ASSERT_TRUE(memcmp(data, decrypt, dataLen) == 0);
EXIT:
AppPrintErrorUioUnInit();
CRYPT_EAL_PkeyFreeCtx(pkeyPrvCtx);
CRYPT_EAL_RandDeinitEx(NULL);
remove(GENPKEY_PRV_FILE_PATH);
remove(PKEY_PRV_FILE_PATH);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_ENCKEY_TC001
* @spec -
* @title 测试UT_HITLS_APP_ENCKEY_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_ENCKEY_TC001(char *algorithm, char *pkeyopt, char *cipherAlg, int hashId)
{
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
char *genpkeyEncPrv[20] = {"genpkey", "-algorithm", algorithm, "-pkeyopt", pkeyopt, cipherAlg, "-pass", "pass:123456", "-out", GENPKEY_ENC_PRV_FILE_PATH};
char *pkeyEncPrv[20] = {"pkey", "-in", GENPKEY_ENC_PRV_FILE_PATH, "-passin", "pass:123456", cipherAlg, "-passout", "pass:123456", "-out", PKEY_ENC_PRV_FILE_PATH};
char *pkeyPub[20] = {"pkey", "-in", PKEY_ENC_PRV_FILE_PATH, "-passin", "pass:123456", "-pubout", "-out", PKEY_PUB_FILE_PATH};
ASSERT_EQ(HITLS_GenPkeyMain(10, genpkeyEncPrv), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_PkeyMain(10, pkeyEncPrv), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_PkeyMain(8, pkeyPub), HITLS_APP_SUCCESS);
CRYPT_RandRegist(TestSimpleRand);
CRYPT_RandRegistEx(TestSimpleRandEx);
CRYPT_EAL_PkeyCtx *pkeyEncPrvCtx = NULL;
CRYPT_EAL_PkeyCtx *pkeyPubCtx = NULL;
uint8_t pwd[] = { '1', '2', '3', '4', '5', '6' };
ASSERT_EQ(CRYPT_EAL_DecodeFileKey(BSL_FORMAT_PEM, CRYPT_PRIKEY_PKCS8_ENCRYPT, PKEY_ENC_PRV_FILE_PATH,
pwd, 6, &pkeyEncPrvCtx),
CRYPT_SUCCESS);
ASSERT_EQ(
CRYPT_EAL_DecodeFileKey(BSL_FORMAT_PEM, CRYPT_PUBKEY_SUBKEY, PKEY_PUB_FILE_PATH, NULL, 0, &pkeyPubCtx),
CRYPT_SUCCESS);
if (strcasecmp(algorithm, "RSA") == 0) {
CRYPT_RSA_PkcsV15Para pkcsv15 = { CRYPT_MD_SHA256 };
ASSERT_EQ(
CRYPT_EAL_PkeyCtrl(pkeyEncPrvCtx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(CRYPT_RSA_PkcsV15Para)),
0);
ASSERT_EQ(
CRYPT_EAL_PkeyCtrl(pkeyPubCtx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(CRYPT_RSA_PkcsV15Para)),
0);
}
uint32_t signLen = CRYPT_EAL_PkeyGetSignLen(pkeyEncPrvCtx);
uint8_t *signdata = (uint8_t *)BSL_SAL_Malloc(signLen);
ASSERT_TRUE(signdata != NULL);
uint8_t data[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09};
uint32_t dataLen = sizeof(data);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyEncPrvCtx, hashId, data, dataLen, signdata, &signLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkeyPubCtx, hashId, data, dataLen, signdata, signLen), CRYPT_SUCCESS);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(signdata);
CRYPT_EAL_PkeyFreeCtx(pkeyEncPrvCtx);
CRYPT_EAL_PkeyFreeCtx(pkeyPubCtx);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
remove(GENPKEY_ENC_PRV_FILE_PATH);
remove(PKEY_ENC_PRV_FILE_PATH);
remove(PKEY_PUB_FILE_PATH);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_ENCKEY_TC002
* @spec -
* @title 测试UT_HITLS_APP_ENCKEY_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_ENCKEY_TC002(char *algorithm, char *pkeyopt, char *cipherAlg)
{
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
char *genpkeyEncPrv[20] = {"genpkey", "-algorithm", algorithm, "-pkeyopt", pkeyopt, cipherAlg, "-pass", "pass:123456", "-out", GENPKEY_ENC_PRV_FILE_PATH};
char *pkeyEncPrv[20] = {"pkey", "-in", GENPKEY_ENC_PRV_FILE_PATH, "-passin", "pass:123456", cipherAlg, "-passout", "pass:123456", "-out", PKEY_ENC_PRV_FILE_PATH};
ASSERT_EQ(HITLS_GenPkeyMain(10, genpkeyEncPrv), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_PkeyMain(10, pkeyEncPrv), HITLS_APP_SUCCESS);
CRYPT_RandRegist(TestSimpleRand);
CRYPT_RandRegistEx(TestSimpleRandEx);
CRYPT_EAL_PkeyCtx *pkeyEncPrvCtx = NULL;
uint8_t pwd[] = { '1', '2', '3', '4', '5', '6' };
ASSERT_EQ(CRYPT_EAL_DecodeFileKey(BSL_FORMAT_PEM, CRYPT_PRIKEY_PKCS8_ENCRYPT, PKEY_ENC_PRV_FILE_PATH,
pwd, 6, &pkeyEncPrvCtx),
CRYPT_SUCCESS);
if (strcasecmp(algorithm, "RSA") == 0) {
SetRsaKeyInfo(pkeyEncPrvCtx);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyEncPrvCtx, CRYPT_CTRL_SET_RSA_OAEP_LABEL, NULL, 0), CRYPT_SUCCESS);
int32_t hashId = CRYPT_MD_SHA1;
BSL_Param oaepParam[3] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &hashId, sizeof(hashId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &hashId, sizeof(hashId), 0},
BSL_PARAM_END};
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyEncPrvCtx, CRYPT_CTRL_SET_RSA_RSAES_OAEP, oaepParam, 0),
CRYPT_SUCCESS);
} else if (strcasecmp(algorithm, "EC") == 0) {
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyEncPrvCtx, CRYPT_CTRL_GEN_ECC_PUBLICKEY, NULL, 0), CRYPT_SUCCESS);
}
uint8_t data[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09};
uint32_t dataLen = sizeof(data);
uint8_t encrypt[TMP_BUFF_LEN];
uint32_t encryptLen = TMP_BUFF_LEN;
ASSERT_EQ(CRYPT_EAL_PkeyEncrypt(pkeyEncPrvCtx, data, dataLen, encrypt, &encryptLen), CRYPT_SUCCESS);
uint8_t decrypt[TMP_BUFF_LEN];
uint32_t decryptLen = TMP_BUFF_LEN;
ASSERT_EQ(CRYPT_EAL_PkeyDecrypt(pkeyEncPrvCtx, encrypt, encryptLen, decrypt, &decryptLen), CRYPT_SUCCESS);
ASSERT_TRUE(dataLen == decryptLen);
ASSERT_TRUE(memcmp(data, decrypt, dataLen) == 0);
EXIT:
AppPrintErrorUioUnInit();
CRYPT_EAL_PkeyFreeCtx(pkeyEncPrvCtx);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
remove(GENPKEY_ENC_PRV_FILE_PATH);
remove(PKEY_ENC_PRV_FILE_PATH);
return;
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/apps/test_suite_ut_app_key.c | C | unknown | 13,362 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include "app_opt.h"
#include "app_print.h"
#include "bsl_uio.h"
#include "uio_abstraction.h"
#include "app_errno.h"
#include "crypt_errno.h"
#include "app_list.h"
#include "app_function.h"
#include "securec.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "stub_replace.h"
/* END_HEADER */
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_list.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c */
/**
* @test UT_HITLS_APP_LIST_TC001
* @spec -
* @title 测试UT_HITLS_APP_LIST_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_LIST_TC001(void)
{
char *argv[][20] = {
{"list", "-all-algorithms"},
{"list", "-digest-algorithms"},
{"list", "-cipher-algorithms"},
{"list", "-asym-algorithms"},
{"list", "-mac-algorithms"},
{"list", "-rand-algorithms"},
{"list", "-kdf-algorithms"},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_SUCCESS},
{2, argv[1], HITLS_APP_SUCCESS},
{2, argv[2], HITLS_APP_SUCCESS},
{2, argv[3], HITLS_APP_SUCCESS},
{2, argv[4], HITLS_APP_SUCCESS},
{2, argv[5], HITLS_APP_SUCCESS},
{2, argv[6], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_ListMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_LIST_TC002
* @spec -
* @title 测试UT_HITLS_APP_LIST_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_LIST_TC002(void)
{
char *argv[][20] = {
{"list", "-ttt"},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_OPT_UNKOWN},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_ListMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/apps/test_suite_ut_app_list.c | C | unknown | 2,836 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <linux/limits.h>
#include "securec.h"
#include "stub_replace.h"
#include "test.h"
#include "bsl_uio.h"
#include "bsl_types.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "sal_file.h"
#include "string.h"
#include "uio_abstraction.h"
#include "crypt_errno.h"
#include "app_opt.h"
#include "app_print.h"
#include "app_errno.h"
#include "app_function.h"
#include "app_provider.h"
#include "app_mac.h"
/* END_HEADER */
#define MAC_MAX_ARGC 22
#define MAX_BUFSIZE (1024 * 8)
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
static void PreProcArgs(char *args, int *argc, char **argv)
{
uint32_t len = strlen(args);
argv[(*argc)++] = args;
for (uint32_t i = 0; i < len; i++) {
if (args[i] == ' ') {
args[i] = '\0';
argv[(*argc)++] = args + i + 1;
}
}
if (APP_GetCurrent_LibCtx() == NULL) {
if (APP_Create_LibCtx() == NULL) {
(void)AppPrintError("Create g_libCtx failed\n");
}
}
}
static int32_t CompareOutByData(char *file1, Hex *data)
{
int ret = 1;
BSL_Buffer buff = {0};
char hexStr[2 * MAX_BUFSIZE + 1] = {0};
for (uint32_t i = 0; i < data->len; ++i) {
sprintf(hexStr + 2 * i, "%02x", data->x[i]);
}
uint32_t hexLen = strlen(hexStr);
ASSERT_EQ(BSL_SAL_ReadFile(file1, &buff.data, &buff.dataLen), 0);
ASSERT_EQ(buff.dataLen, hexLen);
ASSERT_COMPARE("Compare out data", buff.data, buff.dataLen, hexStr, hexLen);
ret = 0;
EXIT:
BSL_SAL_Free(buff.data);
return ret;
}
/**
* @test UT_HITLS_APP_MAC_InvalidOpt_TC001
* @title Test the invalid parameters of the mac command.
* @brief Enter parameters and return the error code expectRet.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_MAC_InvalidOpt_TC001(char *opts, int expectRet)
{
system("echo what do ya want for nothing? > test.txt");
int argc = 0;
char *argv[MAC_MAX_ARGC] = {0};
char *tmp = strdup(opts);
ASSERT_NE(tmp, NULL);
PreProcArgs(tmp, &argc, argv);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_MacMain(argc, argv), expectRet);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(tmp);
}
/* END_CASE */
/**
* @test UT_HITLS_APP_MAC_NormalOpt_TC001
* @title Test the normal parameters of the mac command.
* @brief Enter parameters and return HITLS_APP_SUCCESS.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_MAC_NormalOpt_TC001(char *opts, char *outFile, Hex *expectData)
{
printf("----------------------------------MAC_NormalOpt:");
int argc = 0;
char *argv[MAC_MAX_ARGC] = {0};
char *tmp = strdup(opts);
ASSERT_NE(tmp, NULL);
PreProcArgs(tmp, &argc, argv);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_MacMain(argc, argv), HITLS_APP_SUCCESS);
ASSERT_EQ(CompareOutByData(outFile, expectData), HITLS_APP_SUCCESS);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(tmp);
remove(outFile);
}
/* END_CASE */
/**
* @test UT_HITLS_APP_mac_TC002
* @spec -
* @title 测试UT_HITLS_APP_mac_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_mac_TC002(void)
{
char *argv[][10] = {
{"mac", "-help"},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_HELP},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_MacMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/apps/test_suite_ut_app_mac.c | C | unknown | 4,190 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <securec.h>
#include "app_passwd.h"
#include "app_errno.h"
#include "app_help.h"
#include "app_print.h"
#include "app_opt.h"
#include "bsl_ui.h"
#include "stub_replace.h"
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_passwd.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c */
/* END_HEADER */
#define BSL_SUCCESS 0
typedef struct {
int argc;
char **argv;
int expect;
} PasswdTestData;
int32_t STUB_BSL_UI_ReadPwdUtil(BSL_UI_ReadPwdParam *param, char *buff, uint32_t *buffLen, const BSL_UI_CheckDataCallBack checkDataCallBack, void *callBackData)
{
(void)param;
(void)checkDataCallBack;
(void)callBackData;
char result[] = "12345678";
(void)strcpy_s(buff, *buffLen, result);
*buffLen = (uint32_t)strlen(buff) + 1;
return BSL_SUCCESS;
}
/**
* @test UT_HITLS_APP_passwd_TC001
* @spec -
* @title test UT_HITLS_APP_passwd_TC001 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_passwd_TC001(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
char *argv[][10] = {
{"passwd", "-help"},
{"passwd", "-sha512"},
{"passwd", "-sha512", "-out", "PasswdOutFile"},
{"passwd", "-sha256"},
{"passwd"}
};
PasswdTestData testData[] = {
{2, argv[0], HITLS_APP_HELP},
{2, argv[1], HITLS_APP_SUCCESS},
{4, argv[2], HITLS_APP_SUCCESS},
{2, argv[3], HITLS_APP_OPT_UNKOWN},
{1, argv[4], HITLS_APP_OPT_VALUE_INVALID}
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(PasswdTestData)); ++i) {
int ret = HITLS_PasswdMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_BSL_UI_ReadPwdUtilIsZero(BSL_UI_ReadPwdParam *param, char *buff, uint32_t *buffLen, const BSL_UI_CheckDataCallBack checkDataCallBack, void *callBackData)
{
(void)param;
(void)checkDataCallBack;
(void)callBackData;
(void)buff;
(void)buffLen;
return BSL_SUCCESS;
}
int32_t STUB_BSL_UI_ReadPwdUtilIs1024(BSL_UI_ReadPwdParam *param, char *buff, uint32_t *buffLen,
const BSL_UI_CheckDataCallBack checkDataCallBack, void *callBackData)
{
(void)param;
(void)checkDataCallBack;
(void)callBackData;
char result[] =
"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"1111111111111111111111111111111111";
printf("=======%d\n", *buffLen);
(void)strcpy_s(buff, *buffLen, result);
*buffLen = (uint32_t)strlen(result) + 1;
printf("=======%d\n", *buffLen);
return BSL_SUCCESS;
}
/* *
* @test UT_HITLS_APP_passwd_TC002
* @spec -
* @title test UT_HITLS_APP_passwd_TC002 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_passwd_TC002(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtilIsZero);
char *argv[][10] = {
{"passwd", "-sha512", "-out", "PasswdOutFile"},
};
PasswdTestData testData[] = {
{4, argv[0], HITLS_APP_PASSWD_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(PasswdTestData)); ++i) {
int ret = HITLS_PasswdMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
/* *
* @test UT_HITLS_APP_passwd_TC003
* @spec -
* @title test UT_HITLS_APP_passwd_TC003 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_passwd_TC003(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtilIs1024);
char *argv[][10] = {
{"passwd", "-sha512", "-out", "PasswdOutFile"},
};
PasswdTestData testData[] = {
{4, argv[0], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(PasswdTestData)); ++i) {
int ret = HITLS_PasswdMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/apps/test_suite_ut_app_passwd.c | C | unknown | 6,159 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include "app_opt.h"
#include "app_print.h"
#include "bsl_uio.h"
#include "uio_abstraction.h"
#include "crypt_eal_rand.h"
#include "app_errno.h"
#include "bsl_base64.h"
#include "crypt_errno.h"
#include "app_pkcs12.h"
#include "app_function.h"
#include "securec.h"
#include "bsl_err.h"
#include "bsl_sal.h"
#include "bsl_ui.h"
#include "stub_replace.h"
/* END_HEADER */
#define PRI_KEY "../testdata/apps/pkcs12/server.key"
#define CERT "../testdata/apps/pkcs12/server.crt"
#define CHAIN "../testdata/apps/pkcs12/chain.crt"
#define NO_EXIST_FILE "noexistfile"
#define LARGE_FILE "../testdata/apps/x509/257k.pem"
#define EMPTY_FILE "../testdata/apps/pkcs12/empty.pem"
#define PFX "../testdata/apps/pkcs12/out.pfx"
#define NO_MACP12 "../testdata/apps/pkcs12/nomac.p12"
#define MIN_PASSWD "pass:12345678"
#define MAX_PASSWD \
"pass:" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111"
#define SHORT_PASSWD "pass:"
#define LONG_PASSWD \
"pass:" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"11111111111111111"
#define FILE_PASSWD "file:../testdata/apps/pkcs12/pass.txt"
#define PARAM_PASSWD "pass:12345678"
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_pkcs12.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c */
/**
* @test UT_HITLS_APP_PKCS12_TC001
* @spec -
* @title test UT_HITLS_APP_PKCS12_TC001 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC001(void)
{
char *argv[][16] = {
{"pkcs12", "-help"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile", CHAIN,
"-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-passout", "pass:12345678", "-out", "decode_pfx.pem"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-passout", "pass:12345678", "-out", "decode_pfx.pem", "-clcerts", "-aes256-cbc"},
{"pkcs12", "-in", NO_MACP12, "-passin", "pass:12345678", "-passout", "pass:12345678", "-out", "decode_pfx.pem", "-clcerts", "-aes256-cbc"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", FILE_PASSWD, "-chain", "-CAfile", CHAIN,
"-passout", FILE_PASSWD, "-out", "out.pfx"},
{"pkcs12", "-in", "out.pfx", "-passin", FILE_PASSWD, "-passout", FILE_PASSWD, "-out", "decode_pfx.pem"},
{"pkcs12", "-in", "out.pfx", "-passin", PARAM_PASSWD, "-passout", PARAM_PASSWD, "-out", "decode_pfx.pem"},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_HELP},
{15, argv[1], HITLS_APP_SUCCESS},
{9, argv[2], HITLS_APP_SUCCESS},
{11, argv[3], HITLS_APP_SUCCESS},
{11, argv[4], HITLS_APP_SUCCESS},
{15, argv[5], HITLS_APP_SUCCESS},
{9, argv[6], HITLS_APP_SUCCESS},
{9, argv[7], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PKCS12Main(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKCS12_TC002
* @spec -
* @title test UT_HITLS_APP_PKCS12_TC002 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC002(void)
{
char *argv[][16] = {
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-chain", "-CAfile", CHAIN,
"-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-chain", "-CAfile", CHAIN,
"-passout", SHORT_PASSWD, "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-chain", "-CAfile", CHAIN,
"-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-chain", "-CAfile", CHAIN,
"-passout", LONG_PASSWD, "-out", "out.pfx"},
{"pkcs12", "-in", PFX, "-passin", SHORT_PASSWD, "-passout", "pass:12345678", "-out", "decode_pfx.pem"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-passout", SHORT_PASSWD, "-out", "decode_pfx.pem"},
{"pkcs12", "-in", PFX, "-passin", LONG_PASSWD, "-passout", "pass:12345678", "-out", "decode_pfx.pem"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-passout", LONG_PASSWD, "-out", "decode_pfx.pem"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-chain", "-CAfile", CHAIN,
"-passout", MIN_PASSWD, "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-chain", "-CAfile", CHAIN,
"-passout", MAX_PASSWD, "-out", "out.pfx"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-passout", MIN_PASSWD, "-out", "decode_pfx.pem"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-passout", MAX_PASSWD, "-out", "decode_pfx.pem"},
};
OptTestData testData[] = {
{13, argv[0], HITLS_APP_SUCCESS},
{13, argv[1], HITLS_APP_PASSWD_FAIL},
{13, argv[2], HITLS_APP_SUCCESS},
{13, argv[3], HITLS_APP_PASSWD_FAIL},
{9, argv[4], HITLS_APP_PASSWD_FAIL},
{9, argv[5], HITLS_APP_PASSWD_FAIL},
{9, argv[6], HITLS_APP_PASSWD_FAIL},
{9, argv[7], HITLS_APP_PASSWD_FAIL},
{13, argv[8], HITLS_APP_SUCCESS},
{13, argv[9], HITLS_APP_SUCCESS},
{9, argv[10], HITLS_APP_SUCCESS},
{9, argv[11], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PKCS12Main(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKCS12_TC003
* @spec -
* @title Test UT_HITLS_APP_PKCS12_TC003 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC003(void)
{
char *argv[][16] = {
{"pkcs12", "-export", "-in", NO_EXIST_FILE, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", NO_EXIST_FILE, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
NO_EXIST_FILE, "-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-in", NO_EXIST_FILE, "-passin", "pass:12345678", "-passout", "pass:12345678", "-out", "decode.pem"},
{"pkcs12", "-export", "-in", EMPTY_FILE, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", EMPTY_FILE, "-passin", "pass:12345678", "-chain", "-CAfile", CHAIN,
"-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
EMPTY_FILE, "-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-in", EMPTY_FILE, "-passin", "pass:12345678", "-passout", "pass:12345678", "-out", "decode.pem"},
{"pkcs12", "-export", "-in", LARGE_FILE, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", LARGE_FILE, "-passin", "pass:12345678", "-chain", "-CAfile", CHAIN,
"-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
LARGE_FILE, "-passout", "pass:12345678", "-out", "out.pfx"},
};
OptTestData testData[] = {
{15, argv[0], HITLS_APP_BSL_FAIL},
{15, argv[1], HITLS_APP_BSL_FAIL},
{15, argv[2], HITLS_APP_BSL_FAIL},
{9, argv[3], HITLS_APP_BSL_FAIL},
{15, argv[4], HITLS_APP_X509_FAIL},
{15, argv[5], HITLS_APP_LOAD_KEY_FAIL},
{15, argv[6], HITLS_APP_X509_FAIL},
{9, argv[7], HITLS_APP_X509_FAIL},
{15, argv[8], HITLS_APP_UIO_FAIL},
{15, argv[9], HITLS_APP_UIO_FAIL},
{15, argv[10], HITLS_APP_UIO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PKCS12Main(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKCS12_TC004
* @spec -
* @title Test UT_HITLS_APP_PKCS12_TC004 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC004(void)
{
char *argv[][18] = {
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-keypbe", "PBE-SHA1-RC4-128"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-keypbe", "PBE-SHA1-RC4-40"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-keypbe", "PBE-SHA1-RC2-128"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-keypbe", "PBE-SHA1-3DES"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-keypbe", "PBES2"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-keypbe", "INVALID_ALG"},
};
OptTestData testData[] = {
{17, argv[0], HITLS_APP_OPT_VALUE_INVALID},
{17, argv[1], HITLS_APP_OPT_VALUE_INVALID},
{17, argv[2], HITLS_APP_OPT_VALUE_INVALID},
{17, argv[3], HITLS_APP_OPT_VALUE_INVALID},
{17, argv[4], HITLS_APP_SUCCESS},
{17, argv[5], HITLS_APP_OPT_VALUE_INVALID},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PKCS12Main(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKCS12_TC005
* @spec -
* @title Test UT_HITLS_APP_PKCS12_TC005 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC005(void)
{
char *argv[][18] = {
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-certpbe", "PBE-SHA1-RC4-128"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-certpbe", "PBE-SHA1-RC4-40"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-certpbe", "PBE-SHA1-RC2-128"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-certpbe", "PBE-SHA1-3DES"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-certpbe", "PBES2"},
};
OptTestData testData[] = {
{17, argv[0], HITLS_APP_OPT_VALUE_INVALID},
{17, argv[1], HITLS_APP_OPT_VALUE_INVALID},
{17, argv[2], HITLS_APP_OPT_VALUE_INVALID},
{17, argv[3], HITLS_APP_OPT_VALUE_INVALID},
{17, argv[4], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PKCS12Main(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKCS12_TC006
* @spec -
* @title Test UT_HITLS_APP_PKCS12_TC006 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC006(void)
{
char *argv[][18] = {
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-macalg", "sha224"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-macalg", "INVALID_ALG"},
};
OptTestData testData[] = {
{17, argv[0], HITLS_APP_SUCCESS},
{17, argv[1], HITLS_APP_OPT_VALUE_INVALID},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PKCS12Main(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKCS12_TC007
* @spec -
* @title Test UT_HITLS_APP_PKCS12_TC007 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC007(void)
{
char invalidName[2048] = {0};
(void)memset_s(invalidName, sizeof(invalidName) - 1, 'a', sizeof(invalidName) - 1);
char *argv[][18] = {
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-name", "testname"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-name"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-name", invalidName},
};
OptTestData testData[] = {
{17, argv[0], HITLS_APP_SUCCESS},
{16, argv[1], HITLS_APP_OPT_UNKOWN},
{17, argv[2], HITLS_APP_OPT_VALUE_INVALID},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PKCS12Main(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKCS12_TC008
* @spec -
* @title Test UT_HITLS_APP_PKCS12_TC008 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC008(void)
{
char *validPwd = "file:../testdata/apps/pass/size_1024_pass";
char *invalidPwd = "file:../testdata/apps/pass/size_1025_pass";
char *emptyPwd = "file:../testdata/apps/pass/empty_pass";
char *argv[][18] = {
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", validPwd, "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", invalidPwd, "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", emptyPwd, "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "file:noexistfile", "-out", "out.pfx"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-passout", validPwd, "-out", "decode_pfx.pem"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-passout", invalidPwd, "-out", "decode_pfx.pem"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-passout", emptyPwd, "-out", "decode_pfx.pem"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-passout", "file:noexistfile", "-out", "decode_pfx.pem"},
};
OptTestData testData[] = {
{15, argv[0], HITLS_APP_SUCCESS},
{15, argv[1], HITLS_APP_PASSWD_FAIL},
{15, argv[2], HITLS_APP_PASSWD_FAIL},
{15, argv[3], HITLS_APP_PASSWD_FAIL},
{9, argv[4], HITLS_APP_SUCCESS},
{9, argv[5], HITLS_APP_PASSWD_FAIL},
{9, argv[6], HITLS_APP_PASSWD_FAIL},
{9, argv[7], HITLS_APP_PASSWD_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PKCS12Main(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
static int32_t BSL_UI_ReadPwdUtil_Mock(BSL_UI_ReadPwdParam *param, char *buff, uint32_t *buffLen,
const BSL_UI_CheckDataCallBack checkDataCallBack, void *callBackData)
{
(void)param;
(void)checkDataCallBack;
(void)callBackData;
(void)memcpy_s(buff, *buffLen, "12345678", strlen("12345678"));
*buffLen = strlen("12345678") + 1;
return HITLS_APP_SUCCESS;
}
/**
* @test UT_HITLS_APP_PKCS12_TC009
* @spec -
* @title Test UT_HITLS_APP_PKCS12_TC009 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC009(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UI_ReadPwdUtil, BSL_UI_ReadPwdUtil_Mock);
char *argv[][18] = {
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-out", "out.pfx"},
{"pkcs12", "-in", PFX, "-passout", "pass:12345678", "-out", "decode_pfx.pem"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-out", "decode_pfx.pem"},
};
OptTestData testData[] = {
{13, argv[0], HITLS_APP_SUCCESS},
{13, argv[1], HITLS_APP_SUCCESS},
{7, argv[2], HITLS_APP_SUCCESS},
{7, argv[3], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PKCS12Main(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
static void SplitArgs(char *str, char **result, int *count) {
char *token;
token = strtok(str, " ");
while (token != NULL) {
result[*count] = token;
(*count)++;
token = strtok(NULL, " ");
}
}
/**
* @test UT_HITLS_APP_PKCS12_TC010
* @spec -
* @title Test HITLS_PKCS12Main function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC010(char *arg, int expect)
{
char *argv[30] = {};
int argc = 0;
SplitArgs(arg, argv, &argc);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
int ret = HITLS_PKCS12Main(argc, argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, expect);
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
int32_t STUB_CRYPT_EAL_RandInit(
CRYPT_EAL_LibCtx *libCtx, int32_t algId, const char *attrName,
const uint8_t *pers, uint32_t persLen, BSL_Param *param)
{
(void)libCtx;
(void)algId;
(void)attrName;
(void)pers;
(void)persLen;
(void)param;
return CRYPT_EAL_ERR_DRBG_INIT_FAIL;
}
/**
* @test UT_HITLS_APP_PKCS12_TC011
* @spec -
* @title Test HITLS_PKCS12Main function init rand failed
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC011(char *arg, int expect)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, CRYPT_EAL_ProviderRandInitCtx, STUB_CRYPT_EAL_RandInit);
char *argv[30] = {};
int argc = 0;
SplitArgs(arg, argv, &argc);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
int ret = HITLS_PKCS12Main(argc, argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, expect);
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKCS12_TC012
* @spec -
* @title Test HITLS_PKCS12Main function file pass
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC012(char *passFile, char *passArg, int expect)
{
char *argv[][16] = {
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-chain", "-CAfile", CHAIN,
"-passout", passFile, "-out", "out.pfx"},
{"pkcs12", "-in", "out.pfx", "-passin", passArg, "-passout", passArg, "-out", "decode_pfx.pem"},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
int32_t ret = HITLS_PKCS12Main(13, argv[0]);
ASSERT_EQ(ret, expect);
if (expect == HITLS_APP_SUCCESS) {
ASSERT_EQ(HITLS_PKCS12Main(9, argv[1]), expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/apps/test_suite_ut_app_pkcs12.c | C | unknown | 24,939 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "app_opt.h"
#include "app_print.h"
#include "sal_file.h"
#include "bsl_uio.h"
#include "bsl_ui.h"
#include "uio_abstraction.h"
#include "app_errno.h"
#include "crypt_errno.h"
#include "app_pkey.h"
#include "app_function.h"
#include "securec.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "stub_replace.h"
/* END_HEADER */
#define BAD_KEY_PATH "../testdata/apps/pkey/bad_rsa.pem"
#define PKEY_TEST_FILE_PATH "out_test.pem"
#define PKEY_TEST_DIR_PATH "./pkey_dir"
#define PKEY_MAX_ARGC 10
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
static void PreProcArgs(char *args, int *argc, char **argv)
{
uint32_t len = strlen(args);
argv[(*argc)++] = args;
for (uint32_t i = 0; i < len; i++) {
if (args[i] == ' ') {
args[i] = '\0';
argv[(*argc)++] = args + i + 1;
}
}
}
static int32_t CompareOutByData(char *file1, Hex *data)
{
int ret = 1;
BSL_Buffer buff = {0};
ASSERT_EQ(BSL_SAL_ReadFile(file1, &buff.data, &buff.dataLen), 0);
ASSERT_EQ(buff.dataLen, data->len);
ASSERT_COMPARE("Compare out data", buff.data, buff.dataLen, data->x, data->len);
ret = 0;
EXIT:
BSL_SAL_Free(buff.data);
return ret;
}
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_pkey.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c */
/**
* @test UT_HITLS_APP_PKEY_TC001
* @spec -
* @title 测试UT_HITLS_APP_PKEY_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKEY_TC001(char *encKeyPath)
{
char *argv[][20] = {
{"pkey", "-in", encKeyPath, "-passin", "pass:123456"},
{"pkey", "-in", encKeyPath, "-passin", "pass:123456", "-out", PKEY_TEST_FILE_PATH},
{"pkey", "-in", encKeyPath, "-passin", "pass:123456", "-aes256-cbc", "-passout", "pass:123456"},
{"pkey", "-in", encKeyPath, "-passin", "pass:123456", "-aes256-cbc", "-passout", "pass:123456",
"-out", PKEY_TEST_FILE_PATH},
{"pkey", "-in", encKeyPath, "-passin", "pass:123456", "-pubout"},
{"pkey", "-in", encKeyPath, "-passin", "pass:123456", "-out", PKEY_TEST_FILE_PATH},
};
OptTestData testData[] = {
{5, argv[0], HITLS_APP_SUCCESS},
{7, argv[1], HITLS_APP_SUCCESS},
{8, argv[2], HITLS_APP_SUCCESS},
{10, argv[3], HITLS_APP_SUCCESS},
{6, argv[4], HITLS_APP_SUCCESS},
{7, argv[5], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PkeyMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
remove(PKEY_TEST_FILE_PATH);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKEY_TC002
* @spec -
* @title 测试UT_HITLS_APP_PKEY_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKEY_TC002(char *keyPath)
{
char *argv[][20] = {
{"pkey", "-in", keyPath},
{"pkey", "-in", keyPath, "-out", PKEY_TEST_FILE_PATH},
{"pkey", "-in", keyPath, "-pubout"},
{"pkey", "-in", keyPath, "-pubout", "-out", PKEY_TEST_FILE_PATH},
};
OptTestData testData[] = {
{3, argv[0], HITLS_APP_SUCCESS},
{5, argv[1], HITLS_APP_SUCCESS},
{4, argv[2], HITLS_APP_SUCCESS},
{6, argv[3], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PkeyMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
remove(PKEY_TEST_FILE_PATH);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKEY_TC003
* @spec -
* @title 测试UT_HITLS_APP_PKEY_TC003函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKEY_TC003(char *encKeyPath, char *keyPath)
{
mkdir(PKEY_TEST_DIR_PATH, 0775);
char *argv[][20] = {
{"pkey", "-ttt"},
{"pkey", "-in", "no_exist.pem"},
{"pkey", "-in", BAD_KEY_PATH},
{"pkey", "-in", encKeyPath, "-passin", "err:12"},
{"pkey", "-in", encKeyPath, "-passin", "pass:"},
{"pkey", "-in", keyPath, "-passout", "err:12"},
{"pkey", "-in", keyPath, "-aes256-cbc", "-passout", "pass:"},
{"pkey", "-in", keyPath, "-out", PKEY_TEST_DIR_PATH},
{"pkey", "-in", keyPath, "-pubout", "-out", PKEY_TEST_DIR_PATH},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_OPT_UNKOWN},
{3, argv[1], HITLS_APP_LOAD_KEY_FAIL},
{3, argv[2], HITLS_APP_LOAD_KEY_FAIL},
{5, argv[3], HITLS_APP_PASSWD_FAIL},
{5, argv[4], HITLS_APP_LOAD_KEY_FAIL},
{5, argv[5], HITLS_APP_PASSWD_FAIL},
{6, argv[6], HITLS_APP_PASSWD_FAIL},
{5, argv[7], HITLS_APP_UIO_FAIL},
{6, argv[8], HITLS_APP_UIO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PkeyMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
rmdir(PKEY_TEST_DIR_PATH);
remove(PKEY_TEST_FILE_PATH);
return;
}
/* END_CASE */
static int32_t BSL_UI_ReadPwdUtil_Mock(BSL_UI_ReadPwdParam *param, char *buff, uint32_t *buffLen,
const BSL_UI_CheckDataCallBack checkDataCallBack, void *callBackData)
{
(void)param;
(void)checkDataCallBack;
(void)callBackData;
(void)buff;
(void)buffLen;
return HITLS_APP_PASSWD_FAIL;
}
/**
* @test UT_HITLS_APP_PKEY_TC004
* @spec -
* @title 测试UT_HITLS_APP_PKEY_TC004函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKEY_TC004(char *encKeyPath, char *keyPath)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UI_ReadPwdUtil, BSL_UI_ReadPwdUtil_Mock);
char *argv[][20] = {
{"pkey", "-in", keyPath, "-passin", "pass:"},
{"pkey", "-in", keyPath, "-passin", "stdin"},
{"pkey", "-in", keyPath, "-passout", "pass:"},
{"pkey", "-in", keyPath, "-passout", "stdin"},
{"pkey", "-in", encKeyPath, "-passin", "pass:"},
{"pkey", "-in", encKeyPath, "-passin", "stdin"},
{"pkey", "-in", encKeyPath},
{"pkey", "-in", keyPath, "-aes256-cbc", "-passout", "pass:"},
{"pkey", "-in", keyPath, "-aes256-cbc", "-passout", "stdin"},
{"pkey", "-in", keyPath, "-aes256-cbc"},
};
OptTestData testData[] = {
{5, argv[0], HITLS_APP_SUCCESS},
{5, argv[1], HITLS_APP_SUCCESS},
{5, argv[2], HITLS_APP_SUCCESS},
{5, argv[3], HITLS_APP_SUCCESS},
{5, argv[4], HITLS_APP_LOAD_KEY_FAIL},
{5, argv[5], HITLS_APP_LOAD_KEY_FAIL},
{3, argv[6], HITLS_APP_LOAD_KEY_FAIL},
{6, argv[7], HITLS_APP_PASSWD_FAIL},
{6, argv[8], HITLS_APP_PASSWD_FAIL},
{4, argv[9], HITLS_APP_PASSWD_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PkeyMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
remove(PKEY_TEST_FILE_PATH);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKEY_IN_FILE_SIZE_TC001
* @title Test the limit size of input key file.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKEY_IN_FILE_SIZE_TC001(char *opts, int ret, char *outFile, Hex *expectOut)
{
int argc = 0;
char *argv[PKEY_MAX_ARGC] = {0};
char *tmp = strdup(opts);
ASSERT_NE(tmp, NULL);
PreProcArgs(tmp, &argc, argv);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_PkeyMain(argc, argv), ret);
if (ret == 0) {
ASSERT_EQ(CompareOutByData(outFile, expectOut), HITLS_APP_SUCCESS);
}
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(tmp);
// remove(outFile);
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/apps/test_suite_ut_app_pkey.c | C | unknown | 9,075 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include "app_opt.h"
#include "app_print.h"
#include "bsl_uio.h"
#include "uio_abstraction.h"
#include "app_errno.h"
#include "crypt_errno.h"
#include "app_req.h"
#include "app_function.h"
#include "securec.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "stub_replace.h"
/* END_HEADER */
static void SplitArgs(char *str, char **result, int *count) {
char *token;
token = strtok(str, " ");
while (token != NULL) {
result[*count] = token;
(*count)++;
token = strtok(NULL, " ");
}
}
/**
* @test UT_HITLS_APP_REQ_TC001
* @spec -
* @title 测试UT_HITLS_APP_REQ_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_REQ_TC001(char *arg, int expect)
{
char *argv[20] = {};
int argc = 0;
SplitArgs(arg, argv, &argc);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
int ret = HITLS_ReqMain(argc, argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, expect);
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/apps/test_suite_ut_app_req.c | C | unknown | 1,614 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <termios.h>
#include <unistd.h>
#include "securec.h"
#include "app_opt.h"
#include "app_print.h"
#include "app_utils.h"
#include "bsl_uio.h"
#include "app_errno.h"
#include "app_rsa.h"
#include "app_function.h"
#include "bsl_sal.h"
#include "bsl_err.h"
#include "app_rsa.h"
#include "stub_replace.h"
#include "app_utils.h"
#include "bsl_types.h"
#include "crypt_eal_codecs.h"
#include "crypt_errno.h"
/* END_HEADER */
#define PRV_PATH "../testdata/certificate/rsa_key/prvKey.pem"
#define PRV_PASSWD_PATH "../testdata/cert/asn1/keypem/rsa-pri-key-p8-2048.pem"
#define PRV_DER_PATH "../testdata/cert/asn1/rsa2048key_pkcs1.der"
#define OUT_FILE_PATH "../testdata/certificate/rsa_key/out.pem"
typedef struct {
int32_t outformat;
bool text;
bool noout;
char *outfile;
} OutputInfo;
typedef struct {
int argc;
char **argv;
int expect;
} RsaTestData;
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_rsa.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c */
/**
* @test UT_HITLS_APP_rsa_TC001
* @spec -
* @title 测试UT_HITLS_APP_rsa_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_TC001(void)
{
char *argv[][10] = {
{"rsa", "-in", PRV_PATH, "-noout"},
{"rsa", "-in", PRV_PATH, "-out", OUT_FILE_PATH},
{"rsa", "-in", PRV_PATH, "-out", OUT_FILE_PATH, "-text"},
{"rsa", "-in", PRV_PATH, "-out", OUT_FILE_PATH, "-text", "-noout"},
{"rsa", "-in", PRV_PATH, "-out", "/test/noexist/out.pem"},
{"rsa", "-in", "noexist.pem", "-text"}};
RsaTestData testData[] = {{4, argv[0], HITLS_APP_SUCCESS},
{5, argv[1], HITLS_APP_SUCCESS},
{6, argv[2], HITLS_APP_SUCCESS},
{7, argv[3], HITLS_APP_SUCCESS},
{5, argv[4], HITLS_APP_UIO_FAIL},
{4, argv[5], HITLS_APP_UIO_FAIL}
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_rsa_T002
* @spec -
* @title 测试UT_HITLS_APP_rsa_T002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_TC002(void)
{
char *argv[][2] = {
{"rsa", "-help"},
};
RsaTestData testData[] = {
{2, argv[0], HITLS_APP_HELP},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
int32_t STUB_HITLS_APP_OptBegin(int32_t argc, char **argv, const HITLS_CmdOption *opts)
{
(void)argc;
(void)argv;
(void)opts;
return HITLS_APP_OPT_UNKOWN;
}
/**
* @test UT_HITLS_APP_rsa_T003
* @spec -
* @title 测试UT_HITLS_APP_rsa_T003函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_T003(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptBegin, STUB_HITLS_APP_OptBegin);
char *argv[][4] = {{"rsa", "-in", PRV_PATH, "-noout"}};
RsaTestData testData[] = {
{4, argv[0], HITLS_APP_OPT_UNKOWN},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_CRYPT_EAL_DecodeBuffKey(BSL_ParseFormat format, int32_t type, BSL_Buffer *encode,
uint8_t *pwd, uint32_t pwdlen, CRYPT_EAL_PkeyCtx **ealPKey)
{
(void)format;
(void)type;
(void)encode;
(void)pwd;
(void)pwdlen;
(void)ealPKey;
return HITLS_APP_DECODE_FAIL;
}
/**
* @test UT_HITLS_APP_rsa_T004
* @spec -
* @title 测试UT_HITLS_APP_rsa_T004函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_T004(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, CRYPT_EAL_DecodeBuffKey, STUB_CRYPT_EAL_DecodeBuffKey);
char *argv[][10] = {{"rsa", "-in", PRV_PATH, "-noout"}};
RsaTestData testData[] = {
{4, argv[0], HITLS_APP_DECODE_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
BSL_UIO *STUB_BSL_UIO_New(const BSL_UIO_Method *method)
{
(void)method;
return NULL;
}
/**
* @test UT_HITLS_APP_rsa_T005
* @spec -
* @title 测试UT_HITLS_APP_rsa_T005函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_T005(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UIO_New, STUB_BSL_UIO_New);
char *argv[][10] = {{"rsa", "-in", PRV_PATH, "-noout"}};
RsaTestData testData[] = {
{4, argv[0], HITLS_APP_UIO_FAIL},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_BSL_UIO_Ctrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *parg)
{
(void)uio;
(void)cmd;
(void)larg;
(void)parg;
return BSL_NULL_INPUT;
}
/**
* @test UT_HITLS_APP_rsa_T006
* @spec -
* @title 测试UT_HITLS_APP_rsa_T006函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_T006(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UIO_Ctrl, STUB_BSL_UIO_Ctrl);
char *argv[][10] = {{"rsa", "-in", PRV_PATH, "-noout"}};
RsaTestData testData[] = {
{4, argv[0], HITLS_APP_UIO_FAIL},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
char *STUB_HITLS_APP_OptGetValueStr(void)
{
return NULL;
}
/**
* @test UT_HITLS_APP_rsa_T007
* @spec -
* @title 测试UT_HITLS_APP_rsa_T007函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_T007(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptGetValueStr, STUB_HITLS_APP_OptGetValueStr);
char *argv[][10] = {{"rsa", "-in", PRV_PATH, "-noout"}};
RsaTestData testData[] = {
{4, argv[0], HITLS_APP_OPT_VALUE_INVALID},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_HITLS_APP_OptWriteUio(BSL_UIO *uio, uint8_t *buf, uint32_t outLen, int32_t format)
{
(void)uio;
(void)buf;
(void)outLen;
(void)format;
return HITLS_APP_UIO_FAIL;
}
/**
* @test UT_HITLS_APP_rsa_T008
* @spec -
* @title 测试UT_HITLS_APP_rsa_T008函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_T008(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptWriteUio, STUB_HITLS_APP_OptWriteUio);
char *argv[][10] = {{"rsa", "-in", PRV_PATH, "-text"}};
RsaTestData testData[] = {
{4, argv[0], HITLS_APP_UIO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
bool IsFileExist(const char *fileName)
{
FILE *f = fopen(fileName, "r");
if (f == NULL) {
return false;
}
fclose(f);
return true;
}
/**
* @test UT_HITLS_APP_rsa_T009
* @spec -
* @title 测试UT_HITLS_APP_rsa_T009函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_T009(void)
{
char *filename = "_APP_rsa_T009.txt";
char *argv[][10] = {{"rsa", "-in", PRV_PATH, "-out", filename}};
RsaTestData testData[] = {{5, argv[0], HITLS_APP_SUCCESS}};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
ASSERT_TRUE(IsFileExist(filename) == false);
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
ASSERT_TRUE(IsFileExist(filename));
remove(filename);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
int32_t STUB_CRYPT_EAL_EncodeBuffKey(CRYPT_EAL_PkeyCtx *ealPKey, CRYPT_EncodeParam *encodeParam,
BSL_ParseFormat format, int32_t type, BSL_Buffer *encode)
{
(void)ealPKey;
(void)encodeParam;
(void)format;
(void)type;
(void)encode;
return HITLS_APP_UIO_FAIL;
}
/**
* @test UT_HITLS_APP_rsa_T0010
* @spec -
* @title 测试UT_HITLS_APP_rsa_T0010函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_T0010(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, CRYPT_EAL_EncodeBuffKey, STUB_CRYPT_EAL_EncodeBuffKey);
char *argv[][10] = {{"rsa", "-in", PRV_PATH}};
RsaTestData testData[] = {
{3, argv[0], HITLS_APP_UIO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_HITLS_APP_Passwd(char *buf, int32_t bufMaxLen, int32_t flag, void *userdata)
{
(void)userdata;
(void)flag;
(void)memcpy_s(buf, bufMaxLen, "123456", 6);
return 6;
}
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_T0011(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_Passwd, STUB_HITLS_APP_Passwd);
char *argv[][10] = {
{"rsa", "-in", PRV_PASSWD_PATH, "-noout"},
{"rsa", "-in", PRV_DER_PATH, "-noout"},
};
RsaTestData testData[] = {
{4, argv[0], HITLS_APP_SUCCESS},
{4, argv[1], HITLS_APP_DECODE_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
if (ret != testData[i].expect) {
printf("I is %d\n", i);
}
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_TC012(void)
{
char *argv[][10] = {
{"rsa", "-in", PRV_PATH},
{"rsa", "-in", PRV_PATH, "-noout"},
{"rsa", "-in", PRV_PATH, "-text"},
{"rsa", "-in", PRV_PATH, "-noout", "-text"},
{"rsa", "-in", PRV_PATH, "-out", "out4.pem"},
{"rsa", "-in", PRV_PATH, "-noout", "-out", "out5.pem"},
{"rsa", "-in", PRV_PATH, "-text", "-out", "out6.pem"},
{"rsa", "-in", PRV_PATH, "-noout", "-text", "-out", "out7.pem"},
};
RsaTestData testData[] = {
{3, argv[0], HITLS_APP_SUCCESS},
{4, argv[1], HITLS_APP_SUCCESS},
{4, argv[2], HITLS_APP_SUCCESS},
{5, argv[3], HITLS_APP_SUCCESS},
{5, argv[4], HITLS_APP_SUCCESS},
{6, argv[5], HITLS_APP_SUCCESS},
{6, argv[6], HITLS_APP_SUCCESS},
{7, argv[7], HITLS_APP_SUCCESS},
};
int ret;
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/apps/test_suite_ut_app_rsa.c | C | unknown | 13,916 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "app_verify.h"
#include <linux/limits.h>
#include <stdbool.h>
#include "string.h"
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_errno.h"
#include "app_function.h"
#include "bsl_list.h"
#include "app_errno.h"
#include "app_opt.h"
#include "app_help.h"
#include "app_print.h"
#include "app_utils.h"
#include "stub_replace.h"
/* END_HEADER */
#define MAX_CRLFILE_SIZE (256 * 1024)
#define CAFILE_PATH "../testdata/certificate/VerifyCAfile/root_trust.ca"
#define EMPTY_CAFILE_PATH "../testdata/certificate/VerifyCAfile/emptyRoot.ca"
#define ROOT256K_CAFILE_PATH "../testdata/certificate/VerifyCAfile/root256K.ca"
#define ROOT255K_CAFILE_PATH "../testdata/certificate/VerifyCAfile/root255k.ca"
#define MISTAKE_CA_FILEPATH "../testdata/certificate/VerifyCAfile/mistakeCA.ca"
#define MID_CA_FILEPATH "../testdata/certificate/VerifyCAfile/middle_ca.pem"
#define CERT_PATH "../testdata/certificate/VerifyCAfile/future.pem"
#define EMPTY_CERT_PATH "../testdata/certificate/VerifyCAfile/emptyCert.ca"
#define CERT_256K_FILEPATH "../testdata/certificate/VerifyCAfile/256kfuture.pem"
#define CERT_257K_FILEPATH "../testdata/certificate/VerifyCAfile/257kfuture.pem"
#define MISTAKE_CERT_PATH "../testdata/certificate/VerifyCAfile/mistakeCert.pem"
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_verify.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c */
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
/**
* @test UT_HITLS_APP_Verify_TC001
* @spec -
* @title Test the UT_HITLS_APP_Verify_TC001 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_verify_TC001(void)
{
char *argv[][100] = {
{"verify", "-CAfile", CAFILE_PATH, CERT_PATH},
};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_VerifyMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_verify_TC002
* @spec -
* @title Test the UT_HITLS_APP_verify_TC002 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_verify_TC002(void)
{
char *argv[][2] = {
{"verify", "-help"},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_HELP},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_VerifyMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
int32_t STUB_HITLS_APP_OptBegin(int32_t argc, char **argv, const HITLS_CmdOption *opts)
{
(void)argc;
(void)argv;
(void)opts;
return HITLS_APP_OPT_UNKOWN;
}
/**
* @test UT_HITLS_APP_verify_TC003
* @spec -
* @title Test the UT_HITLS_APP_verify_TC003 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_verify_TC003(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptBegin, STUB_HITLS_APP_OptBegin);
char *argv[][100] = {
{"verify", "-CAfile", CAFILE_PATH, CERT_PATH},
};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_OPT_UNKOWN},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_VerifyMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_BSL_UIO_Ctrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *parg)
{
(void)uio;
(void)cmd;
(void)larg;
(void)parg;
return BSL_UIO_FAIL;
}
char *STUB_HITLS_APP_OptGetValueStr(void)
{
return NULL;
}
/**
* @test UT_HITLS_APP_verify_TC005
* @spec -
* @title Test the UT_HITLS_APP_verify_TC005 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_verify_TC005(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptGetValueStr, STUB_HITLS_APP_OptGetValueStr);
char *argv[][100] = {{"verify", "-CAfile", CAFILE_PATH, CERT_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_OPT_VALUE_INVALID},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_VerifyMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_HITLS_X509_CertMulParseFile(int32_t format, const char *path, HITLS_X509_List **certlist)
{
(void)format;
(void)path;
(void)certlist;
return HITLS_APP_DECODE_FAIL;
}
/* *
* @test UT_HITLS_APP_verify_TC006
* @spec -
* @title Test the UT_HITLS_APP_verify_TC006 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_verify_TC006(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_X509_CertParseBundleFile, STUB_HITLS_X509_CertMulParseFile);
char *argv[][100] = {{"verify", "-CAfile", CAFILE_PATH, CERT_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_X509_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_VerifyMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_HITLS_X509_StoreCtxCtrl(HITLS_X509_StoreCtx *storeCtx, int32_t cmd, void *val, uint32_t valLen)
{
if (cmd == HITLS_X509_STORECTX_DEEP_COPY_SET_CA) {
return HITLS_APP_DECODE_FAIL;
}
(void)storeCtx;
(void)val;
(void)valLen;
return HITLS_APP_SUCCESS;
}
/**
* @test UT_HITLS_APP_verify_TC008
* @spec -
* @titleTest UT_HITLS_APP_verify_TC008 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_verify_TC008(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_X509_StoreCtxCtrl, STUB_HITLS_X509_StoreCtxCtrl);
char *argv[][100] = {{"verify", "-CAfile", CAFILE_PATH, CERT_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_X509_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_VerifyMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
HITLS_X509_StoreCtx *STUB_HITLS_X509_StoreCtxNew(void)
{
return NULL;
}
/**
* @test UT_HITLS_APP_verify_TC009
* @spec -
* @titleTest UT_HITLS_APP_verify_TC009 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_verify_TC009(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_X509_StoreCtxNew, STUB_HITLS_X509_StoreCtxNew);
char *argv[][100] = {{"verify", "-CAfile", CAFILE_PATH, CERT_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_X509_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_VerifyMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_HITLS_X509_CertVerify(HITLS_X509_StoreCtx *storeCtx, HITLS_X509_List *chain)
{
(void)storeCtx;
(void)chain;
return HITLS_APP_X509_FAIL;
}
/**
* @test UT_HITLS_APP_verify_TC0010
* @spec -
* @titleTest UT_HITLS_APP_verify_TC0012 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_verify_TC0010(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_X509_CertVerify, STUB_HITLS_X509_CertVerify);
char *argv[][50] = {{"verify", "-CAfile", CAFILE_PATH, CERT_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_X509_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_VerifyMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/apps/test_suite_ut_app_verify.c | C | unknown | 9,411 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include "securec.h"
#include "stub_replace.h"
#include "test.h"
#include "bsl_uio.h"
#include "bsl_types.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "sal_file.h"
#include "uio_abstraction.h"
#include "crypt_errno.h"
#include "app_opt.h"
#include "app_print.h"
#include "app_errno.h"
#include "app_function.h"
#include "app_x509.h"
/* END_HEADER */
#define X509_MAX_ARGC 22
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
static void PreProcArgs(char *args, int *argc, char **argv)
{
uint32_t len = strlen(args);
argv[(*argc)++] = args;
for (uint32_t i = 0; i < len; i++) {
if (args[i] == ' ') {
args[i] = '\0';
argv[(*argc)++] = args + i + 1;
}
}
}
static int32_t CompareOutByFile(char *file1, char *file2)
{
int ret = 1;
BSL_Buffer buff1 = {0};
BSL_Buffer buff2 = {0};
ASSERT_EQ(BSL_SAL_ReadFile(file1, &buff1.data, &buff1.dataLen), 0);
ASSERT_EQ(BSL_SAL_ReadFile(file2, &buff2.data, &buff2.dataLen), 0);
ASSERT_EQ(buff1.dataLen, buff2.dataLen);
ASSERT_COMPARE("Compare out data", buff1.data, buff1.dataLen, buff2.data, buff2.dataLen);
ret = 0;
EXIT:
BSL_SAL_Free(buff1.data);
BSL_SAL_Free(buff2.data);
return ret;
}
static int32_t CompareOutByData(char *file1, Hex *data)
{
int ret = 1;
BSL_Buffer buff = {0};
ASSERT_EQ(BSL_SAL_ReadFile(file1, &buff.data, &buff.dataLen), 0);
ASSERT_EQ(buff.dataLen, data->len);
ASSERT_COMPARE("Compare out data", buff.data, buff.dataLen, data->x, data->len);
ret = 0;
EXIT:
BSL_SAL_Free(buff.data);
return ret;
}
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_x509.c
* ${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c */
/**
* @test UT_HITLS_APP_X509_InvalidOpt_TC001
* @title Test the invalid parameters of the x509 command.
* @brief Enter parameters and return the error code expectRet.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_X509_InvalidOpt_TC001(char *opts, int expectRet)
{
int argc = 0;
char *argv[X509_MAX_ARGC] = {0};
char *tmp = strdup(opts);
ASSERT_NE(tmp, NULL);
PreProcArgs(tmp, &argc, argv);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_X509Main(argc, argv), expectRet);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(tmp);
}
/* END_CASE */
/**
* @test UT_HITLS_APP_X509_NormalOpt_TC001
* @title Test the normal parameters of the x509 command.
* @brief Enter parameters and return HITLS_APP_SUCCESS.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_X509_NormalOpt_TC001(char *opts)
{
int argc = 0;
char *argv[X509_MAX_ARGC] = {0};
char *tmp = strdup(opts);
ASSERT_NE(tmp, NULL);
PreProcArgs(tmp, &argc, argv);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_X509Main(argc, argv), HITLS_APP_SUCCESS);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(tmp);
}
/* END_CASE */
/**
* @test UT_HITLS_APP_X509_FormatConvert_TC001
* @title Test certificate format conversion.
* @brief The input format is 'inform', the output format is 'outform', and the output result is the same as that of
* out.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_X509_FormatConvert_TC001(char *opts, char *outFile, char *expectFile)
{
int argc = 0;
char *argv[X509_MAX_ARGC] = {0};
char *tmp = strdup(opts);
ASSERT_NE(tmp, NULL);
PreProcArgs(tmp, &argc, argv);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_X509Main(argc, argv), 0);
ASSERT_EQ(CompareOutByFile(outFile, expectFile), HITLS_APP_SUCCESS);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(tmp);
remove(outFile);
}
/* END_CASE */
/**
* @test UT_HITLS_APP_X509_Print_TC001
* @title Test certificate format conversion.
* @brief The input format is 'inform', the output format is 'outform', and the output result is the same as that of
* out.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_X509_Print_TC001(char *opts, char *outFile, Hex *expectOut)
{
int argc = 0;
char *argv[X509_MAX_ARGC] = {0};
char *tmp = strdup(opts);
ASSERT_NE(tmp, NULL);
PreProcArgs(tmp, &argc, argv);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_X509Main(argc, argv), 0);
ASSERT_EQ(CompareOutByData(outFile, expectOut), HITLS_APP_SUCCESS);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(tmp);
remove(outFile);
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/apps/test_suite_ut_app_x509.c | C | unknown | 5,122 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "string.h"
#include "app_opt.h"
#include "app_function.h"
#include "app_errno.h"
#include "app_help.h"
#include "app_dgst.h"
#include "app_print.h"
#include "crypt_eal_md.h"
#include "bsl_sal.h"
#include "securec.h"
#include "bsl_errno.h"
#include "crypt_errno.h"
#include "stub_replace.h"
/* END_HEADER */
#define PRV_PATH "../testdata/certificate/rsa_key/prvKey.pem"
#define OUT_FILE_PATH "../testdata/certificate/rsa_key/out.pem"
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_dgst.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c */
/**
* @test UT_HITLS_APP_dgst_TC001
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC001(void)
{
char *argv[][10] = {
{"dgst", "-md", "md5", PRV_PATH},
{"dgst", PRV_PATH},
{"dgst", "-md", "md5", "-out", OUT_FILE_PATH, PRV_PATH},
};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_SUCCESS},
{2, argv[1], HITLS_APP_SUCCESS},
{6, argv[2], HITLS_APP_SUCCESS}
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_dgst_TC002
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC002(void)
{
char *argv[][10] = {{"dgst", "-md"},
{"dgst", "-md", "md10", PRV_PATH},
{"dgst", "-md", "md5", "md5", PRV_PATH},
{"dgst", "-md", "md5", "-out"},
{"dgst", "-md", "md5", "/noexist/noexist.txt"},
{"dgst", "-md", "md5", "-out", "/noexist/filepath/outfile.txt", PRV_PATH},
{"dgst", "-md", "md5", "-out", "-out", "/noexist/filepath/outfile.txt", PRV_PATH}
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_OPT_UNKOWN},
{4, argv[1], HITLS_APP_OPT_VALUE_INVALID},
{5, argv[2], HITLS_APP_UIO_FAIL},
{4, argv[3], HITLS_APP_OPT_UNKOWN},
{4, argv[4], HITLS_APP_UIO_FAIL},
{6, argv[5], HITLS_APP_UIO_FAIL},
{7, argv[6], HITLS_APP_UIO_FAIL}
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_dgst_TC003
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC003函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC003(void)
{
char *argv[][2] = {
{"dgst", "-help"},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_HELP},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
int32_t STUB_HITLS_APP_OptBegin(int32_t argc, char **argv, const HITLS_CmdOption *opts)
{
(void)argc;
(void)argv;
(void)opts;
return HITLS_APP_OPT_UNKOWN;
}
/**
* @test UT_HITLS_APP_dgst_TC004
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC004函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC004(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptBegin, STUB_HITLS_APP_OptBegin);
char *argv[][50] = {{"dgst", "-md", "md5", "-out", OUT_FILE_PATH, PRV_PATH}};
OptTestData testData[] = {
{6, argv[0], HITLS_APP_OPT_UNKOWN},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_BSL_UIO_Ctrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *parg)
{
(void)uio;
(void)cmd;
(void)larg;
(void)parg;
return BSL_UIO_FAIL;
}
/**
* @test UT_HITLS_APP_dgst_TC005
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC005函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC005(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UIO_Ctrl, STUB_BSL_UIO_Ctrl);
char *argv[][50] = {{"dgst", "-md", "md5", "-out", OUT_FILE_PATH, PRV_PATH}};
OptTestData testData[] = {
{6, argv[0], HITLS_APP_UIO_FAIL},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
char *STUB_HITLS_APP_OptGetValueStr(void)
{
return NULL;
}
/**
* @test UT_HITLS_APP_dgst_TC006
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC006函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC006(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptGetValueStr, STUB_HITLS_APP_OptGetValueStr);
char *argv[][50] = {{"dgst", "-out", OUT_FILE_PATH, PRV_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_OPT_VALUE_INVALID},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_HITLS_APP_OptWriteUio(BSL_UIO *uio, uint8_t *buf, uint32_t outLen, int32_t format)
{
(void)uio;
(void)buf;
(void)outLen;
(void)format;
return HITLS_APP_UIO_FAIL;
}
/**
* @test UT_HITLS_APP_dgst_TC007
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC007函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC007(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptWriteUio, STUB_HITLS_APP_OptWriteUio);
char *argv[][50] = {{"dgst", "-out", OUT_FILE_PATH, PRV_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_UIO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
bool IsFileExist(const char *fileName)
{
FILE *f = fopen(fileName, "r");
if (f == NULL) {
return false;
}
fclose(f);
return true;
}
/**
* @test UT_HITLS_APP_dgst_TC008
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC008函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC008(void)
{
char *filename = "_APP_dgst_T008.txt";
char *argv[][10] = {{"dgst", "-out", filename, PRV_PATH}};
OptTestData testData[] = {{4, argv[0], HITLS_APP_SUCCESS}};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
ASSERT_TRUE(IsFileExist(filename));
remove(filename);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
uint32_t STUB_CRYPT_EAL_MdGetDigestSize(CRYPT_MD_AlgId id)
{
(void)id;
return 0;
}
/**
* @test UT_HITLS_APP_dgst_TC009
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC009函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC009(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, CRYPT_EAL_MdGetDigestSize, STUB_CRYPT_EAL_MdGetDigestSize);
char *argv[][50] = {{"dgst", "-out", OUT_FILE_PATH, PRV_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_CRYPTO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
CRYPT_EAL_MdCTX *STUB_CRYPT_EAL_ProviderMdNewCtx(CRYPT_EAL_LibCtx *libCtx, int32_t algId, const char *attrName)
{
(void)algId;
(void)attrName;
(void)libCtx;
return NULL;
}
/**
* @test UT_HITLS_APP_dgst_TC0010
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC0010函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC0010(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, CRYPT_EAL_ProviderMdNewCtx, STUB_CRYPT_EAL_ProviderMdNewCtx);
char *argv[][50] = {{"dgst", "-out", OUT_FILE_PATH, PRV_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_CRYPTO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_CRYPT_EAL_MdInit(CRYPT_EAL_MdCTX *ctx){
(void)ctx;
return HITLS_APP_CRYPTO_FAIL;
}
/**
* @test UT_HITLS_APP_dgst_TC0011
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC0011函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC0011(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, CRYPT_EAL_MdInit, STUB_CRYPT_EAL_MdInit);
char *argv[][50] = {{"dgst", "-out", OUT_FILE_PATH, PRV_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_CRYPTO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_CRYPT_EAL_MdUpdate(CRYPT_EAL_MdCTX *ctx, const uint8_t *data, uint32_t len){
(void)ctx;
(void)data;
(void)len;
return CRYPT_EAL_ERR_STATE;
}
/**
* @test UT_HITLS_APP_dgst_TC0012
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC0012函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC0012(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, CRYPT_EAL_MdUpdate, STUB_CRYPT_EAL_MdUpdate);
char *argv[][50] = {{"dgst", "-out", OUT_FILE_PATH, PRV_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_UIO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_CRYPT_EAL_MdFinal(CRYPT_EAL_MdCTX *ctx, uint8_t *out, uint32_t *len){
(void)ctx;
(void)out;
(void)len;
return CRYPT_EAL_ERR_STATE;
}
/**
* @test UT_HITLS_APP_dgst_TC0013
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC0013函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC0013(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, CRYPT_EAL_MdFinal, STUB_CRYPT_EAL_MdFinal);
char *argv[][50] = {{"dgst", "-out", OUT_FILE_PATH, PRV_PATH}};
OptTestData testData[] = {{4, argv[0], HITLS_APP_CRYPTO_FAIL}};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/apps/test_suite_ut_dgst.c | C | unknown | 13,165 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include "app_enc.h"
#include "app_errno.h"
#include "app_help.h"
#include "app_print.h"
#include "app_opt.h"
#include "bsl_uio.h"
#include "crypt_eal_cipher.h"
#include "crypt_eal_kdf.h"
#include "eal_cipher_local.h"
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_enc.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c */
/* END_HEADER */
typedef struct {
uint16_t version;
} ResumeTestInfo;
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
/**
* @test UT_HITLS_APP_ENC_TC001
* @spec -
* @title 测试命令行二级命令enc正常场景
*/
/* BEGIN_CASE */
void UT_HITLS_APP_ENC_TC001(void)
{
char *argv[][13] = {
{"enc", "-enc", "-cipher", "aes128_cbc", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-enc", "-cipher", "aes128_cbc", "-in", "../testdata/apps/enc/test_encfile", "-pass", "file:../testdata/apps/pass/size_1024_pass", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-enc", "-cipher", "aes128_cbc", "-md", "sha1", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-enc", "-cipher", "aes128_cbc", "-in", "../testdata/apps/enc/test_encfile", "-pass", "file:../testdata/apps/enc/enter_pass_file", "-out", "../testdata/apps/enc/res_encfile"}
};
OptTestData testData[] = {
{10, argv[0], HITLS_APP_SUCCESS},
{10, argv[1], HITLS_APP_SUCCESS},
{12, argv[2], HITLS_APP_SUCCESS},
{10, argv[3], HITLS_APP_SUCCESS}
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_EncMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_ENC_TC002
* @spec -
* @title 测试命令行二级命令enc不同对称加解密算法的加解密流程
*/
/* BEGIN_CASE */
void UT_HITLS_APP_ENC_TC002(void)
{
char *argv[][11] = {
{"enc", "-enc", "-cipher", "aes128_cbc", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:12345678", "-out", "res_tmpfile"},
{"enc", "-dec", "-cipher", "aes128_cbc", "-in", "res_tmpfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_decfile"},
{"enc", "-enc", "-cipher", "aes128_ctr", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-dec", "-cipher", "aes128_ctr", "-in", "../testdata/apps/enc/res_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_decfile"},
{"enc", "-enc", "-cipher", "aes128_ecb", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-dec", "-cipher", "aes128_ecb", "-in", "../testdata/apps/enc/res_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_decfile"},
{"enc", "-enc", "-cipher", "aes128_xts", "-in", "../testdata/apps/enc/test_xts_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-dec", "-cipher", "aes128_xts", "-in", "../testdata/apps/enc/res_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_decfile"},
{"enc", "-enc", "-cipher", "aes128_gcm", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-dec", "-cipher", "aes128_gcm", "-in", "../testdata/apps/enc/res_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_decfile"},
{"enc", "-enc", "-cipher", "chacha20_poly1305", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-dec", "-cipher", "chacha20_poly1305", "-in", "../testdata/apps/enc/res_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_decfile"},
{"enc", "-enc", "-cipher", "sm4_cfb", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-dec", "-cipher", "sm4_cfb", "-in", "../testdata/apps/enc/res_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_decfile"}
};
OptTestData testData[] = {
{10, argv[0], HITLS_APP_SUCCESS},
{10, argv[1], HITLS_APP_SUCCESS},
{10, argv[2], HITLS_APP_SUCCESS},
{10, argv[3], HITLS_APP_SUCCESS},
{10, argv[4], HITLS_APP_SUCCESS},
{10, argv[5], HITLS_APP_SUCCESS},
{10, argv[6], HITLS_APP_SUCCESS},
{10, argv[7], HITLS_APP_SUCCESS},
{10, argv[8], HITLS_APP_SUCCESS},
{10, argv[9], HITLS_APP_SUCCESS},
{10, argv[10], HITLS_APP_SUCCESS},
{10, argv[11], HITLS_APP_SUCCESS},
{10, argv[12], HITLS_APP_SUCCESS},
{10, argv[13], HITLS_APP_SUCCESS}
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_EncMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_ENC_TC003
* @spec -
* @title 测试命令行二级命令enc异常场景
*/
/* BEGIN_CASE */
void UT_HITLS_APP_ENC_TC003(void)
{
char *argv[][13] = {
{"enc", "-enc", "-cipher", "aes128_abc", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-enc", "-cipher", "aes128_cbc", "-in", "../testdata/apps/enc/test_encfile", "-pass", "file:../testdata/apps/pass/empty_pass", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-enc", "-cipher", "aes128_cbc", "-md", "md_abc", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-enc", "-cipher", "aes128_cbc", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-enc", "-cipher", "aes128_cbc", "-in", "../testdata/apps/enc/test_encfile", "-pass", "file:../testdata/apps/pass/size_1025_pass", "-out", "../testdata/apps/enc/res_encfile"}
};
OptTestData testData[] = {
{10, argv[0], HITLS_APP_OPT_VALUE_INVALID},
{10, argv[1], HITLS_APP_PASSWD_FAIL},
{12, argv[2], HITLS_APP_OPT_VALUE_INVALID},
{10, argv[3], HITLS_APP_PASSWD_FAIL},
{10, argv[4], HITLS_APP_PASSWD_FAIL}
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_EncMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/apps/test_suite_ut_enc.c | C | unknown | 7,782 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include "app_opt.h"
#include "securec.h"
#include "app_errno.h"
#include "bsl_uio.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "app_print.h"
#include "stub_replace.h"
#include "bsl_base64.h"
#ifdef HITLS_BSL_SAL_DOPRA_V3
#include <unistd.h>
#include "vfs_core.h"
#endif
/* END_HEADER */
typedef struct {
int argc;
char **argv;
HITLS_CmdOption *opts;
int expect;
} OptTestData;
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c */
/**
* @test UT_HITLS_APP_OptBegin_TC001
* @spec -
* @title 测试HITLS_APP_OptBegine异常
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptBegin_TC001(void)
{
HITLS_CmdOption opts[] = {{"test1", 1, HITLS_APP_OPT_VALUETYPE_NO_VALUE, "test1"}, {NULL}};
OptTestData testData[] = {
{0, NULL, NULL, HITLS_APP_OPT_UNKOWN}, // case1:invalid arg argc、argv、opt
{0, NULL, opts, HITLS_APP_OPT_UNKOWN} // case2:invalid argc and argv
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
ASSERT_EQ(HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts), testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_OptBegin_TC002
* @spec -
* @title 测试HITLS_APP_OptBegine异常
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptBegin_TC002(void)
{
HITLS_CmdOption opts[] = {{"-test1", 1, HITLS_APP_OPT_VALUETYPE_NO_VALUE, "test1"}, {NULL}};
char *argv[] = {"path", "help"};
OptTestData testData[] = {
{2, argv, opts, HITLS_APP_OPT_NAME_INVALID}, // case1： invald optname
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
ASSERT_EQ(HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts), testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_OptBegin_TC003
* @spec -
* @title 测试HITLS_APP_OptBegine异常
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptBegin_TC003(void)
{
HITLS_CmdOption opts[][4] = {
{{"test1", 1, HITLS_APP_OPT_VALUETYPE_NONE, "test1"}, {NULL}},
{{"test2", 1, HITLS_APP_OPT_VALUETYPE_NONE - 1, "test1"}, {NULL}},
{{"test3", 1, HITLS_APP_OPT_VALUETYPE_MAX, "test1"}, {NULL}},
{{"test4", 1, HITLS_APP_OPT_VALUETYPE_MAX + 1, "test1"}, {NULL}}
};
char *argv[] = {"path", "help"};
OptTestData testData[] = {
{2, argv, opts[0], HITLS_APP_OPT_VALUETYPE_INVALID}, // case1： invalid valuetype = 0
{2, argv, opts[1], HITLS_APP_OPT_VALUETYPE_INVALID}, // case2： invalid valuetype < 0
{2, argv, opts[2], HITLS_APP_OPT_VALUETYPE_INVALID}, // case3： invalid valuetype = max
{2, argv, opts[3], HITLS_APP_OPT_VALUETYPE_INVALID}, // case4： invalid valuetype > max
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
ASSERT_EQ(HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts), testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_OptBegin_TC004
* @spec -
* @title 测试HITLS_APP_OptBegine异常
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptBegin_TC004(void)
{
HITLS_CmdOption opts[][4] = {
{
{"test1", 1, HITLS_APP_OPT_VALUETYPE_NONE + 1, "test1"},
{"test1", 1, HITLS_APP_OPT_VALUETYPE_NONE + 1, "test1"},
{NULL}
},
{
{"test1", 1, HITLS_APP_OPT_VALUETYPE_NONE + 1, "test1"},
{"test2", 1, HITLS_APP_OPT_VALUETYPE_NONE + 1, "test1"},
{"test1", 1, HITLS_APP_OPT_VALUETYPE_NONE + 1, "test1"},
{NULL}
},
{
{"", 1, HITLS_APP_OPT_VALUETYPE_MAX - 1, "test1"},
{"", 1, HITLS_APP_OPT_VALUETYPE_MAX - 1, "test1"},
{NULL}
},
{
{"", 1, HITLS_APP_OPT_VALUETYPE_NONE + 1, "test1"},
{"test2", 1, HITLS_APP_OPT_VALUETYPE_NONE + 1, "test1"},
{"", 1, HITLS_APP_OPT_VALUETYPE_NONE + 1, "test1"},
{NULL}
}
};
char *argv[] = {"path", "help"};
OptTestData testData[] = {
{2, argv, opts[0], HITLS_APP_OPT_NAME_INVALID}, // case1： optname(test1) dup (neighbour)
{2, argv, opts[1], HITLS_APP_OPT_NAME_INVALID}, // case2： optname(test1) dup (separate)
{2, argv, opts[2], HITLS_APP_OPT_NAME_INVALID}, // case3： optname("") dup (neighbour)
{2, argv, opts[3], HITLS_APP_OPT_NAME_INVALID}, // case4： optname("") dup (separate)
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
ASSERT_EQ(HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts), testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_OptBegin_TC005
* @spec -
* @title 测试HITLS_APP_OptBegine异常
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptBegin_TC005(void)
{
HITLS_CmdOption opts[] = {{"", 1, HITLS_APP_OPT_VALUETYPE_FMT_PEMDER, "test1"}, {NULL}};
char *argv[] = {"path", "help"};
OptTestData testData[] = {
{2, argv, opts, HITLS_APP_OPT_NAME_INVALID} // case1： optname is "",but opttype is not no value
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
ASSERT_EQ(HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts), testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_OptBegin_TC006
* @spec -
* @title 测试HITLS_APP_OptBegine正常
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptBegin_TC006(void)
{
HITLS_CmdOption opts[2][2] = {
{{"", 1, HITLS_APP_OPT_VALUETYPE_NO_VALUE, "test1"},{NULL}},
{{"test", 1, HITLS_APP_OPT_VALUETYPE_NO_VALUE, "test1"},{NULL}}
};
char *argv[] = {"test", "help"};
OptTestData testData[] = {
{2, argv, opts[0], HITLS_APP_SUCCESS}, // case1： HITLS_Optbegin success
{2, argv, opts[1], HITLS_APP_SUCCESS} // case2： HITLS_Optbegin success
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
ASSERT_EQ(HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts), testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test HITLS_APP_OptNext_TC001
* @spec -
* @title 测试HITLS_APP_OptNext异常
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptNext_TC001(void)
{
HITLS_CmdOption opts[] = {
{"", 1, HITLS_APP_OPT_VALUETYPE_STRING, "test1"},
{"test", 1, HITLS_APP_OPT_VALUETYPE_NO_VALUE, "test1"},
{NULL}
};
char *argv[3][2] = {{"help", "-"}, {"help", "--"}, {"help", NULL}};
OptTestData testData[] = {
{1, argv[0], opts, HITLS_APP_OPT_ERR}, // case1： input arg only contain "-"
{2, argv[1], opts, HITLS_APP_OPT_ERR}, // case2： input arg only contain "--"
{2, argv[2], opts, HITLS_APP_OPT_EOF}
}; // case3： input arg is NULL
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
(void)HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts);
ASSERT_EQ(HITLS_APP_OptNext(), testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test HITLS_OptNext_TC002
* @spec -
* @title 测试HITLS_OptNext异常
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptNext_TC002(void)
{
char testcmd[] = "-test=21";
HITLS_CmdOption opts[] = {
{"11", 1, HITLS_APP_OPT_VALUETYPE_STRING, "test1"},
{"test", 1, HITLS_APP_OPT_VALUETYPE_NO_VALUE, "test1"},
{"test2", 1, HITLS_APP_OPT_VALUETYPE_STRING, "test2"},
{NULL},
{NULL}
};
char *argv[][3] = {
{"help", "-test"}, // case1:no opt value
{"help", testcmd }, // case2: -key=value not support
{"help", "-test2", NULL}, // case3: opt should have value,but input isn't opt's value
{"help", "-xxx"} // case4: invalid opt
};
OptTestData testData[] = {
{2, argv[0], opts, 1},
{2, argv[1], opts, HITLS_APP_OPT_ERR},
{3, argv[2], opts, HITLS_APP_OPT_ERR},
{2, argv[3], opts, HITLS_APP_OPT_ERR},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
(void)HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts);
ASSERT_EQ(HITLS_APP_OptNext(), testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
HITLS_CmdOption g_tc003Opts[] = {
{"novalue", 1, HITLS_APP_OPT_VALUETYPE_NO_VALUE, "test"},
{"infile", 1, HITLS_APP_OPT_VALUETYPE_IN_FILE, "test1"},
{"outfile", 1, HITLS_APP_OPT_VALUETYPE_OUT_FILE, "test2"},
{"string", 1, HITLS_APP_OPT_VALUETYPE_STRING, "test2"},
{"params", 1, HITLS_APP_OPT_VALUETYPE_PARAMTERS, "test2"},
{"dir", 1, HITLS_APP_OPT_VALUETYPE_DIR, "test2"},
{"int", 1, HITLS_APP_OPT_VALUETYPE_INT, "test2"},
{"uint", 1, HITLS_APP_OPT_VALUETYPE_UINT, "test2"},
{"pint", 1, HITLS_APP_OPT_VALUETYPE_POSITIVE_INT, "test2"},
{"long", 1, HITLS_APP_OPT_VALUETYPE_LONG, "test2"},
{"ulong", 1, HITLS_APP_OPT_VALUETYPE_ULONG, "test2"},
{"pemder", 1, HITLS_APP_OPT_VALUETYPE_FMT_PEMDER, "test2"},
{"any", 1, HITLS_APP_OPT_VALUETYPE_FMT_ANY, "test2"},
{NULL}
};
char *g_tc003Argv[][3] = {
{"help", "-novalue", NULL}, // 0 novalue tpye case
{"help", "-infile", "1.txt"}, // 1 infiletype case
{"help", "-outfile", "1.txt"}, // 2 outfiletype case
{"help", "-string", "11111"}, // 3 string case
{"help", "-params", "1211"}, // 4 params case
{"help", "-dir", "."}, // 5 dir case
{"help", "-int", "131231"}, // 6 int > 0 case
{"help", "-int", "-131231"}, // 7 int < 0 case
{"help", "-uint", "131231"}, // 8 uint > 0 case
{"help", "-uint", "-131231"}, // 9 uint < 0 case
{"help", "-uint", "3147483637"}, // 10 uint > max_uint case
{"help", "-pint", "13123"}, // 11 positive int > 0 case
{"help", "-pint", "0"}, // 12 positive int = 0 case
{"help", "-long", "13123"}, // 13 long > 0 case
{"help", "-ulong", "13123"}, // 14 ulong > 0 case
{"help", "-ulong", "1312312"}, // 15 ulong > 0 case
{"help", "-pemder", "PEM"}, // 16 pem case
{"help", "-pemder", "DER"}, // 17 der case
{"help", "-pemder", "xxx"}, // 18 any case
{"help", "-any", "PEM"}, // 19 any case
{"help", "-dir", NULL}, // 20 dir (value is NULL) case
{"help", "-dir", "1"}, // 21 dir (not exist) case
};
OptTestData g_tc003TestData[] = {
{3, g_tc003Argv[0], g_tc003Opts, 1},
{3, g_tc003Argv[1], g_tc003Opts, 1},
{3, g_tc003Argv[2], g_tc003Opts, 1},
{3, g_tc003Argv[3], g_tc003Opts, 1},
{3, g_tc003Argv[4], g_tc003Opts, 1},
{3, g_tc003Argv[5], g_tc003Opts, 1},
{3, g_tc003Argv[6], g_tc003Opts, 1},
{3, g_tc003Argv[7], g_tc003Opts, 1},
{3, g_tc003Argv[8], g_tc003Opts, 1},
{3, g_tc003Argv[9], g_tc003Opts, -1},
{3, g_tc003Argv[10], g_tc003Opts, -1},
{3, g_tc003Argv[11], g_tc003Opts, 1},
{3, g_tc003Argv[12], g_tc003Opts, 1},
{3, g_tc003Argv[13], g_tc003Opts, 1},
{3, g_tc003Argv[14], g_tc003Opts, 1},
{3, g_tc003Argv[15], g_tc003Opts, 1},
{3, g_tc003Argv[16], g_tc003Opts, 1},
{3, g_tc003Argv[17], g_tc003Opts, 1},
{3, g_tc003Argv[18], g_tc003Opts, -1},
{3, g_tc003Argv[19], g_tc003Opts, 1},
{3, g_tc003Argv[20], g_tc003Opts, -1},
{3, g_tc003Argv[21], g_tc003Opts, -1},
{3, g_tc003Argv[21], g_tc003Opts, -1},
};
/**
* @test HITLS_APP_OptNext_TC003
* @spec -
* @title 测试HITLS_APP_OptNext中各类值类型
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptNext_TC003(void)
{
AppPrintErrorUioInit(stderr);
for (int i = 0; i < (int)(sizeof(g_tc003TestData) / sizeof(OptTestData)); i++) {
(void)HITLS_APP_OptBegin(g_tc003TestData[i].argc, g_tc003TestData[i].argv, g_tc003TestData[i].opts);
ASSERT_EQ(HITLS_APP_OptNext(), g_tc003TestData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_OptNext_TC004
* @spec -
* @title 测试HITLS_APP_OptNext函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptNext_TC004(void)
{
enum OptType{param = 0,help,cipher};
HITLS_CmdOption opts[] = {
{"help",help , HITLS_APP_OPT_VALUETYPE_NO_VALUE, "print help"},
{"",cipher,HITLS_APP_OPT_VALUETYPE_NO_VALUE,"cipher alg" },
{"param", param, HITLS_APP_OPT_VALUETYPE_PARAMTERS, "input paramters"},
{NULL}
};
char *argv[][3] = {
{"cmd", "-help", NULL},
{"cmd", "-aes128-cbc", NULL},
{"cmd", "a", "b"}
};
OptTestData testData[] = {
{3, argv[0], opts, help},
{3, argv[1], opts, cipher},
{3, argv[2], opts, param},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
(void)HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts);
ASSERT_EQ(HITLS_APP_OptNext(), testData[i].expect);
HITLS_APP_OptEnd();
}
EXIT:
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_GetRestOptNum_TC001
* @spec -
* @title 测试HITLS_APP_GetRestOptNum函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_GetRestOptNum_TC001(void)
{
char *argv[] = {"help", "-infile", "1.txt"};
HITLS_CmdOption opts[] = {
{"infile", 1, HITLS_APP_OPT_VALUETYPE_IN_FILE, "test1"},
{NULL}
};
OptTestData testData[] = {
{3, argv, opts, 2} // case1: rest opt number
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
(void)HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts);
ASSERT_EQ(HITLS_APP_GetRestOptNum(), testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_GetRestOpt_TC001
* @spec -
* @title 测试UT_HITLS_APP_GetRestOpt函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_GetRestOpt_TC001(void)
{
char *argv[] = {"help", "-infile", "1.txt"};
HITLS_CmdOption opts[] = {
{"infile", 1, HITLS_APP_OPT_VALUETYPE_IN_FILE, "test1"}, // case1: rest opt number
{NULL}
};
OptTestData testData[] = {
{3, argv, opts, 1}
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
(void)HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts);
ASSERT_EQ(HITLS_APP_GetRestOpt() == &argv[1], testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
static bsl_sal_file_handle fileHandle = NULL;
static int32_t InitStderrUIOForFp(const char *filename, const char *mode)
{
int32_t ret = BSL_SAL_FileOpen(&fileHandle, filename, mode);
if (ret != BSL_SUCCESS) {
return HITLS_APP_INTERNAL_EXCEPTION;
}
return AppPrintErrorUioInit(fileHandle);
}
#define MAX_BUF_SIZE (1024 * 2)
static int32_t CheckResult()
{
char buf[MAX_BUF_SIZE] = {0};
size_t len;
int32_t ret = BSL_SAL_FileOpen(&fileHandle, "test.dat", "r");
if (ret != BSL_SUCCESS) {
return HITLS_APP_INTERNAL_EXCEPTION;
}
ret = BSL_SAL_FileRead(fileHandle, buf, sizeof(buf) / sizeof(char), sizeof(char), &len);
if (ret != BSL_SUCCESS) {
return HITLS_APP_INTERNAL_EXCEPTION;
}
(void)BSL_SAL_FileClose(fileHandle);
fileHandle = NULL;
/* check infile opt */
if (strstr(buf, "-infile infile input infile") == NULL) {
return HITLS_APP_INTERNAL_EXCEPTION;
}
/* check inint opt */
if (strstr(buf, "-inint int input int") == NULL) {
return HITLS_APP_INTERNAL_EXCEPTION;
}
/* check help opt */
if (strstr(buf, "-help print help") == NULL) {
return HITLS_APP_INTERNAL_EXCEPTION;
}
/* check param opt */
if (strstr(buf, "[param] input paramters") == NULL) {
return HITLS_APP_INTERNAL_EXCEPTION;
}
return HITLS_APP_SUCCESS;
}
static void *TestOptHelpPrint(void *args)
{
(void)args;
HITLS_CmdOption opts[] = {
{"infile", 1, HITLS_APP_OPT_VALUETYPE_IN_FILE, "input infile"}, // case1: rest opt number
{"inint", 1, HITLS_APP_OPT_VALUETYPE_INT, "input int"}, // case1: rest opt number
{"help", 1, HITLS_APP_OPT_VALUETYPE_NO_VALUE, "print help"}, // case1: rest opt number
{"param", 1, HITLS_APP_OPT_VALUETYPE_PARAMTERS, "input paramters"}, // case1: rest opt number
{NULL}
};
char *argv[] = {"help"};
#ifdef HITLS_BSL_SAL_DOPRA_V3
char* abPath = getcwd(NULL, 0);
ASSERT_EQ(VOS_VFS_SetWorkPath(abPath), 0);
#endif
ASSERT_TRUE(InitStderrUIOForFp("test.dat", "w+") == HITLS_APP_SUCCESS);
HITLS_APP_OptBegin(1, argv, opts);
HITLS_APP_OptHelpPrint(opts);
AppPrintErrorUioUnInit();
(void)BSL_SAL_FileClose(fileHandle);
fileHandle = NULL;
ASSERT_TRUE(CheckResult() == HITLS_APP_SUCCESS);
EXIT:
return NULL;
}
/**
* @test UT_HITLS_APP_OptHelpPrint_TC001
* @spec -
* @title 测试HITLS_APP_OptHelpPrint函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptHelpPrint_TC001(void)
{
#ifdef HITLS_BSL_SAL_DOPRA_V3
BSL_SAL_ThreadId serverThread = NULL;
ASSERT_EQ(BSL_SAL_ThreadCreate(&serverThread, TestOptHelpPrint, NULL), BSL_SUCCESS);
EXIT:
BSL_SAL_ThreadClose(serverThread);
#else
TestOptHelpPrint(NULL);
#endif
}
/* END_CASE */
typedef struct{
char* filename;
char mode;
int32_t flag;
}OptUioData;
/**
* @test UT_HITLS_APP_OptUioOpen_TC001
* @spec -
* @title UT_HITLS_APP_OptUioOpen_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptUioOpen_TC001(void)
{
OptUioData testData[] = {
{NULL, 'w', 0},
{NULL, 'r', 0},
{"1.txt", 'w', 0},
{"1.txt", 'r', 0},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptUioData)); ++i) {
BSL_UIO *ret = HITLS_APP_UioOpen(testData[i].filename, testData[i].mode, testData[i].flag);
ASSERT_TRUE(ret != NULL);
BSL_UIO_Free(ret);
}
EXIT:
return;
}
/* END_CASE */
int32_t STUB_BSL_UIO_Ctrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *parg)
{
(void)uio;
(void)cmd;
(void)larg;
(void)parg;
return BSL_UIO_FAIL;
}
/**
* @test UT_HITLS_APP_OptUioOpen_TC002
* @spec -
* @title UT_HITLS_APP_OptUioOpen_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptUioOpen_TC002(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UIO_Ctrl, STUB_BSL_UIO_Ctrl);
OptUioData testData[] = {
{NULL, 'w', 0},
{NULL, 'a', 0},
{NULL, 'b', 0},
{NULL, 'r', 0},
{"1.txt", 'w', 0},
{"1.txt", 'a', 0},
{"1.txt", 'b', 0},
{"1.txt", 'r', 0},
{"D:\\outfile\\1.txt", 'w', 0},
{"D:\\outfile\\1.txt", 'r', 0},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptUioData)); ++i) {
BSL_UIO *uio = HITLS_APP_UioOpen(testData[i].filename, testData[i].mode, testData[i].flag);
ASSERT_TRUE(uio == NULL);
}
EXIT:
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
BSL_UIO *STUB_BSL_UIO_New(const BSL_UIO_Method *method)
{
(void)method;
return NULL;
}
/**
* @test UT_HITLS_APP_OptUioOpen_TC003
* @spec -
* @title UT_HITLS_APP_OptUioOpen_TC003函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptUioOpen_TC003(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UIO_New, STUB_BSL_UIO_New);
OptUioData testData[] = {
{NULL, 'w', 0},
{NULL, 'r', 0},
{"1.txt", 'w', 0},
{"1.txt", 'r', 0}
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptUioData)); ++i) {
BSL_UIO *uio = HITLS_APP_UioOpen(testData[i].filename, testData[i].mode, testData[i].flag);
ASSERT_TRUE(uio == NULL);
}
EXIT:
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
typedef struct {
BSL_UIO *uio;
uint8_t *buf;
uint32_t outLen;
int32_t format;
int32_t expect;
} OutputUioData;
/**
* @test UT_HITLS_APP_OptUioOut_TC001
* @spec -
* @title 测试UT_HITLS_APP_OptUioOut_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptUioOut_TC001(void)
{
BSL_UIO *uio[] = {
HITLS_APP_UioOpen(NULL, 'w', 0),
HITLS_APP_UioOpen("D:\\outfile\\1.txt", 'w', 0),
HITLS_APP_UioOpen("1.txt", 'w', 0),
HITLS_APP_UioOpen(NULL, 'w', 0),
HITLS_APP_UioOpen(NULL, 'w', 0),
HITLS_APP_UioOpen(NULL, 'w', 0)
};
uint8_t buf[10] = {"123456789"};
OutputUioData testData[] = {
{uio[0], buf, 10, HITLS_APP_FORMAT_BASE64, HITLS_APP_SUCCESS},
{uio[1], buf, 10, HITLS_APP_FORMAT_HEX, HITLS_APP_SUCCESS},
{uio[2], buf, 10, HITLS_APP_FORMAT_BINARY, HITLS_APP_SUCCESS},
{uio[3], NULL, 10, HITLS_APP_FORMAT_BASE64, HITLS_APP_INTERNAL_EXCEPTION},
{uio[4], NULL, 10, HITLS_APP_FORMAT_HEX, HITLS_APP_INTERNAL_EXCEPTION},
{uio[5], buf, 0, HITLS_APP_FORMAT_BINARY, HITLS_APP_INTERNAL_EXCEPTION},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OutputUioData)); ++i) {
int ret = HITLS_APP_OptWriteUio(testData[i].uio, testData[i].buf, testData[i].outLen, testData[i].format);
BSL_UIO_Free(testData[i].uio);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
int32_t STUB_BSL_UIO_Write(BSL_UIO *uio, const void *data, uint32_t len, uint32_t *writeLen)
{
(void)uio;
(void)data;
(void)len;
(void)writeLen;
return BSL_INTERNAL_EXCEPTION;
}
/**
* @test UT_HITLS_APP_OptUioOut_TC002
* @spec -
* @title 测试UT_HITLS_APP_OptUioOut_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptUioOut_TC002(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UIO_Write, STUB_BSL_UIO_Write);
BSL_UIO *uio[] = {
HITLS_APP_UioOpen(NULL, 'w', 0),
HITLS_APP_UioOpen(NULL, 'w', 0),
HITLS_APP_UioOpen("1.txt", 'w', 0),
HITLS_APP_UioOpen("1.txt", 'w', 0),
};
uint8_t buf[][1024] = {"123456789qweeeeeeqweqweqweqwasd12312", "1234567893123123123123123", "", "NULL"};
OutputUioData testData[] = {
{uio[0], buf[0], 1024, HITLS_APP_FORMAT_BASE64, HITLS_APP_UIO_FAIL},
{uio[1], buf[1], 1024, HITLS_APP_FORMAT_HEX, HITLS_APP_UIO_FAIL},
{uio[2], buf[1], 1024, HITLS_APP_FORMAT_BINARY, HITLS_APP_UIO_FAIL},
{uio[3], buf[2], 1024, HITLS_APP_FORMAT_BASE64, HITLS_APP_UIO_FAIL},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OutputUioData)); ++i) {
int ret = HITLS_APP_OptWriteUio(testData[i].uio, testData[i].buf, testData[i].outLen, testData[i].format);
BSL_UIO_Free(testData[i].uio);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_BSL_Base64Encode(const uint8_t *srcBuf, const uint32_t srcBufLen, char *dstBuf, uint32_t *dstBufLen)
{
(void)srcBuf;
(void)srcBufLen;
(void)dstBuf;
(void)dstBufLen;
return BSL_UIO_FAIL;
}
/**
* @test UT_HITLS_APP_OptUioOut_TC003
* @spec -
* @title 测试UT_HITLS_APP_OptUioOut_TC003函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptUioOut_TC003(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_BASE64_Encode, STUB_BSL_Base64Encode);
BSL_UIO *uio[] = {
HITLS_APP_UioOpen(NULL, 'w', 0),
HITLS_APP_UioOpen(NULL, 'w', 0),
HITLS_APP_UioOpen("1.txt", 'w', 0),
HITLS_APP_UioOpen("1.txt", 'w', 0),
};
uint8_t buf[][1024] = {"123456789qweeeeeeqweqweqweqwasd12312", "1234567893123123123123123", "", "NULL"};
OutputUioData testData[] = {
{uio[0], buf[0], 1024, HITLS_APP_FORMAT_BASE64, HITLS_APP_ENCODE_FAIL},
{uio[1], NULL, 1024, HITLS_APP_FORMAT_BASE64, HITLS_APP_INTERNAL_EXCEPTION},
{uio[2], buf[2], 1024, HITLS_APP_FORMAT_BASE64, HITLS_APP_ENCODE_FAIL},
{uio[3], buf[3], 1024, HITLS_APP_FORMAT_BASE64, HITLS_APP_ENCODE_FAIL},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OutputUioData)); ++i) {
int ret = HITLS_APP_OptWriteUio(testData[i].uio, testData[i].buf, testData[i].outLen, testData[i].format);
BSL_UIO_Free(testData[i].uio);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_OptToBase64_TC001
* @spec -
* @title 测试UT_HITLS_APP_OptToBase64_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptToBase64_TC001(void)
{
uint8_t str[] = "hello, world";
char outBuf[1024] = {0};
int ret = HITLS_APP_OptToBase64(str, 0, outBuf, 1024);
ASSERT_EQ(ret, HITLS_APP_INTERNAL_EXCEPTION);
int ret1 = HITLS_APP_OptToBase64(NULL, 12, outBuf, 1024);
ASSERT_EQ(ret1, HITLS_APP_INTERNAL_EXCEPTION);
int ret2 = HITLS_APP_OptToBase64(str, 12, NULL, 1024);
ASSERT_EQ(ret2, HITLS_APP_INTERNAL_EXCEPTION);
int ret3 = HITLS_APP_OptToBase64(str, 12, outBuf, 0);
ASSERT_EQ(ret3, HITLS_APP_INTERNAL_EXCEPTION);
EXIT:
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_OptToHex_TC001
* @spec -
* @title 测试UT_HITLS_APP_OptToHex_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptToHex_TC001(void)
{
uint8_t str[] = "hello, world";
char outBuf[1024] = {0};
int ret = HITLS_APP_OptToHex(str, 0, outBuf, 1024);
ASSERT_EQ(ret, HITLS_APP_INTERNAL_EXCEPTION);
int ret1 = HITLS_APP_OptToHex(NULL, 12, outBuf, 1024);
ASSERT_EQ(ret1, HITLS_APP_INTERNAL_EXCEPTION);
int ret2 = HITLS_APP_OptToHex(str, 12, NULL, 1024);
ASSERT_EQ(ret2, HITLS_APP_INTERNAL_EXCEPTION);
int ret3 = HITLS_APP_OptToHex(str, 12, outBuf, 0);
ASSERT_EQ(ret3, HITLS_APP_INTERNAL_EXCEPTION);
EXIT:
return;
}
/* END_CASE */
bool IsFileExist(const char *fileName)
{
FILE *f = fopen(fileName, "r");
if (f == NULL) {
return false;
}
fclose(f);
return true;
}
int32_t CreateFile(const char *fileName, const char *data)
{
size_t dataLen = strlen(data);
FILE *f = fopen(fileName, "w");
ASSERT_EQ(fwrite(data, dataLen, 1, f), 1);
(void)fclose(f);
return 1;
EXIT:
return 0;
}
/* @
* @test UT_HITLS_APP_Opt_Write_TC001
* @spec -
* @title file uio 测试: "w"模式打开文件，不存在则新建，存在则删除后再新建
@ */
/* BEGIN_CASE */
void UT_HITLS_APP_Opt_Write_TC001(void)
{
const char *data = "1";
uint32_t dataLen = strlen(data);
BSL_UIO *uio = NULL;
char *testFile = "uio.txt";
ASSERT_TRUE(IsFileExist(testFile) == false);
uio = HITLS_APP_UioOpen(testFile, 'w', 1);
ASSERT_TRUE(uio != NULL);
ASSERT_TRUE(IsFileExist(testFile));
ASSERT_EQ(HITLS_APP_OptWriteUio(uio, (uint8_t *)data, dataLen, HITLS_APP_FORMAT_BINARY), HITLS_APP_SUCCESS);
EXIT:
BSL_UIO_Free(uio);
remove(testFile);
}
/* END_CASE */
/**
* @test UT_HITLS_APP_Opt_Uio_Read_TC001
* @spec -
* @title 测试UT_HITLS_APP_Opt_Uio_Read_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_Opt_Uio_Read_TC001(void)
{
char *testFile = "file_uio.txt";
char data[] = "0123456789abcdef";
uint32_t dataLen = strlen(data);
BSL_UIO *uio = NULL;
uint8_t *readBuf = NULL;
uint64_t readBufLen = 0;
ASSERT_TRUE(IsFileExist(testFile) == false);
ASSERT_EQ(HITLS_APP_OptReadUio(uio, &readBuf, &readBufLen, 0), HITLS_APP_INTERNAL_EXCEPTION);
ASSERT_EQ(CreateFile(testFile, data), 1);
ASSERT_TRUE(IsFileExist(testFile));
uio = HITLS_APP_UioOpen(testFile, 'r', 0);
ASSERT_TRUE(uio != NULL);
ASSERT_EQ(HITLS_APP_OptReadUio(uio, &readBuf, &readBufLen, 2048), HITLS_APP_SUCCESS);
ASSERT_EQ(readBufLen, dataLen);
EXIT:
BSL_UIO_Free(uio);
BSL_SAL_FREE(readBuf);
remove(testFile);
return;
}
/* END_CASE */
int32_t STUB_BSL_UIO_Read(BSL_UIO *uio, const void *data, uint32_t len, uint32_t *writeLen)
{
(void)uio;
(void)data;
(void)len;
(void)writeLen;
return HITLS_APP_UIO_FAIL;
}
/**
* @test UT_HITLS_APP_Opt_Uio_Read_TC002
* @spec -
* @title 测试UT_HITLS_APP_Opt_Uio_Read_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_Opt_Uio_Read_TC002(void)
{
char *testFile = "file_read_uio.txt";
const char *data = "0123456789abcdef";
BSL_UIO *uio = NULL;
uint8_t *readBuf = NULL;
uint64_t readBufLen = 0;
ASSERT_EQ(CreateFile(testFile, data), 1);
uio = HITLS_APP_UioOpen(testFile, 'r', 0);
ASSERT_TRUE(uio != NULL);
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UIO_Read, STUB_BSL_UIO_Read);
ASSERT_EQ(HITLS_APP_OptReadUio(uio, &readBuf, &readBufLen, 0), HITLS_APP_UIO_FAIL);
testFile = NULL;
ASSERT_EQ(HITLS_APP_OptReadUio(uio, &readBuf, &readBufLen, 0), HITLS_APP_UIO_FAIL);
EXIT:
BSL_UIO_Free(uio);
BSL_SAL_FREE(readBuf);
remove(testFile);
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_Opt_Uio_Read_TC003
* @spec -
* @title 测试UT_HITLS_APP_Opt_Uio_Read_TC003函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_Opt_Uio_Read_TC003(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UIO_Ctrl, STUB_BSL_UIO_Ctrl);
char *testFile = "file_read_uio.txt";
const char *data = "0123456789abcdef";
BSL_UIO *uio = NULL;
uint8_t *readBuf = NULL;
uint64_t readBufLen = 0;
ASSERT_EQ(CreateFile(testFile, data), 1);
uio = HITLS_APP_UioOpen(testFile, 'r', 0);
ASSERT_TRUE(uio == NULL);
ASSERT_EQ(HITLS_APP_OptReadUio(uio, &readBuf, &readBufLen, 0), HITLS_APP_INTERNAL_EXCEPTION);
EXIT:
BSL_UIO_Free(uio);
BSL_SAL_FREE(readBuf);
remove(testFile);
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/apps/test_suite_ut_opt.c | C | unknown | 30,253 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "app_opt.h"
#include "securec.h"
#include "app_errno.h"
#include "bsl_uio.h"
#include "app_print.h"
/* END_HEADER */
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c */
/**
* @test UT_HITLS_APP_PrintStderr_TC001
* @spec -
* @title 测试UT_HITLS_APP_PrintStderr_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APPPrint_TC001(void)
{
AppPrintErrorUioInit(stderr);
AppPrintError("\n%d %x\n", BSL_UIO_FILE_PTR, BSL_UIO_FILE_PTR + 1);
AppPrintErrorUioUnInit();
}
/* END_CASE */
BSL_UIO *g_stderrUio = NULL;
static int32_t InitStderrUIO(void)
{
if (g_stderrUio != NULL)
return HITLS_APP_SUCCESS;
g_stderrUio = BSL_UIO_New(BSL_UIO_FileMethod());
if (g_stderrUio == NULL)
return HITLS_APP_MEM_ALLOC_FAIL;
return BSL_UIO_Ctrl(g_stderrUio, BSL_UIO_FILE_PTR, 0, (void *)stderr);
}
/**
* @test UT_HITLS_APP_Print_TC001
* @spec -
* @title 测试UT_HITLS_APP_Print_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APPPrint_TC002(void)
{
InitStderrUIO();
ASSERT_EQ(AppPrint(g_stderrUio, "\n%d %x\n", HITLS_APP_SUCCESS, HITLS_APP_SUCCESS + 1), HITLS_APP_SUCCESS);
EXIT:
BSL_UIO_Free(g_stderrUio);
g_stderrUio = NULL;
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/apps/test_suite_ut_print.c | C | unknown | 1,777 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include "app_opt.h"
#include "app_print.h"
#include "bsl_uio.h"
#include "uio_abstraction.h"
#include "crypt_eal_rand.h"
#include "app_errno.h"
#include "bsl_base64.h"
#include "crypt_errno.h"
#include "app_rand.h"
#include "app_function.h"
#include "securec.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "stub_replace.h"
/* END_HEADER */
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_rand.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c */
/**
* @test UT_HITLS_APP_rand_TC001
* @spec -
* @title 测试UT_HITLS_APP_rand_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC001(void)
{
char *argv[][10] = {
{"rand", "-hex", "10"},
{"rand", "10"},
{"rand", "-base64", "10"},
{"rand", "-out", "TC001_binary.txt", "10"},
{"rand", "-out", "TC001_hex.txt", "-hex", "10"},
{"rand", "-out", "TC001_base64.txt", "-base64", "10"}
};
OptTestData testData[] = {
{3, argv[0], HITLS_APP_SUCCESS},
{2, argv[1], HITLS_APP_SUCCESS},
{3, argv[2], HITLS_APP_SUCCESS},
{4, argv[3], HITLS_APP_SUCCESS},
{5, argv[4], HITLS_APP_SUCCESS},
{5, argv[5], HITLS_APP_SUCCESS}
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_rand_TC002
* @spec -
* @title 测试UT_HITLS_APP_rand_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC002(void)
{
char *argv[][5] = {
{"rand", "-base64", "-out", "1.txt", "10"},
{"rand", "-hex", "-out", "D:\\outfile\\1.txt", "10"},
{"rand", "-hex", "1.txt", "10"},
{"rand", "-out"}
};
OptTestData testData[] =
{
{5, argv[0], HITLS_APP_SUCCESS},
{5, argv[1], HITLS_APP_SUCCESS},
{4, argv[2], HITLS_APP_OPT_UNKOWN},
{2, argv[3], HITLS_APP_OPT_UNKOWN}
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_rand_TC003
* @spec -
* @title 测试UT_HITLS_APP_rand_TC003函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC003(void)
{
char *argv[][4] = {
{"rand", "1231-31231"},
{"rand", "asdsaldsalkdsjadl"},
{"rand", "2147483648"},
{"rand", "-10"},
{"rand", "2312/0"},
{"rand", "-out", "D:\\outfile\\1.txt", "123"},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_OPT_VALUE_INVALID},
{2, argv[1], HITLS_APP_OPT_VALUE_INVALID},
{2, argv[2], HITLS_APP_OPT_VALUE_INVALID},
{2, argv[3], HITLS_APP_OPT_UNKOWN}, //带了'-'误认为是命令
{2, argv[4], HITLS_APP_OPT_VALUE_INVALID},
{4, argv[5], HITLS_APP_SUCCESS}
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_rand_TC004
* @spec -
* @title 测试UT_HITLS_APP_rand_TC004函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC004(void)
{
char *argv[][2] = {
{"rand", "-help"},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_HELP},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
int32_t STUB_HITLS_APP_OptBegin(int32_t argc, char **argv, const HITLS_CmdOption *opts)
{
(void)argc;
(void)argv;
(void)opts;
return HITLS_APP_OPT_UNKOWN;
}
/**
* @test UT_HITLS_APP_rand_TC005
* @spec -
* @title 测试UT_HITLS_APP_rand_TC005函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC005(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptBegin, STUB_HITLS_APP_OptBegin);
char *argv[][3] = {
{"rand", "-hex", "10"},
};
OptTestData testData[] = {
{3, argv[0], HITLS_APP_OPT_UNKOWN},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
void *STUB_SAL_Calloc(uint32_t num, uint32_t size)
{
(void)num;
(void)size;
return NULL;
}
/**
* @test UT_HITLS_APP_rand_TC006
* @spec -
* @title 测试UT_HITLS_APP_rand_TC006函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC006(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_SAL_Calloc, STUB_SAL_Calloc);
char *argv[][3] = {
{"rand", "-hex", "10"},
{"rand", "-base64", "10"},
{"rand", "10"},
};
OptTestData testData[] = {
{3, argv[0], HITLS_APP_CRYPTO_FAIL},
{3, argv[1], HITLS_APP_CRYPTO_FAIL},
{2, argv[2], HITLS_APP_CRYPTO_FAIL},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_BSL_UIO_Ctrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *parg)
{
(void)uio;
(void)cmd;
(void)larg;
(void)parg;
return BSL_NULL_INPUT;
}
/**
* @test UT_HITLS_APP_rand_TC007
* @spec -
* @title 测试UT_HITLS_APP_rand_TC007函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC007(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UIO_Ctrl, STUB_BSL_UIO_Ctrl);
char *argv[][4] = {
{"rand", "-hex", "2049"},
{"rand", "-out", "1.txt", "10"},
{"rand", "-out", "D:\\outfile\\1.txt", "10"}
};
OptTestData testData[] = {
{3, argv[0], HITLS_APP_UIO_FAIL},
{4, argv[1], HITLS_APP_UIO_FAIL},
{4, argv[2], HITLS_APP_UIO_FAIL},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_CRYPT_EAL_RandInit(
CRYPT_EAL_LibCtx *libCtx, int32_t algId, const char *attrName,
const uint8_t *pers, uint32_t persLen, BSL_Param *param)
{
(void)libCtx;
(void)algId;
(void)attrName;
(void)pers;
(void)persLen;
(void)param;
return CRYPT_EAL_ERR_DRBG_INIT_FAIL;
}
/**
* @test UT_HITLS_APP_rand_TC008
* @spec -
* @title 测试UT_HITLS_APP_rand_TC008函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC008(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, CRYPT_EAL_ProviderRandInitCtx, STUB_CRYPT_EAL_RandInit);
char *argv[][3] = {
{"rand", "-hex", "10"},
};
OptTestData testData[] = {
{3, argv[0], HITLS_APP_CRYPTO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_CRYPT_EAL_Randbytes(void *libctx, uint8_t *byte, uint32_t len)
{
(void)byte;
(void)len;
(void)libctx;
return CRYPT_EAL_ERR_GLOBAL_DRBG_NULL;
}
/**
* @test UT_HITLS_APP_rand_TC009
* @spec -
* @title 测试UT_HITLS_APP_rand_TC009函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC009(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, CRYPT_EAL_RandbytesEx, STUB_CRYPT_EAL_Randbytes);
char *argv[][3] = {
{"rand", "-hex", "10"},
};
OptTestData testData[] = {
{3, argv[0], HITLS_APP_CRYPTO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
BSL_UIO *STUB_BSL_UIO_New(const BSL_UIO_Method *method)
{
(void)method;
return NULL;
}
/**
* @test UT_HITLS_APP_rand_TC0010
* @spec -
* @title 测试UT_HITLS_APP_rand_TC0010函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC0010(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UIO_New, STUB_BSL_UIO_New);
char *argv[][3] = {
{"rand", "-hex", "10"},
};
OptTestData testData[] = {
{3, argv[0], HITLS_APP_UIO_FAIL},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
char *STUB_HITLS_APP_OptGetValueStr(void)
{
return NULL;
}
/**
* @test UT_HITLS_APP_rand_TC0011
* @spec -
* @title 测试UT_HITLS_APP_rand_TC0011函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC0011(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptGetValueStr, STUB_HITLS_APP_OptGetValueStr);
char *argv[][4] = {{"rand", "-out", "1.txt", "10"}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_OPT_VALUE_INVALID},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_HITLS_APP_OptWriteUio(BSL_UIO *uio, uint8_t *buf, uint32_t outLen, int32_t format)
{
(void)uio;
(void)buf;
(void)outLen;
(void)format;
return HITLS_APP_UIO_FAIL;
}
/**
* @test UT_HITLS_APP_rand_TC0012
* @spec -
* @title 测试UT_HITLS_APP_rand_TC0012函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC0012(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptWriteUio, STUB_HITLS_APP_OptWriteUio);
char *argv[][4] = {{"rand", "-out", "1.txt", "10"}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_UIO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
bool IsFileExist(const char *fileName)
{
FILE *f = fopen(fileName, "r");
if (f == NULL) {
return false;
}
fclose(f);
return true;
}
/**
* @test UT_HITLS_APP_rand_TC0013
* @spec -
* @title 测试UT_HITLS_APP_rand_TC0013函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC0013(void)
{
char* filename = "TC0013_binary.txt";
char *argv[][10] = {
{"rand", "-out", filename, "10"},
{"rand", "-out", filename, "-hex", "10"},
{"rand", "-out", filename, "-base64", "10"}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_SUCCESS},
{5, argv[1], HITLS_APP_SUCCESS},
{5, argv[2], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
ASSERT_TRUE(IsFileExist(filename) == false);
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
ASSERT_TRUE(IsFileExist(filename));
remove(filename);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/apps/test_suite_ut_rand.c | C | unknown | 13,574 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdint.h>
#include "privpass_token.h"
#include "auth_privpass_token.h"
#include "auth_errno.h"
#include "auth_params.h"
#include "crypt_util_rand.h"
#include "crypt_eal_rand.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_codecs.h"
#include "crypt_errno.h"
#include "crypt_params_key.h"
#include "eal_md_local.h"
#include "securec.h"
/* END_HEADER */
#define MAX_LEN 512
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_SERIALIZATION_TC001
* @spec Private Pass Token Serialization
* @title Test serialization and deserialization of Private Pass Token objects
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_SERIALIZATION_TC001(int type, Hex *buffer)
{
TestRandInit();
uint8_t output[MAX_LEN];
uint32_t outputLen = 0;
HITLS_AUTH_PrivPassToken *challenge = NULL;
HITLS_AUTH_PrivPassCtx *ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
// Test deserialization
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, type, buffer->x, buffer->len, &challenge), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, challenge, NULL, &outputLen), HITLS_AUTH_SUCCESS);
outputLen--;
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, challenge, output, &outputLen),
HITLS_AUTH_PRIVPASS_BUFFER_NOT_ENOUGH);
outputLen++;
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, challenge, output, &outputLen), HITLS_AUTH_SUCCESS);
// Test serialization
ASSERT_COMPARE("compare token", output, outputLen, buffer->x, buffer->len);
EXIT:
HITLS_AUTH_PrivPassFreeToken(challenge);
HITLS_AUTH_PrivPassFreeCtx(ctx);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_SERIALIZATION_TC002
* @spec Private Pass Token challenge serialization
* @title Test serialization of Private Pass Token challenge
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_SERIALIZATION_TC002(Hex *tokenType, Hex *issuerName, Hex *redemption, Hex *originInfo)
{
HITLS_AUTH_PrivPassCtx *ctx = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge1 = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge2 = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge3 = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge4 = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge3_1 = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge4_1 = NULL;
uint8_t output1[MAX_LEN >> 1];
uint32_t outputLen1 = MAX_LEN >> 1;
uint8_t output2[MAX_LEN >> 1];
uint32_t outputLen2 = MAX_LEN >> 1;
uint8_t output3[MAX_LEN >> 1];
uint32_t outputLen3 = MAX_LEN >> 1;
uint8_t output4[MAX_LEN >> 1];
uint32_t outputLen4 = MAX_LEN >> 1;
uint16_t tokenTypeValue = tokenType->x[0] << 8 | tokenType->x[1];
BSL_Param param1[5] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenTypeValue, 2, 2},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerName->x, issuerName->len,
issuerName->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemption->x, redemption->len,
redemption->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ORIGININFO, BSL_PARAM_TYPE_OCTETS_PTR, originInfo->x, originInfo->len,
originInfo->len},
BSL_PARAM_END};
BSL_Param param2[5] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerName->x, issuerName->len,
issuerName->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenTypeValue, 2, 2},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ORIGININFO, BSL_PARAM_TYPE_OCTETS_PTR, originInfo->x, originInfo->len,
originInfo->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemption->x, redemption->len,
redemption->len},
BSL_PARAM_END};
BSL_Param param3[5] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerName->x, issuerName->len,
issuerName->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ORIGININFO, BSL_PARAM_TYPE_OCTETS_PTR, originInfo->x, originInfo->len,
originInfo->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, 0, 0, 0},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenTypeValue, 2, 2}, BSL_PARAM_END};
BSL_Param param4[4] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerName->x, issuerName->len,
issuerName->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemption->x, redemption->len,
redemption->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenTypeValue, 2, 2}, BSL_PARAM_END};
TestRandInit();
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(ctx, param1, &tokenChallenge1), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, tokenChallenge1, output1, &outputLen1), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(ctx, param2, &tokenChallenge2), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, tokenChallenge2, output2, &outputLen2), HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare token", output1, outputLen1, output2, outputLen2);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(ctx, param3, &tokenChallenge3), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, tokenChallenge3, output3, &outputLen3), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE, output3, outputLen3,
&tokenChallenge3_1), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(ctx, param4, &tokenChallenge4), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, tokenChallenge4, output4, &outputLen4), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE, output4, outputLen4,
&tokenChallenge4_1), HITLS_AUTH_SUCCESS);
EXIT:
CRYPT_EAL_RandDeinit();
HITLS_AUTH_PrivPassFreeToken(tokenChallenge1);
HITLS_AUTH_PrivPassFreeToken(tokenChallenge2);
HITLS_AUTH_PrivPassFreeToken(tokenChallenge3);
HITLS_AUTH_PrivPassFreeToken(tokenChallenge4);
HITLS_AUTH_PrivPassFreeToken(tokenChallenge3_1);
HITLS_AUTH_PrivPassFreeToken(tokenChallenge4_1);
HITLS_AUTH_PrivPassFreeCtx(ctx);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_SERIALIZATION_INVALID_TC001
* @spec Private Pass Token Serialization Invalid Parameters
* @title Test serialization and deserialization with invalid parameters
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_SERIALIZATION_INVALID_TC001()
{
uint8_t output[MAX_LEN];
uint32_t outputLen = MAX_LEN;
HITLS_AUTH_PrivPassToken *token = NULL;
uint8_t dummyData[8] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
HITLS_AUTH_PrivPassCtx *ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
// Test NULL parameters
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE,
NULL, sizeof(dummyData), &token), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE,
dummyData, 0, &token), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE,
dummyData, sizeof(dummyData), NULL), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
// Test invalid token type
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, 999, dummyData,
sizeof(dummyData), &token), HITLS_AUTH_PRIVPASS_INVALID_TOKEN_TYPE);
// Test serialization with NULL parameters
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, NULL, output, &outputLen), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, token, NULL, &outputLen), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, token, output, NULL), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
EXIT:
HITLS_AUTH_PrivPassFreeToken(token);
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_SERIALIZATION_INVALID_TC002
* @spec Private Pass Token Invalid Serialization
* @title Test deserialization with invalid token data
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_SERIALIZATION_INVALID_TC002(int type, Hex *buffer)
{
HITLS_AUTH_PrivPassToken *token = NULL;
HITLS_AUTH_PrivPassCtx *ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_NE(HITLS_AUTH_PrivPassDeserialization(ctx, type, buffer->x, buffer->len, &token), HITLS_AUTH_SUCCESS);
EXIT:
HITLS_AUTH_PrivPassFreeToken(token);
HITLS_AUTH_PrivPassFreeCtx(ctx);
CRYPT_EAL_RandDeinit();
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_SERIALIZATION_INVALID_TC003
* @spec Private Pass Token Invalid Serialization
* @title Test serialization with invalid data
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_SERIALIZATION_INVALID_TC003(int type, Hex *buffer)
{
HITLS_AUTH_PrivPassToken *token = NULL;
HITLS_AUTH_PrivPassToken *token2 = NULL;
uint8_t output[MAX_LEN];
uint32_t outputLen = MAX_LEN;
HITLS_AUTH_PrivPassCtx *ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, type, buffer->x, buffer->len, &token), HITLS_AUTH_SUCCESS);
if (type == HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE) {
token->st.tokenChallenge->tokenType = 0x0001; // support prv type
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, token, output, &outputLen), HITLS_AUTH_SUCCESS);
}
if (type == HITLS_AUTH_PRIVPASS_TOKEN_REQUEST) {
token->st.tokenRequest->tokenType = 0x0001; // not support prv type
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, token, output, &outputLen),
HITLS_AUTH_PRIVPASS_INVALID_TOKEN_REQUEST);
}
if (type == HITLS_AUTH_PRIVPASS_TOKEN_RESPONSE) {
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, type, buffer->x, buffer->len - 1, &token2),
HITLS_AUTH_PRIVPASS_INVALID_TOKEN_TYPE);
token->st.tokenResponse->type = 0; // not support prv type
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, token, output, &outputLen),
HITLS_AUTH_PRIVPASS_INVALID_TOKEN_RESPONSE);
token->st.tokenResponse->type = 1;
}
if (type == HITLS_AUTH_PRIVPASS_TOKEN_INSTANCE) {
token->st.token->tokenType = 0; // not support prv type
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, token, output, &outputLen),
HITLS_AUTH_PRIVPASS_INVALID_TOKEN_INSTANCE);
}
EXIT:
HITLS_AUTH_PrivPassFreeToken(token);
HITLS_AUTH_PrivPassFreeCtx(ctx);
CRYPT_EAL_RandDeinit();
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_GEN_PROCESS_TC001
* @spec Private Pass Token Generation Process
* @title Test complete token generation process including challenge, request, response and verification
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_GEN_PROCESS_TC001(Hex *pki, Hex *ski, Hex *tokenType, Hex *issuerName,
Hex *redemption, Hex *originInfo)
{
HITLS_AUTH_PrivPassCtx *client = NULL;
HITLS_AUTH_PrivPassCtx *issuer = NULL;
HITLS_AUTH_PrivPassCtx *server = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge2 = NULL;
HITLS_AUTH_PrivPassToken *tokenRequest = NULL;
HITLS_AUTH_PrivPassToken *tokenResponse = NULL;
HITLS_AUTH_PrivPassToken *finalToken = NULL;
uint8_t output[MAX_LEN];
uint32_t outputLen = MAX_LEN;
uint16_t tokenTypeValue = tokenType->x[0] << 8 | tokenType->x[1];
BSL_Param param[5] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenTypeValue, 2, 2},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerName->x, issuerName->len,
issuerName->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemption->x, redemption->len,
redemption->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ORIGININFO, BSL_PARAM_TYPE_OCTETS_PTR, originInfo->x, originInfo->len,
originInfo->len},
BSL_PARAM_END};
TestRandInit();
// Create context
client = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(client, NULL);
issuer = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(issuer, NULL);
server = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(server, NULL);
// Set keys
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(client, pki->x, pki->len), HITLS_AUTH_SUCCESS);
// issuer needs pub and prv key
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(issuer, NULL, ski->x, ski->len), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(issuer, pki->x, pki->len), HITLS_AUTH_SUCCESS);
// server
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(server, pki->x, pki->len), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(server, param, &tokenChallenge), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(server, tokenChallenge, output, &outputLen), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(client, HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE, output,
outputLen, &tokenChallenge2), HITLS_AUTH_SUCCESS);
// Generate token request
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenReq(client, tokenChallenge, &tokenRequest), HITLS_AUTH_SUCCESS);
// Generate token response
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenResponse(issuer, tokenRequest, &tokenResponse), HITLS_AUTH_SUCCESS);
// Generate final token
ASSERT_EQ(HITLS_AUTH_PrivPassGenToken(client, tokenChallenge, tokenResponse, &finalToken), HITLS_AUTH_SUCCESS);
// Verify token
ASSERT_EQ(HITLS_AUTH_PrivPassVerifyToken(server, tokenChallenge, finalToken), HITLS_AUTH_SUCCESS);
EXIT:
CRYPT_EAL_RandDeinit();
HITLS_AUTH_PrivPassFreeToken(tokenChallenge);
HITLS_AUTH_PrivPassFreeToken(tokenChallenge2);
HITLS_AUTH_PrivPassFreeToken(tokenRequest);
HITLS_AUTH_PrivPassFreeToken(tokenResponse);
HITLS_AUTH_PrivPassFreeToken(finalToken);
HITLS_AUTH_PrivPassFreeCtx(client);
HITLS_AUTH_PrivPassFreeCtx(issuer);
HITLS_AUTH_PrivPassFreeCtx(server);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_GEN_TOKEN_CHALLENGE_TC001
* @spec Private Pass Token gen invalid token challenge
* @title Test gen invalid token challenge
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_GEN_TOKEN_CHALLENGE_TC001(Hex *tokenType, Hex *issuerName, Hex *redemption,
Hex *originInfo)
{
HITLS_AUTH_PrivPassCtx *ctx = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge = NULL;
uint16_t invaliedTokenType = 3;
uint16_t tokenTypeValue = tokenType->x[0] << 8 | tokenType->x[1];
BSL_Param param1[5] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerName->x, issuerName->len,
issuerName->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &invaliedTokenType, 2, 2},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ORIGININFO, BSL_PARAM_TYPE_OCTETS_PTR, originInfo->x, originInfo->len,
originInfo->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemption->x, redemption->len,
redemption->len},
BSL_PARAM_END};
BSL_Param param2[4] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenTypeValue, 2, 2},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ORIGININFO, BSL_PARAM_TYPE_OCTETS_PTR, originInfo->x, originInfo->len,
originInfo->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemption->x, redemption->len,
redemption->len},
BSL_PARAM_END};
BSL_Param param3[4] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenTypeValue, 2, 2},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerName->x,
PRIVPASS_MAX_ISSUER_NAME_LEN + 1, PRIVPASS_MAX_ISSUER_NAME_LEN + 1},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemption->x, redemption->len,
redemption->len},
BSL_PARAM_END};
BSL_Param param4[5] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenTypeValue, 2, 2},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerName->x, issuerName->len,
issuerName->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemption->x, redemption->len,
redemption->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ORIGININFO, BSL_PARAM_TYPE_OCTETS_PTR, originInfo->x,
PRIVPASS_MAX_ISSUER_NAME_LEN + 1, PRIVPASS_MAX_ORIGIN_INFO_LEN + 1},
BSL_PARAM_END};
BSL_Param param5[4] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenTypeValue, 2, 2},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerName->x, issuerName->len,
issuerName->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemption->x,
PRIVPASS_MAX_ISSUER_NAME_LEN + 1, PRIVPASS_REDEMPTION_LEN + 1},
BSL_PARAM_END};
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(ctx, param1, &tokenChallenge),
HITLS_AUTH_PRIVPASS_INVALID_TOKEN_TYPE);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(ctx, param2, &tokenChallenge),
HITLS_AUTH_PRIVPASS_NO_TOKEN_CHALLENGE_ISSUERNAME);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(ctx, param3, &tokenChallenge),
HITLS_AUTH_PRIVPASS_INVALID_ISSUER_NAME);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(ctx, param4, &tokenChallenge),
HITLS_AUTH_PRIVPASS_INVALID_ORIGIN_INFO);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(ctx, param5, &tokenChallenge),
HITLS_AUTH_PRIVPASS_INVALID_REDEMPTION);
EXIT:
CRYPT_EAL_RandDeinit();
HITLS_AUTH_PrivPassFreeToken(tokenChallenge);
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
static uint8_t *g_nonceBuf;
static uint32_t g_nonceLen;
static uint8_t *g_saltBuf;
static uint32_t g_saltLen;
static uint8_t *g_blindBuf;
static uint32_t g_blindLen;
static int32_t ref = 0;
static int32_t STUB_ReplaceRandom(uint8_t *r, uint32_t randLen)
{
if (ref == 0) {
for (uint32_t i = 0; i < randLen; i++) {
r[i] = g_nonceBuf[i];
}
ref++;
} else if (ref == 1) {
for (uint32_t i = 0; i < randLen; i++) {
r[i] = g_saltBuf[i];
}
ref++;
} else if (ref == 2) {
for (uint32_t i = 0; i < randLen; i++) {
r[i] = g_blindBuf[i];
}
}
return 0;
}
static int32_t STUB_ReplaceRandomWEx(void *libCtx, uint8_t *r, uint32_t randLen)
{
(void) libCtx;
return STUB_ReplaceRandom(r, randLen);
}
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_VECTOR_TEST_TC001
* @spec Private Pass Token Vector Testing
* @title Test token generation process with predefined test vectors
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_VECTOR_TEST_TC001(Hex *ski, Hex *pki, Hex *challenge, Hex *nonce, Hex *blind, Hex *salt,
Hex *request, Hex *response, Hex *token)
{
ref = 0;
TestRandInit();
uint8_t tokenChallengeBuffer[MAX_LEN];
uint32_t tokenChallengeBufferLen = MAX_LEN;
uint8_t tokenRequestBuffer[MAX_LEN];
uint32_t tokenRequestBufferLen = MAX_LEN;
uint8_t tokenResponseBuffer[MAX_LEN];
uint32_t tokenResponseBufferLen = MAX_LEN;
uint8_t finalTokenBuffer[MAX_LEN];
uint32_t finalTokenBufferLen = MAX_LEN;
uint8_t nonceBuff[MAX_LEN];
uint32_t nonceLen = MAX_LEN;
HITLS_AUTH_PrivPassCtx *ctx = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge = NULL;
HITLS_AUTH_PrivPassToken *tokenRequest = NULL;
HITLS_AUTH_PrivPassToken *tokenResponse = NULL;
HITLS_AUTH_PrivPassToken *finalToken = NULL;
g_nonceBuf = (uint8_t *)nonce->x;
g_saltBuf = (uint8_t *)salt->x;
g_nonceLen = nonce->len;
g_saltLen = salt->len;
g_blindBuf = (uint8_t *)blind->x;
g_blindLen = blind->len;
BSL_Param param[2] = {
{AUTH_PARAM_PRIVPASS_TOKEN_NONCE, BSL_PARAM_TYPE_OCTETS_PTR, nonceBuff, nonceLen, 0}, BSL_PARAM_END};
// Create context
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ctx->method.random = STUB_ReplaceRandom;
ASSERT_NE(ctx, NULL);
// Set keys
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(ctx, pki->x, pki->len), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(ctx, NULL, ski->x, ski->len), HITLS_AUTH_SUCCESS);
CRYPT_RandRegist(STUB_ReplaceRandom);
CRYPT_RandRegistEx(STUB_ReplaceRandomWEx);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE, challenge->x, challenge->len,
&tokenChallenge), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, tokenChallenge, tokenChallengeBuffer, &tokenChallengeBufferLen),
HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare tokenchallenge", tokenChallengeBuffer, tokenChallengeBufferLen,
challenge->x, challenge->len);
// Generate token request
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenReq(ctx, tokenChallenge, &tokenRequest), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, tokenRequest, tokenRequestBuffer, &tokenRequestBufferLen),
HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare tokenrequest", tokenRequestBuffer, tokenRequestBufferLen, request->x, request->len);
// Generate token response
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenResponse(ctx, tokenRequest, &tokenResponse), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, tokenResponse, tokenResponseBuffer, &tokenResponseBufferLen),
HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare tokenresponse", tokenResponseBuffer, tokenResponseBufferLen, response->x, response->len);
// Generate final token
ASSERT_EQ(HITLS_AUTH_PrivPassGenToken(ctx, tokenChallenge, tokenResponse, &finalToken), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, finalToken, finalTokenBuffer, &finalTokenBufferLen),
HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare finaltoken", finalTokenBuffer, finalTokenBufferLen, token->x, token->len);
// Verify token
ASSERT_EQ(HITLS_AUTH_PrivPassVerifyToken(ctx, tokenChallenge, finalToken), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(finalToken, HITLS_AUTH_PRIVPASS_GET_TOKEN_NONCE, param, 0),
HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare nonce", param->value, param->useLen, nonce->x, nonce->len);
EXIT:
TestRandDeInit();
HITLS_AUTH_PrivPassFreeToken(tokenChallenge);
HITLS_AUTH_PrivPassFreeToken(tokenRequest);
HITLS_AUTH_PrivPassFreeToken(tokenResponse);
HITLS_AUTH_PrivPassFreeToken(finalToken);
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_CHALLENGE_OBTAIN_TC001
* @spec Private Pass Token Challenge Parameters
* @title Test obtaining and validating token challenge parameters
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_CHALLENGE_OBTAIN_TC001(Hex *challenge)
{
uint8_t tokenChallengeBuffer[MAX_LEN];
uint32_t tokenChallengeBufferLen = MAX_LEN;
uint16_t tokenType;
uint8_t issuerNameBuffer[MAX_LEN];
uint32_t issuerNameBufferLen = MAX_LEN;
uint8_t redemptionBuffer[MAX_LEN];
uint32_t redemptionBufferLen = MAX_LEN;
uint8_t originInfoBuffer[MAX_LEN];
uint32_t originInfoBufferLen = MAX_LEN;
HITLS_AUTH_PrivPassToken *tokenChallenge1 = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge2 = NULL;
HITLS_AUTH_PrivPassCtx *ctx = NULL;
BSL_Param param1[5] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenType, 2, 0},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerNameBuffer,
issuerNameBufferLen, 0},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemptionBuffer,
redemptionBufferLen, 0},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ORIGININFO, BSL_PARAM_TYPE_OCTETS_PTR, originInfoBuffer,
originInfoBufferLen, 0},
BSL_PARAM_END};
BSL_Param param2[5] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenType, 2, 0},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerNameBuffer, 0, 0},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemptionBuffer, 0, 0},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ORIGININFO, BSL_PARAM_TYPE_OCTETS_PTR, originInfoBuffer, 0, 0},
BSL_PARAM_END};
// Create context
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE, challenge->x, challenge->len,
&tokenChallenge1), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenChallenge1, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGE_TYPE, param1, 0),
HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenChallenge1, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGE_REDEMPTION,
param1, 0),
HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenChallenge1, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGE_ORIGININFO,
param1, 0),
HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenChallenge1, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGE_ISSUERNAME,
param1, 0),
HITLS_AUTH_SUCCESS);
param2[0].valueLen = param1[0].useLen;
param2[1].valueLen = param1[1].useLen;
param2[2].valueLen = param1[2].useLen;
param2[3].valueLen = param1[3].useLen;
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(ctx, param2, &tokenChallenge2), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, tokenChallenge2, tokenChallengeBuffer,
&tokenChallengeBufferLen), HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare token challenge", tokenChallengeBuffer, tokenChallengeBufferLen, challenge->x,
challenge->len);
EXIT:
CRYPT_EAL_RandDeinit();
HITLS_AUTH_PrivPassFreeToken(tokenChallenge1);
HITLS_AUTH_PrivPassFreeToken(tokenChallenge2);
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
void *NewPkeyCtxTmp(void *libCtx, int algId)
{
(void)libCtx;
(void)algId;
return NULL;
}
/**
* @test SDV_AUTH_PRIVPASS_TEST_SET_CRYPTO_CB_TC001
* @brief Test setting and validating crypto callback functionality
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TEST_SET_CRYPTO_CB_TC001(Hex *ski, Hex *pki)
{
TestRandInit();
HITLS_AUTH_PrivPassCtx *ctx = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE);
HITLS_AUTH_PrivPassToken *tokenRequest = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_REQUEST);
HITLS_AUTH_PrivPassToken *tokenResponse = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_RESPONSE);
HITLS_AUTH_PrivPassToken *finalToken = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_INSTANCE);
HITLS_AUTH_PrivPassToken *tokenRequest1 = NULL;
HITLS_AUTH_PrivPassToken *tokenResponse1 = NULL;
HITLS_AUTH_PrivPassToken *finalToken1 = NULL;
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
ASSERT_NE(tokenChallenge, NULL);
ASSERT_NE(tokenRequest, NULL);
ASSERT_NE(tokenResponse, NULL);
ASSERT_NE(finalToken, NULL);
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(ctx, pki->x, pki->len), 0);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(ctx, NULL, ski->x, ski->len), 0);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenReq(ctx, tokenChallenge, &tokenRequest1),
HITLS_AUTH_PRIVPASS_INVALID_TOKEN_TYPE);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenResponse(ctx, tokenRequest, &tokenResponse1),
HITLS_AUTH_PRIVPASS_INVALID_TOKEN_TYPE);
ASSERT_EQ(HITLS_AUTH_PrivPassGenToken(ctx, tokenChallenge, tokenResponse, &finalToken1),
HITLS_AUTH_PRIVPASS_INVALID_TOKEN_TYPE);
ASSERT_EQ(HITLS_AUTH_PrivPassVerifyToken(ctx, tokenChallenge, finalToken), HITLS_AUTH_PRIVPASS_INVALID_TOKEN_TYPE);
pkeyCtx = ctx->method.newPkeyCtx(NULL, NULL, HITLS_AUTH_PRIVPASS_CRYPTO_RSA);
ASSERT_NE(pkeyCtx, NULL);
ASSERT_EQ(CRYPT_EAL_PkeyGetId(pkeyCtx), CRYPT_PKEY_RSA);
ctx->method.freePkeyCtx(pkeyCtx);
pkeyCtx = NULL;
ASSERT_EQ(HITLS_AUTH_PrivPassSetCryptCb(ctx, HITLS_AUTH_PRIVPASS_NEW_PKEY_CTX_CB - 1, NewPkeyCtxTmp),
HITLS_AUTH_PRIVPASS_INVALID_CRYPTO_CALLBACK_TYPE);
ASSERT_EQ(HITLS_AUTH_PrivPassSetCryptCb(ctx, HITLS_AUTH_PRIVPASS_NEW_PKEY_CTX_CB, NewPkeyCtxTmp),
HITLS_AUTH_SUCCESS);
pkeyCtx = ctx->method.newPkeyCtx(NULL, NULL, HITLS_AUTH_PRIVPASS_CRYPTO_RSA);
ASSERT_EQ(pkeyCtx, NULL);
EXIT:
HITLS_AUTH_PrivPassFreeCtx(ctx);
HITLS_AUTH_PrivPassFreeToken(tokenChallenge);
HITLS_AUTH_PrivPassFreeToken(tokenRequest);
HITLS_AUTH_PrivPassFreeToken(tokenResponse);
HITLS_AUTH_PrivPassFreeToken(finalToken);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_SET_KEY_TC001
* @brief Test case for setting public and private keys in PrivPass context
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_SET_KEY_TC001(Hex *ski, Hex *pki)
{
TestRandInit();
HITLS_AUTH_PrivPassCtx *ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
// Test NULL pointer parameters
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(NULL, pki->x, pki->len), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(ctx, NULL, pki->len), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(NULL, NULL, ski->x, ski->len), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(ctx, NULL, NULL, ski->len), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
// Test zero length
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(ctx, pki->x, 0), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(ctx, NULL, ski->x, 0), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
// Test duplicate key setting
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(ctx, pki->x, pki->len), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(ctx, pki->x, pki->len), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(ctx, NULL, ski->x, ski->len), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(ctx, NULL, ski->x, ski->len), HITLS_AUTH_SUCCESS);
ctx->method.checkKeyPair = NULL;
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(ctx, NULL, ski->x, ski->len), HITLS_AUTH_PRIVPASS_NO_KEYPAIR_CHECK_CALLBACK);
EXIT:
HITLS_AUTH_PrivPassFreeCtx(ctx);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_SET_KEY_TC002
* @brief Test case for validating that mismatched public/private key pairs are rejected
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_SET_KEY_TC002()
{
TestRandInit();
uint8_t e[] = {1, 0, 1};
BSL_Buffer pubBuffer = {0};
BSL_Buffer prvBuffer = {0};
CRYPT_EAL_PkeyPara para = {0};
HITLS_AUTH_PrivPassCtx *ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
CRYPT_EAL_PkeyCtx *pkey1 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_RSA);
CRYPT_EAL_PkeyCtx *pkey2 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_RSA);
CRYPT_MD_AlgId mdId = CRYPT_MD_SHA384;
uint32_t saltLen = 0;
BSL_Param pssParam[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &saltLen, sizeof(saltLen), 0}, BSL_PARAM_END};
ASSERT_NE(ctx, NULL);
ASSERT_NE(pkey1, NULL);
ASSERT_NE(pkey2, NULL);
para.id = CRYPT_PKEY_RSA;
para.para.rsaPara.e = e;
para.para.rsaPara.eLen = 3;
para.para.rsaPara.bits = 2048;
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey1, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey2, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey2), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey1, CRYPT_CTRL_SET_RSA_EMSA_PSS, &pssParam, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey2, CRYPT_CTRL_SET_RSA_EMSA_PSS, &pssParam, 0) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkey1, NULL, BSL_FORMAT_ASN1, CRYPT_PUBKEY_SUBKEY, &pubBuffer), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkey2, NULL, BSL_FORMAT_PEM, CRYPT_PRIKEY_PKCS8_UNENCRYPT, &prvBuffer),
CRYPT_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(ctx, pubBuffer.data, pubBuffer.dataLen), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(ctx, NULL, prvBuffer.data, prvBuffer.dataLen),
HITLS_AUTH_PRIVPASS_CHECK_KEYPAIR_FAILED);
HITLS_AUTH_PrivPassFreeCtx(ctx);
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(ctx, NULL, prvBuffer.data, prvBuffer.dataLen),
HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(ctx, pubBuffer.data, pubBuffer.dataLen),
HITLS_AUTH_PRIVPASS_CHECK_KEYPAIR_FAILED);
EXIT:
BSL_SAL_Free(pubBuffer.data);
BSL_SAL_Free(prvBuffer.data);
HITLS_AUTH_PrivPassFreeCtx(ctx);
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_GEN_INVALID_TC001
* @spec Private Pass Token Generation Invalid Cases
* @title Test token generation process with invalid parameters and states
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_INVALID_INTERACTION_TC001()
{
HITLS_AUTH_PrivPassCtx *ctx = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge = NULL;
HITLS_AUTH_PrivPassToken *tokenRequest = NULL;
HITLS_AUTH_PrivPassToken *tokenResponse = NULL;
HITLS_AUTH_PrivPassToken *finalToken = NULL;
TestRandInit();
// Test with NULL context
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenReq(NULL, tokenChallenge, &tokenRequest), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenResponse(NULL, tokenRequest, &tokenResponse),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenToken(NULL, tokenChallenge, tokenResponse, &finalToken),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassVerifyToken(NULL, tokenChallenge, finalToken), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
// Create context but don't set keys
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenReq(ctx, tokenChallenge, &tokenRequest), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenResponse(ctx, tokenRequest, &tokenResponse),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenToken(ctx, tokenChallenge, tokenResponse, &finalToken),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassVerifyToken(ctx, tokenChallenge, finalToken), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
// Test with NULL tokens
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenReq(ctx, NULL, &tokenRequest), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenResponse(ctx, NULL, &tokenResponse), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenToken(ctx, NULL, tokenResponse, &finalToken), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassVerifyToken(ctx, NULL, finalToken), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
EXIT:
TestRandDeInit();
HITLS_AUTH_PrivPassFreeToken(tokenChallenge);
HITLS_AUTH_PrivPassFreeToken(tokenRequest);
HITLS_AUTH_PrivPassFreeToken(tokenResponse);
HITLS_AUTH_PrivPassFreeToken(finalToken);
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_GEN_INVALID_TC001
* @brief Test case to verify error handling for invalid PrivPass token interactions
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_INVALID_INTERACTION_TC002(Hex *challenge, Hex *request, Hex *response, Hex *token)
{
TestRandInit();
HITLS_AUTH_PrivPassCtx *ctx = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge = NULL;
HITLS_AUTH_PrivPassToken *tokenRequest = NULL;
HITLS_AUTH_PrivPassToken *tokenResponse = NULL;
HITLS_AUTH_PrivPassToken *finalToken = NULL;
HITLS_AUTH_PrivPassToken *tokenRequest1 = NULL;
HITLS_AUTH_PrivPassToken *tokenResponse1 = NULL;
HITLS_AUTH_PrivPassToken *finalToken1 = NULL;
// Create a new PrivPass context
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE, challenge->x, challenge->len,
&tokenChallenge), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_REQUEST, request->x, request->len,
&tokenRequest), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_RESPONSE, response->x, response->len,
&tokenResponse), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_INSTANCE, token->x, token->len,
&finalToken), HITLS_AUTH_SUCCESS);
// The entered token object does not match the expected value
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenReq(ctx, finalToken, &tokenRequest), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenResponse(ctx, finalToken, &tokenResponse), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenToken(ctx, tokenResponse, tokenResponse, &finalToken),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenToken(ctx, tokenChallenge, tokenChallenge, &finalToken),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassVerifyToken(ctx, tokenResponse, finalToken), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
// When the output != NULL
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenReq(ctx, tokenChallenge, &tokenRequest), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenResponse(ctx, tokenRequest, &tokenResponse),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenToken(ctx, tokenChallenge, tokenResponse, &finalToken),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
// There is no key info
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenReq(ctx, tokenChallenge, &tokenRequest1), HITLS_AUTH_PRIVPASS_NO_PUBKEY_INFO);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenResponse(ctx, tokenRequest, &tokenResponse1),
HITLS_AUTH_PRIVPASS_NO_PRVKEY_INFO);
ASSERT_EQ(HITLS_AUTH_PrivPassGenToken(ctx, tokenChallenge, tokenResponse, &finalToken1),
HITLS_AUTH_PRIVPASS_NO_PUBKEY_INFO);
ASSERT_EQ(HITLS_AUTH_PrivPassVerifyToken(ctx, tokenChallenge, finalToken), HITLS_AUTH_PRIVPASS_NO_PUBKEY_INFO);
EXIT:
TestRandDeInit();
HITLS_AUTH_PrivPassFreeToken(tokenChallenge);
HITLS_AUTH_PrivPassFreeToken(tokenRequest);
HITLS_AUTH_PrivPassFreeToken(tokenResponse);
HITLS_AUTH_PrivPassFreeToken(finalToken);
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_CHALLENGEREQUEST_OBTAIN_TC001
* @spec Private Pass Token challenge Request Parameters
* @title Test obtaining and validating token challenge request parameters obtain
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_CHALLENGEREQUEST_OBTAIN_TC001(Hex *challRequest)
{
uint8_t challengeRequestBuffer[MAX_LEN];
HITLS_AUTH_PrivPassToken *challengeRequest = NULL;
HITLS_AUTH_PrivPassCtx *ctx = NULL;
BSL_Param param[3] = {
{AUTH_PARAM_PRIVPASS_TOKEN, BSL_PARAM_TYPE_OCTETS_PTR, challengeRequestBuffer,
MAX_LEN, MAX_LEN},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REQUEST, BSL_PARAM_TYPE_OCTETS_PTR, challengeRequestBuffer,
MAX_LEN, MAX_LEN},
BSL_PARAM_END};
// Create context
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE_REQUEST, challRequest->x,
challRequest->len, &challengeRequest), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(challengeRequest, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGEREQUEST_INFO,
param, 0), HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare token challenge request", challengeRequestBuffer, param[1].useLen, challRequest->x,
challRequest->len);
EXIT:
HITLS_AUTH_PrivPassFreeToken(challengeRequest);
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_REQUEST_OBTAIN_TC001
* @spec Private Pass Token challenge Request Parameters
* @title Test obtaining and validating token challenge request parameters obtain
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_REQUEST_OBTAIN_TC001(Hex *request)
{
uint8_t tokenRequestBuffer[MAX_LEN];
uint32_t tokenRequestBufferLen = MAX_LEN;
uint16_t tokenType;
uint8_t truncatedTokenKeyId;
uint8_t blindedMsgBuffer[MAX_LEN];
uint32_t blindedMsgBufferLen = MAX_LEN;
HITLS_AUTH_PrivPassToken *tokenRequest1 = NULL;
HITLS_AUTH_PrivPassToken *tokenRequest2 = NULL;
HITLS_AUTH_PrivPassCtx *ctx = NULL;
PrivPass_TokenRequest *tmpRequest = NULL;
BSL_Param param[4] = {
{AUTH_PARAM_PRIVPASS_TOKENREQUEST_BLINDEDMSG, BSL_PARAM_TYPE_OCTETS_PTR, blindedMsgBuffer, blindedMsgBufferLen, 0},
{AUTH_PARAM_PRIVPASS_TOKENREQUEST_TRUNCATEDTOKENKEYID, BSL_PARAM_TYPE_UINT8, &truncatedTokenKeyId, 1, 0},
{AUTH_PARAM_PRIVPASS_TOKENREQUEST_TYPE, BSL_PARAM_TYPE_UINT16, &tokenType, 2, 0},
BSL_PARAM_END
};
// Create context
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_TRUE(ctx != NULL);
// Deserialize the request
ASSERT_TRUE(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_REQUEST, request->x, request->len,
&tokenRequest1) == HITLS_AUTH_SUCCESS);
// Extract parameters
ASSERT_TRUE(HITLS_AUTH_PrivPassTokenCtrl(tokenRequest1, HITLS_AUTH_PRIVPASS_GET_TOKENREQUEST_TYPE, param, 0)
== HITLS_AUTH_SUCCESS);
ASSERT_TRUE(HITLS_AUTH_PrivPassTokenCtrl(tokenRequest1, HITLS_AUTH_PRIVPASS_GET_TOKENREQUEST_TRUNCATEDTOKENKEYID,
param, 0) == HITLS_AUTH_SUCCESS);
ASSERT_TRUE(HITLS_AUTH_PrivPassTokenCtrl(tokenRequest1, HITLS_AUTH_PRIVPASS_GET_TOKENREQUEST_BLINDEDMSG, param,
0) == HITLS_AUTH_SUCCESS);
// Create new token request
tokenRequest2 = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_REQUEST);
tmpRequest = tokenRequest2->st.tokenRequest;
tmpRequest->tokenType = tokenType;
tmpRequest->truncatedTokenKeyId = truncatedTokenKeyId;
tmpRequest->blindedMsg.data = blindedMsgBuffer;
tmpRequest->blindedMsg.dataLen = param[0].useLen;
// Serialize and compare
ASSERT_TRUE(HITLS_AUTH_PrivPassSerialization(ctx, tokenRequest2, tokenRequestBuffer, &tokenRequestBufferLen)
== HITLS_AUTH_SUCCESS);
ASSERT_TRUE(memcmp(tokenRequestBuffer, request->x, request->len) == 0);
ASSERT_COMPARE("compare token request", tokenRequestBuffer, tokenRequestBufferLen, request->x, request->len);
EXIT:
tmpRequest->blindedMsg.data = NULL;
HITLS_AUTH_PrivPassFreeToken(tokenRequest1);
HITLS_AUTH_PrivPassFreeToken(tokenRequest2);
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_INSTANCE_OBTAIN_TC001
* @spec Private Pass Token Instance Parameters
* @title Test obtaining and validating token instance parameters
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_INSTANCE_OBTAIN_TC001(Hex *token)
{
uint8_t tokenInstanceBuffer[MAX_LEN];
uint32_t tokenInstanceBufferLen = MAX_LEN;
uint16_t tokenType;
uint8_t nonceBuffer[MAX_LEN];
uint32_t nonceBufferLen = MAX_LEN;
uint8_t challengeDigestBuffer[MAX_LEN];
uint32_t challengeDigestBufferLen = MAX_LEN;
uint8_t tokenKeyIdBuffer[MAX_LEN];
uint32_t tokenKeyIdBufferLen = MAX_LEN;
uint8_t authenticatorBuffer[MAX_LEN];
uint32_t authenticatorBufferLen = MAX_LEN;
HITLS_AUTH_PrivPassToken *tokenInstance1 = NULL;
HITLS_AUTH_PrivPassToken *tokenInstance2 = NULL;
HITLS_AUTH_PrivPassCtx *ctx = NULL;
PrivPass_TokenInstance *tmpToken = NULL;
BSL_Param param[6] = {
{AUTH_PARAM_PRIVPASS_TOKEN_NONCE, BSL_PARAM_TYPE_OCTETS_PTR, nonceBuffer, nonceBufferLen, 0},
{AUTH_PARAM_PRIVPASS_TOKEN_AUTHENTICATOR, BSL_PARAM_TYPE_OCTETS_PTR, authenticatorBuffer,
authenticatorBufferLen, 0},
{AUTH_PARAM_PRIVPASS_TOKEN_TYPE, BSL_PARAM_TYPE_UINT16, &tokenType, 2, 0},
{AUTH_PARAM_PRIVPASS_TOKEN_CHALLENGEDIGEST, BSL_PARAM_TYPE_OCTETS_PTR, challengeDigestBuffer,
challengeDigestBufferLen, 0},
{AUTH_PARAM_PRIVPASS_TOKEN_TOKENKEYID, BSL_PARAM_TYPE_OCTETS_PTR, tokenKeyIdBuffer, tokenKeyIdBufferLen, 0},
BSL_PARAM_END
};
// Create context
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
// Deserialize the token instance
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_INSTANCE, token->x, token->len,
&tokenInstance1), HITLS_AUTH_SUCCESS);
// Extract parameters
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenInstance1, HITLS_AUTH_PRIVPASS_GET_TOKEN_TYPE, param, 0),
HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenInstance1, HITLS_AUTH_PRIVPASS_GET_TOKEN_NONCE, param, 0),
HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenInstance1, HITLS_AUTH_PRIVPASS_GET_TOKEN_CHALLENGEDIGEST, param, 0),
HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenInstance1, HITLS_AUTH_PRIVPASS_GET_TOKEN_TOKENKEYID, param, 0),
HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenInstance1, HITLS_AUTH_PRIVPASS_GET_TOKEN_AUTHENTICATOR, param, 0),
HITLS_AUTH_SUCCESS);
// Create new token instance
tokenInstance2 = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_INSTANCE);
tmpToken = tokenInstance2->st.token;
tmpToken->tokenType = tokenType;
(void)memcpy_s(tmpToken->nonce, param[0].useLen, nonceBuffer, param[0].useLen);
(void)memcpy_s(tmpToken->challengeDigest, param[3].useLen, challengeDigestBuffer, param[3].useLen);
(void)memcpy_s(tmpToken->tokenKeyId, param[4].useLen, tokenKeyIdBuffer, param[4].useLen);
tmpToken->authenticator.data = authenticatorBuffer;
tmpToken->authenticator.dataLen = param[1].useLen;
// Serialize and compare
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, tokenInstance2, tokenInstanceBuffer, &tokenInstanceBufferLen),
HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare token instance", tokenInstanceBuffer, tokenInstanceBufferLen, token->x, token->len);
EXIT:
tmpToken->authenticator.data = NULL;
HITLS_AUTH_PrivPassFreeToken(tokenInstance1);
HITLS_AUTH_PrivPassFreeToken(tokenInstance2);
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_RESPONSE_OBTAIN_TC001
* @spec Private Pass Token Response Parameters
* @title Test obtaining and validating token response parameters obtain
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_RESPONSE_OBTAIN_TC001(Hex *response)
{
uint8_t responseBuffer[MAX_LEN];
uint32_t responseBufferLen = MAX_LEN;
HITLS_AUTH_PrivPassToken *responseToken = NULL;
HITLS_AUTH_PrivPassCtx *ctx = NULL;
BSL_Param param[3] = {
{AUTH_PARAM_PRIVPASS_TOKEN, BSL_PARAM_TYPE_OCTETS_PTR, responseBuffer, responseBufferLen, 0},
{AUTH_PARAM_PRIVPASS_TOKENRESPONSE_INFO, BSL_PARAM_TYPE_OCTETS_PTR, responseBuffer, responseBufferLen, 0},
BSL_PARAM_END};
// Create context
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_RESPONSE, response->x,
response->len, &responseToken), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(responseToken, HITLS_AUTH_PRIVPASS_GET_TOKENRESPONSE_INFO, param, 0),
HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare token response", responseBuffer, param[1].useLen, response->x,
response->len);
EXIT:
HITLS_AUTH_PrivPassFreeToken(responseToken);
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_CTRL_INVALIED_TEST_TC001
* @spec Private Pass Token Ctrl Invalid Test
* @title Test obtaining and validating token ctrl invalid test
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_CTRL_INVALIED_TEST_TC001()
{
uint8_t buffer[MAX_LEN];
uint32_t bufferLen = MAX_LEN;
BSL_Param param[4] = {
{AUTH_PARAM_PRIVPASS_TOKENREQUEST_BLINDEDMSG, BSL_PARAM_TYPE_OCTETS_PTR, buffer, bufferLen, 0},
{AUTH_PARAM_PRIVPASS_TOKENRESPONSE_INFO, BSL_PARAM_TYPE_OCTETS_PTR, buffer, bufferLen, 0},
{AUTH_PARAM_PRIVPASS_TOKEN_AUTHENTICATOR, BSL_PARAM_TYPE_OCTETS_PTR, buffer, bufferLen, 0},
BSL_PARAM_END};
HITLS_AUTH_PrivPassToken *tokenChallReq = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE_REQUEST);
HITLS_AUTH_PrivPassToken *tokenChallenge = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE);
HITLS_AUTH_PrivPassToken *tokenRequest = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_REQUEST);
HITLS_AUTH_PrivPassToken *tokenResponse = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_RESPONSE);
HITLS_AUTH_PrivPassToken *tokenInstance = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_INSTANCE);
ASSERT_TRUE(tokenChallReq != NULL);
ASSERT_TRUE(tokenChallenge != NULL);
ASSERT_TRUE(tokenRequest != NULL);
ASSERT_TRUE(tokenResponse != NULL);
ASSERT_TRUE(tokenInstance != NULL);
// for test invailed token challenge request
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(NULL, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGEREQUEST_INFO, param, 0),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenChallReq, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGEREQUEST_INFO, NULL, 0),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenChallReq, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGEREQUEST_INFO, param, 0),
HITLS_AUTH_PRIVPASS_NO_TOKEN_CHALLENGE_REQUEST);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenChallenge, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGEREQUEST_INFO, param,
0), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
// for test invailed token challenge
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenChallenge, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGE_TYPE, NULL, 0),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenChallenge, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGE_ISSUERNAME, param, 0),
HITLS_AUTH_PRIVPASS_NO_ISSUERNAME);
// for test invailed token request
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenRequest, HITLS_AUTH_PRIVPASS_GET_TOKENREQUEST_TYPE, NULL, 0),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenRequest, HITLS_AUTH_PRIVPASS_GET_TOKENREQUEST_BLINDEDMSG, param, 0),
HITLS_AUTH_PRIVPASS_NO_BLINDEDMSG);
// for test invailed token response
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(NULL, HITLS_AUTH_PRIVPASS_GET_TOKENRESPONSE_INFO, param, 0),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenResponse, HITLS_AUTH_PRIVPASS_GET_TOKENRESPONSE_INFO, param, 0),
HITLS_AUTH_PRIVPASS_NO_RESPONSE_INFO);
// for test invailed token
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(NULL, HITLS_AUTH_PRIVPASS_GET_TOKEN_TYPE, param, 0),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenInstance, HITLS_AUTH_PRIVPASS_GET_TOKEN_AUTHENTICATOR, param, 0),
HITLS_AUTH_PRIVPASS_NO_AUTHENTICATOR);
EXIT:
HITLS_AUTH_PrivPassFreeToken(tokenChallReq);
HITLS_AUTH_PrivPassFreeToken(tokenChallenge);
HITLS_AUTH_PrivPassFreeToken(tokenRequest);
HITLS_AUTH_PrivPassFreeToken(tokenResponse);
HITLS_AUTH_PrivPassFreeToken(tokenInstance);
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_CTX_DATA_OBTAIN_TC001
* @spec Private Pass ctx data obtain
* @title Test obtaining and validating ctx data obtain
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_CTX_DATA_OBTAIN_TC001(Hex *pki, Hex *nonce)
{
uint8_t nonceBuffer[MAX_LEN];
uint32_t nonceBufferLen = MAX_LEN;
uint8_t truncatedTokenKeyId;
uint8_t tokenKeyIdBuffer[MAX_LEN];
uint32_t tokenKeyIdBufferLen = MAX_LEN;
uint8_t hashBuffer[PRIVPASS_TOKEN_SHA256_SIZE];
uint32_t hashBufferLen = PRIVPASS_TOKEN_SHA256_SIZE;
HITLS_AUTH_PrivPassCtx *ctx = NULL;
BSL_Param param[4] = {
{AUTH_PARAM_PRIVPASS_CTX_NONCE, BSL_PARAM_TYPE_OCTETS_PTR, nonceBuffer, nonceBufferLen, 0},
{AUTH_PARAM_PRIVPASS_CTX_TOKENKEYID, BSL_PARAM_TYPE_OCTETS_PTR, tokenKeyIdBuffer, tokenKeyIdBufferLen, 0},
{AUTH_PARAM_PRIVPASS_CTX_TRUNCATEDTOKENKEYID, BSL_PARAM_TYPE_UINT8, &truncatedTokenKeyId, 1, 0},
BSL_PARAM_END
};
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassCtxCtrl(NULL, HITLS_AUTH_PRIVPASS_GET_CTX_TOKENKEYID, param, 0),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassCtxCtrl(ctx, HITLS_AUTH_PRIVPASS_GET_CTX_TOKENKEYID, NULL, 0),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassCtxCtrl(ctx, HITLS_AUTH_PRIVPASS_GET_CTX_TOKENKEYID, param, 0),
HITLS_AUTH_PRIVPASS_NO_PUBKEY_INFO);
ASSERT_EQ(HITLS_AUTH_PrivPassCtxCtrl(ctx, HITLS_AUTH_PRIVPASS_GET_CTX_TRUNCATEDTOKENKEYID, param, 0),
HITLS_AUTH_PRIVPASS_NO_PUBKEY_INFO);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(ctx, pki->x, pki->len), HITLS_AUTH_SUCCESS);
(void)memcpy_s(ctx->nonce, nonce->len, nonce->x, nonce->len);
ASSERT_EQ(HITLS_AUTH_PrivPassCtxCtrl(ctx, HITLS_AUTH_PRIVPASS_GET_CTX_NONCE, param, 0), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassCtxCtrl(ctx, HITLS_AUTH_PRIVPASS_GET_CTX_TOKENKEYID, param, 0), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassCtxCtrl(ctx, HITLS_AUTH_PRIVPASS_GET_CTX_TRUNCATEDTOKENKEYID, param, 0),
HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare ctx nonce", nonceBuffer, param[0].useLen, nonce->x, nonce->len);
ASSERT_EQ(EAL_Md(CRYPT_MD_SHA256, NULL, NULL, pki->x, pki->len, hashBuffer, &hashBufferLen), HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare token key id", hashBuffer, hashBufferLen, tokenKeyIdBuffer, param[1].useLen);
ASSERT_EQ(truncatedTokenKeyId, hashBuffer[PRIVPASS_TOKEN_SHA256_SIZE - 1]);
EXIT:
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/auth/privpass_token/test_suite_sdv_privpass_token.c | C | unknown | 56,548 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include "bsl_sal.h"
#include "bsl_asn1_internal.h"
#include "bsl_err.h"
#include "bsl_log.h"
#include "sal_time.h"
#include "sal_file.h"
#include "bsl_obj_internal.h"
#include "hitls_x509_local.h"
/* END_HEADER */
/* They are placed in their respective implementations and belong to specific applications, not asn1 modules */
#define BSL_ASN1_CTX_SPECIFIC_TAG_VER 0
#define BSL_ASN1_CTX_SPECIFIC_TAG_ISSUERID 1
#define BSL_ASN1_CTX_SPECIFIC_TAG_SUBJECTID 2
#define BSL_ASN1_CTX_SPECIFIC_TAG_EXTENSION 3
BSL_ASN1_TemplateItem certTempl[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0}, /* x509 */
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1}, /* tbs */
/* 2: version */
{BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_CTX_SPECIFIC_TAG_VER, BSL_ASN1_FLAG_DEFAULT, 2},
{BSL_ASN1_TAG_INTEGER, 0, 3},
/* 2: serial number */
{BSL_ASN1_TAG_INTEGER, 0, 2},
/* 2: signature info */
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 2},
{BSL_ASN1_TAG_OBJECT_ID, 0, 3},
{BSL_ASN1_TAG_ANY, BSL_ASN1_FLAG_OPTIONAL, 3}, // 8
/* 2: issuer */
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_HEADERONLY | BSL_ASN1_FLAG_SAME, 2},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SET, BSL_ASN1_FLAG_SAME, 3},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 4},
{BSL_ASN1_TAG_OBJECT_ID, 0, 5},
{BSL_ASN1_TAG_ANY, 0, 5},
/* 2: validity */
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 2},
{BSL_ASN1_TAG_CHOICE, 0, 3},
{BSL_ASN1_TAG_CHOICE, 0, 3}, // 16
/* 2: subject ref: issuer */
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_HEADERONLY | BSL_ASN1_FLAG_SAME, 2},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SET, BSL_ASN1_FLAG_SAME, 3},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 4},
{BSL_ASN1_TAG_OBJECT_ID, 0, 5},
{BSL_ASN1_TAG_ANY, 0, 5},
/* 2: subject public key info ref signature info */
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 2},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 3},
{BSL_ASN1_TAG_OBJECT_ID, 0, 4},
{BSL_ASN1_TAG_ANY, BSL_ASN1_FLAG_OPTIONAL, 4}, // 25
{BSL_ASN1_TAG_BITSTRING, 0, 3},
/* 2: issuer id, subject id */
{BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_CTX_SPECIFIC_TAG_ISSUERID, BSL_ASN1_FLAG_OPTIONAL, 2},
{BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_CTX_SPECIFIC_TAG_SUBJECTID, BSL_ASN1_FLAG_OPTIONAL, 2},
/* 2: extension */
{BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_CTX_SPECIFIC_TAG_EXTENSION,
BSL_ASN1_FLAG_OPTIONAL | BSL_ASN1_FLAG_HEADERONLY | BSL_ASN1_FLAG_SAME, 2},
{BSL_ASN1_TAG_OBJECT_ID, 0, 3},
{BSL_ASN1_TAG_BOOLEAN, BSL_ASN1_FLAG_DEFAULT, 3},
{BSL_ASN1_TAG_OCTETSTRING, 0, 3},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1}, /* signAlg */
{BSL_ASN1_TAG_OBJECT_ID, 0, 2},
{BSL_ASN1_TAG_ANY, BSL_ASN1_FLAG_OPTIONAL, 2}, // 35
{BSL_ASN1_TAG_BITSTRING, 0, 1} /* sig */
};
BSL_ASN1_TemplateItem maxDepthTempl[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 7},
};
#ifdef HITLS_BSL_SAL_FILE
static BSL_ASN1_TemplateItem g_rsaPub[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0}, /* ignore seq */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* n */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* e */
};
static BSL_ASN1_TemplateItem g_rsaPrv[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0}, /* ignore seq header */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* version */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* n */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* e */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* d */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* p */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* q */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* d mod (p-1) */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* d mod (q-1) */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* q^-1 mod p */
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE,
BSL_ASN1_FLAG_OPTIONAL | BSL_ASN1_FLAG_HEADERONLY | BSL_ASN1_FLAG_SAME, 1}, /* OtherPrimeInfos OPTIONAL */
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 2}, /* OtherPrimeInfo */
{BSL_ASN1_TAG_INTEGER, 0, 3}, /* ri */
{BSL_ASN1_TAG_INTEGER, 0, 3}, /* di */
{BSL_ASN1_TAG_INTEGER, 0, 3} /* ti */
};
typedef struct {
BSL_ASN1_TemplateItem *items;
uint32_t itemNum;
uint32_t asnNum;
} TestAsn1Param;
static TestAsn1Param g_tests[] = {
{g_rsaPub, sizeof(g_rsaPub) / sizeof(g_rsaPub[0]), 2},
{g_rsaPrv, sizeof(g_rsaPrv) / sizeof(g_rsaPrv[0]), 10},
};
#endif
typedef enum {
BSL_ASN1_TAG_VERSION_IDX = 0,
BSL_ASN1_TAG_SERIAL_IDX = 1,
BSL_ASN1_TAG_SIGNINFO_OID_IDX = 2,
BSL_ASN1_TAG_SIGNINFO_ANY_IDX = 3,
BSL_ASN1_TAG_ISSUER_IDX = 4,
BSL_ASN1_TAG_BEFORE_VALID_IDX = 5,
BSL_ASN1_TAG_AFTER_VALID_IDX = 6,
BSL_ASN1_TAG_SUBJECT_IDX = 7,
BSL_ASN1_TAG_SUBKEYINFO_IDX = 8,
BSL_ASN1_TAG_SUBKEYINFO_ANY_IDX = 9,
BSL_ASN1_TAG_SUBKEYINFO_BITSTRING_IDX = 10,
BSL_ASN1_TAG_ISSUERID_IDX = 11,
BSL_ASN1_TAG_SUBJECTID_IDX = 12,
BSL_ASN1_TAG_EXT_IDX = 13,
BSL_ASN1_TAG_SIGNALG_IDX = 14,
BSL_ASN1_TAG_SIGNALG_ANY_IDX = 15,
BSL_ASN1_TAG_SIGN_IDX = 16
} CERT_TEMPL_IDX;
#define BSL_ASN1_TIME_UTC_1 14
#define BSL_ASN1_TIME_UTC_2 15
#define BSL_ASN1_ID_ANY_1 7
#define BSL_ASN1_ID_ANY_2 24
#define BSL_ASN1_ID_ANY_3 34
char *g_oidEcc = "\x2a\x86\x48\xce\x3d\x02\01";
char *g_oidRsaPss = "\x2a\x86\x48\x86\xf7\x0d\x01\x01\x0a";
int32_t BSL_ASN1_CertTagGetOrCheck(int32_t type, uint32_t idx, void *data, void *expVal)
{
BSL_ASN1_Buffer *param = NULL;
uint32_t len = 0;
switch (type) {
case BSL_ASN1_TYPE_CHECK_CHOICE_TAG:
if (idx == BSL_ASN1_TIME_UTC_1 || idx == BSL_ASN1_TIME_UTC_2) {
uint8_t tag = *(uint8_t *) data;
if ((tag & BSL_ASN1_TAG_UTCTIME) || (tag & BSL_ASN1_TAG_GENERALIZEDTIME)) {
*(uint8_t *) expVal = tag;
return BSL_SUCCESS;
}
}
return BSL_ASN1_FAIL;
case BSL_ASN1_TYPE_GET_ANY_TAG:
param = (BSL_ASN1_Buffer *) data;
len = param->len;
if (idx == BSL_ASN1_ID_ANY_1 || idx == BSL_ASN1_ID_ANY_3) {
if (strlen(g_oidRsaPss) == len && memcmp(param->buff, g_oidRsaPss, len) == 0) {
// note: any It can be encoded empty or it can be null
*(uint8_t *) expVal = BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE;
return BSL_SUCCESS;
} else {
*(uint8_t *) expVal = BSL_ASN1_TAG_NULL; // is null
return BSL_SUCCESS;
}
}
if (idx == BSL_ASN1_ID_ANY_2) {
if (strlen(g_oidEcc) == len && memcmp(param->buff, g_oidEcc, len) == 0) {
// note: any It can be encoded empty or it can be null
*(uint8_t *) expVal = BSL_ASN1_TAG_OBJECT_ID;
return BSL_SUCCESS;
} else { //
*(uint8_t *) expVal = BSL_ASN1_TAG_NULL; // is null
return BSL_SUCCESS;
}
}
return BSL_ASN1_FAIL;
default:
break;
}
return BSL_ASN1_FAIL;
}
#ifdef HITLS_BSL_SAL_FILE
static int32_t ReadCert(const char *path, uint8_t **buff, uint32_t *len)
{
size_t readLen;
size_t fileLen = 0;
int32_t ret = BSL_SAL_FileLength(path, &fileLen);
if (ret != BSL_SUCCESS) {
return ret;
}
bsl_sal_file_handle stream = NULL;
ret = BSL_SAL_FileOpen(&stream, path, "rb");
if (ret != BSL_SUCCESS) {
return ret;
}
uint8_t *fileBuff = BSL_SAL_Malloc(fileLen);
if (fileBuff == NULL) {
BSL_SAL_FileClose(stream);
return BSL_MALLOC_FAIL;
}
do {
ret = BSL_SAL_FileRead(stream, fileBuff, 1, fileLen, &readLen);
BSL_SAL_FileClose(stream);
if (ret != BSL_SUCCESS) {
break;
}
*buff = fileBuff;
*len = (uint32_t)fileLen;
return ret;
} while (0);
BSL_SAL_FREE(fileBuff);
return ret;
}
#else
static int32_t ReadCert(const char *path, uint8_t **buff, uint32_t *len)
{
(void)path;
(void)buff;
(void)len;
return BSL_INTERNAL_EXCEPTION;
}
#endif
#ifdef HITLS_BSL_LOG
void BinLogFixLenFunc(uint32_t logId, uint32_t logLevel, uint32_t logType,
void *format, void *para1, void *para2, void *para3, void *para4)
{
(void)logLevel;
(void)logType;
printf("logId:%u\t", logId);
printf(format, para1, para2, para3, para4);
printf("\n");
}
void BinLogVarLenFunc(uint32_t logId, uint32_t logLevel, uint32_t logType,
void *format, void *para)
{
(void)logLevel;
(void)logType;
printf("logId:%u\t", logId);
printf(format, para);
printf("\n");
}
#endif
/* BEGIN_CASE */
void SDV_BSL_ASN1_DecodeTemplate_TC001(char *path)
{
#ifndef HITLS_BSL_SAL_FILE
SKIP_TEST();
#endif
#ifdef HITLS_BSL_LOG
BSL_LOG_BinLogFuncs func = {0};
func.fixLenFunc = BinLogFixLenFunc;
func.varLenFunc = BinLogVarLenFunc;
ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_SUCCESS);
#endif
uint32_t fileLen = 0;
uint8_t *fileBuff = NULL;
int32_t ret = ReadCert(path, &fileBuff, &fileLen);
ASSERT_EQ(ret, BSL_SUCCESS);
uint8_t *rawBuff = fileBuff;
BSL_ASN1_Buffer asnArr[BSL_ASN1_TAG_SIGN_IDX + 1] = {0};
BSL_ASN1_Template templ = {certTempl, sizeof(certTempl) / sizeof(certTempl[0])};
ret = BSL_ASN1_DecodeTemplate(NULL, BSL_ASN1_CertTagGetOrCheck, &fileBuff, &fileLen, asnArr, BSL_ASN1_TAG_SIGN_IDX + 1);
ASSERT_EQ(ret, BSL_NULL_INPUT);
ret = BSL_ASN1_DecodeTemplate(&templ, NULL, &fileBuff, &fileLen, asnArr, BSL_ASN1_TAG_SIGN_IDX + 1);
ASSERT_EQ(ret, BSL_ASN1_ERR_NO_CALLBACK);
ret = BSL_ASN1_DecodeTemplate(&templ, BSL_ASN1_CertTagGetOrCheck, NULL, &fileLen, asnArr, BSL_ASN1_TAG_SIGN_IDX + 1);
ASSERT_EQ(ret, BSL_NULL_INPUT);
ret = BSL_ASN1_DecodeTemplate(&templ, BSL_ASN1_CertTagGetOrCheck, &fileBuff, NULL, asnArr, BSL_ASN1_TAG_SIGN_IDX + 1);
ASSERT_EQ(ret, BSL_NULL_INPUT);
ret = BSL_ASN1_DecodeTemplate(&templ, BSL_ASN1_CertTagGetOrCheck, &fileBuff, &fileLen, NULL, BSL_ASN1_TAG_SIGN_IDX + 1);
ASSERT_EQ(ret, BSL_NULL_INPUT);
ret = BSL_ASN1_DecodeTemplate(&templ, BSL_ASN1_CertTagGetOrCheck, &fileBuff, &fileLen, asnArr, 0);
ASSERT_EQ(ret, BSL_NULL_INPUT);
EXIT:
BSL_SAL_FREE(rawBuff);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_DECODE_TEMPLATE_TC002(char *path)
{
#ifndef HITLS_BSL_SAL_FILE
SKIP_TEST();
#endif
#ifdef HITLS_BSL_LOG
BSL_LOG_BinLogFuncs func = {0};
func.fixLenFunc = BinLogFixLenFunc;
func.varLenFunc = BinLogVarLenFunc;
ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_SUCCESS);
#endif
uint32_t fileLen = 0;
uint8_t *fileBuff = NULL;
int32_t ret = ReadCert(path, &fileBuff, &fileLen);
ASSERT_EQ(ret, BSL_SUCCESS);
uint8_t *rawBuff = fileBuff;
BSL_ASN1_Buffer asnArr[BSL_ASN1_TAG_SIGN_IDX + 1] = {0};
BSL_ASN1_Template templ = {maxDepthTempl, sizeof(maxDepthTempl) / sizeof(maxDepthTempl[0])};
ret = BSL_ASN1_DecodeTemplate(&templ, BSL_ASN1_CertTagGetOrCheck, &fileBuff, &fileLen, asnArr, BSL_ASN1_TAG_SIGN_IDX + 1);
ASSERT_EQ(ret, BSL_ASN1_ERR_MAX_DEPTH);
EXIT:
BSL_SAL_FREE(rawBuff);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_CERT_FUNC_TC001(char *path, Hex *version, Hex *serial, Hex *algId, Hex *anyAlgId,
Hex *issuer, Hex *before, Hex *after, Hex *subject, Hex *pubId, Hex *pubAny, Hex *pubKey, Hex *issuerId,
Hex *subjectId, Hex *ext, Hex *signAlg, Hex *signAlgAny, Hex *sign)
{
#ifndef HITLS_BSL_SAL_FILE
SKIP_TEST();
#endif
#ifdef HITLS_BSL_LOG
BSL_LOG_BinLogFuncs func = {0};
func.fixLenFunc = BinLogFixLenFunc;
func.varLenFunc = BinLogVarLenFunc;
ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_SUCCESS);
#endif
uint32_t fileLen = 0;
uint8_t *fileBuff = NULL;
int32_t ret = ReadCert(path, &fileBuff, &fileLen);
ASSERT_EQ(ret, BSL_SUCCESS);
uint8_t *rawBuff = fileBuff;
BSL_ASN1_Buffer asnArr[BSL_ASN1_TAG_SIGN_IDX + 1] = {0};
BSL_ASN1_Template templ = {certTempl, sizeof(certTempl) / sizeof(certTempl[0])};
ret = BSL_ASN1_DecodeTemplate(&templ, BSL_ASN1_CertTagGetOrCheck,
&fileBuff, &fileLen, asnArr, BSL_ASN1_TAG_SIGN_IDX + 1);
ASSERT_EQ(ret, BSL_SUCCESS);
ASSERT_EQ(fileLen, 0);
// 证书对比
if (version->len != 0) {
ASSERT_EQ_LOG("version compare tag", asnArr[BSL_ASN1_TAG_VERSION_IDX].tag, BSL_ASN1_TAG_INTEGER);
ASSERT_COMPARE("version compare", version->x, version->len,
asnArr[BSL_ASN1_TAG_VERSION_IDX].buff, asnArr[BSL_ASN1_TAG_VERSION_IDX].len);
}
ASSERT_EQ_LOG("serial compare tag", asnArr[BSL_ASN1_TAG_SERIAL_IDX].tag, BSL_ASN1_TAG_INTEGER);
ASSERT_COMPARE("serial compare", serial->x, serial->len,
asnArr[BSL_ASN1_TAG_SERIAL_IDX].buff, asnArr[BSL_ASN1_TAG_SERIAL_IDX].len);
ASSERT_EQ_LOG("algid compare tag", asnArr[BSL_ASN1_TAG_SIGNINFO_OID_IDX].tag, BSL_ASN1_TAG_OBJECT_ID);
ASSERT_COMPARE("algid compare", algId->x, algId->len,
asnArr[BSL_ASN1_TAG_SIGNINFO_OID_IDX].buff, asnArr[BSL_ASN1_TAG_SIGNINFO_OID_IDX].len);
if (anyAlgId->len != 0) {
ASSERT_COMPARE("any algid compare", anyAlgId->x, anyAlgId->len,
asnArr[BSL_ASN1_TAG_SIGNINFO_ANY_IDX].buff, asnArr[BSL_ASN1_TAG_SIGNINFO_ANY_IDX].len);
} else {
ASSERT_EQ(asnArr[BSL_ASN1_TAG_SIGNINFO_ANY_IDX].buff, NULL);
ASSERT_EQ(asnArr[BSL_ASN1_TAG_SIGNINFO_ANY_IDX].len, 0);
}
ASSERT_EQ_LOG("issuer compare tag", asnArr[BSL_ASN1_TAG_ISSUER_IDX].tag,
BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE);
ASSERT_COMPARE("issuer compare", issuer->x, issuer->len,
asnArr[BSL_ASN1_TAG_ISSUER_IDX].buff, asnArr[BSL_ASN1_TAG_ISSUER_IDX].len);
ASSERT_COMPARE("before compare", before->x, before->len,
asnArr[BSL_ASN1_TAG_BEFORE_VALID_IDX].buff, asnArr[BSL_ASN1_TAG_BEFORE_VALID_IDX].len);
ASSERT_COMPARE("after compare", after->x, after->len,
asnArr[BSL_ASN1_TAG_AFTER_VALID_IDX].buff, asnArr[BSL_ASN1_TAG_AFTER_VALID_IDX].len);
ASSERT_EQ_LOG("subject compare tag", asnArr[BSL_ASN1_TAG_SUBJECT_IDX].tag,
BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE);
ASSERT_COMPARE("subject compare", subject->x, subject->len,
asnArr[BSL_ASN1_TAG_SUBJECT_IDX].buff, asnArr[BSL_ASN1_TAG_SUBJECT_IDX].len);
ASSERT_EQ_LOG("subject pub key compare tag", asnArr[BSL_ASN1_TAG_SUBKEYINFO_IDX].tag, BSL_ASN1_TAG_OBJECT_ID);
ASSERT_COMPARE("subject pub key id compare", pubId->x, pubId->len,
asnArr[BSL_ASN1_TAG_SUBKEYINFO_IDX].buff, asnArr[BSL_ASN1_TAG_SUBKEYINFO_IDX].len);
if (pubAny->len != 0) {
ASSERT_COMPARE("any pub key compare", pubAny->x, pubAny->len,
asnArr[BSL_ASN1_TAG_SUBKEYINFO_ANY_IDX].buff, asnArr[BSL_ASN1_TAG_SUBKEYINFO_ANY_IDX].len);
} else {
ASSERT_EQ(asnArr[BSL_ASN1_TAG_SUBKEYINFO_ANY_IDX].buff, NULL);
ASSERT_EQ(asnArr[BSL_ASN1_TAG_SUBKEYINFO_ANY_IDX].len, 0);
}
ASSERT_EQ_LOG("subject pub key compare tag", asnArr[BSL_ASN1_TAG_SUBKEYINFO_BITSTRING_IDX].tag,
BSL_ASN1_TAG_BITSTRING);
ASSERT_COMPARE("subject pub key compare", pubKey->x, pubKey->len,
asnArr[BSL_ASN1_TAG_SUBKEYINFO_BITSTRING_IDX].buff, asnArr[BSL_ASN1_TAG_SUBKEYINFO_BITSTRING_IDX].len);
if (issuerId->len != 0) {
ASSERT_COMPARE("issuerId compare", issuerId->x, issuerId->len,
asnArr[BSL_ASN1_TAG_ISSUERID_IDX].buff, asnArr[BSL_ASN1_TAG_ISSUERID_IDX].len);
} else {
ASSERT_EQ(asnArr[BSL_ASN1_TAG_ISSUERID_IDX].buff, NULL);
ASSERT_EQ(asnArr[BSL_ASN1_TAG_ISSUERID_IDX].len, 0);
}
if (subjectId->len != 0) {
ASSERT_COMPARE("subjectId compare", subjectId->x, subjectId->len,
asnArr[BSL_ASN1_TAG_SUBJECTID_IDX].buff, asnArr[BSL_ASN1_TAG_SUBJECTID_IDX].len);
} else {
ASSERT_EQ(asnArr[BSL_ASN1_TAG_SUBJECTID_IDX].buff, NULL);
ASSERT_EQ(asnArr[BSL_ASN1_TAG_SUBJECTID_IDX].len, 0);
}
if (ext->len != 0) { // v1 没有ext
ASSERT_EQ_LOG("ext compare tag", asnArr[BSL_ASN1_TAG_EXT_IDX].tag,
BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_CTX_SPECIFIC_TAG_EXTENSION);
ASSERT_COMPARE("ext compare", ext->x, ext->len,
asnArr[BSL_ASN1_TAG_EXT_IDX].buff, asnArr[BSL_ASN1_TAG_EXT_IDX].len);
}
ASSERT_EQ_LOG("signAlg compare tag", asnArr[BSL_ASN1_TAG_SIGNALG_IDX].tag, BSL_ASN1_TAG_OBJECT_ID);
ASSERT_COMPARE("signAlg compare", signAlg->x, signAlg->len,
asnArr[BSL_ASN1_TAG_SIGNALG_IDX].buff, asnArr[BSL_ASN1_TAG_SIGNALG_IDX].len);
if (signAlgAny->len != 0) {
ASSERT_COMPARE("signAlgAny compare", signAlgAny->x, signAlgAny->len,
asnArr[BSL_ASN1_TAG_SIGNALG_ANY_IDX].buff, asnArr[BSL_ASN1_TAG_SIGNALG_ANY_IDX].len);
} else {
ASSERT_EQ(asnArr[BSL_ASN1_TAG_SIGNALG_ANY_IDX].buff, NULL);
ASSERT_EQ(asnArr[BSL_ASN1_TAG_SIGNALG_ANY_IDX].len, 0);
}
ASSERT_EQ_LOG("sign compare tag", asnArr[BSL_ASN1_TAG_SIGN_IDX].tag, BSL_ASN1_TAG_BITSTRING);
ASSERT_COMPARE("sign compare", sign->x, sign->len,
asnArr[BSL_ASN1_TAG_SIGN_IDX].buff, asnArr[BSL_ASN1_TAG_SIGN_IDX].len);
EXIT:
BSL_SAL_FREE(rawBuff);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_DecodePrimitiveItem_FUNC_TC001(Hex *val)
{
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BOOLEAN, val->len, val->x};
bool res;
int32_t ret = BSL_ASN1_DecodePrimitiveItem(NULL, &res);
ASSERT_EQ(ret, BSL_NULL_INPUT);
ret = BSL_ASN1_DecodePrimitiveItem(&asn, NULL);
ASSERT_EQ(ret, BSL_NULL_INPUT);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_DecodePrimitiveItem_FUNC_TC002(int tag, Hex *val)
{
BSL_ASN1_Buffer asn = {(uint8_t)tag, val->len, val->x};
int32_t res;
int32_t ret = BSL_ASN1_DecodePrimitiveItem(NULL, &res);
ASSERT_EQ(ret, BSL_NULL_INPUT);
ret = BSL_ASN1_DecodePrimitiveItem(&asn, NULL);
ASSERT_EQ(ret, BSL_NULL_INPUT);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_DecodePrimitiveItem_FUNC_TC003(Hex *val)
{
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BITSTRING, val->len, val->x};
BSL_ASN1_BitString res;
int32_t ret = BSL_ASN1_DecodePrimitiveItem(NULL, &res);
ASSERT_EQ(ret, BSL_NULL_INPUT);
ret = BSL_ASN1_DecodePrimitiveItem(&asn, NULL);
ASSERT_EQ(ret, BSL_NULL_INPUT);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_BOOL_PRIMITIVEITEM_FUNC(Hex *val, int expectVal)
{
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BOOLEAN, val->len, val->x};
bool res;
int32_t ret = BSL_ASN1_DecodePrimitiveItem(&asn, &res);
ASSERT_EQ(ret, BSL_SUCCESS);
ASSERT_EQ((bool)expectVal, res);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_INT_PRIMITIVEITEM_FUNC(int tag, Hex *val, int result, int expectVal)
{
BSL_ASN1_Buffer asn = {(uint8_t)tag, val->len, val->x};
int32_t res;
int32_t ret = BSL_ASN1_DecodePrimitiveItem(&asn, &res);
ASSERT_EQ(ret, result);
if (ret == BSL_SUCCESS) {
ASSERT_EQ((uint32_t)expectVal, res);
}
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_BITSTRING_PRIMITIVEITEM_FUNC(Hex *val, int result, int unusedBits)
{
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BITSTRING, val->len, val->x};
BSL_ASN1_BitString res;
int32_t ret = BSL_ASN1_DecodePrimitiveItem(&asn, &res);
ASSERT_EQ(ret, result);
if (ret == BSL_SUCCESS) {
ASSERT_EQ((uint32_t)unusedBits, res.unusedBits);
ASSERT_EQ(val->len - 1, res.len);
ASSERT_COMPARE("bit string", res.buff, res.len, val->x + 1, val->len - 1);
}
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_TIME_PRIMITIVEITEM_FUNC(int tag, Hex *val, int result,
int year, int month, int day, int hour, int minute, int second)
{
BSL_ASN1_Buffer asn = {tag, val->len, val->x};
BSL_TIME res = {0};
int32_t ret = BSL_ASN1_DecodePrimitiveItem(&asn, &res);
ASSERT_EQ(ret, result);
if (ret == BSL_SUCCESS) {
ASSERT_EQ(res.year, year);
ASSERT_EQ(res.month, month);
ASSERT_EQ(res.day, day);
ASSERT_EQ(res.hour, hour);
ASSERT_EQ(res.minute, minute);
ASSERT_EQ(res.second, second);
}
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_DECODELEN_FUNC(int flag, Hex *val, int res)
{
uint8_t *encode = val->x;
uint32_t encodeLen = val->len;
uint32_t len = 0;
ASSERT_EQ(BSL_ASN1_DecodeLen(&encode, &encodeLen, flag, &len), res);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_DECODE_WRONG_INPUT_FUNC()
{
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
uint32_t valueLen = 0;
bool completeLen = 0;
uint8_t tag = 0x30;
BSL_ASN1_Buffer asnItem = {0};
ASSERT_EQ(BSL_ASN1_DecodeLen(&encode, &encodeLen, completeLen, &valueLen), BSL_NULL_INPUT);
ASSERT_EQ(BSL_ASN1_DecodeTagLen(tag, &encode, &encodeLen, &valueLen), BSL_NULL_INPUT);
ASSERT_EQ(BSL_ASN1_DecodeItem(&encode, &encodeLen, &asnItem), BSL_NULL_INPUT);
BSL_ASN1_TemplateItem listTempl = {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0};
BSL_ASN1_Template templ = {&listTempl, 1};
ASSERT_EQ(BSL_ASN1_DecodeTemplate(&templ, NULL, &encode, &encodeLen, &asnItem, 1), BSL_NULL_INPUT);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_DECODECOMPLETELEN_FUNC(Hex *val, int ecpLen, int res)
{
uint8_t *encode = val->x;
uint32_t encodeLen = val->len;
ASSERT_EQ(BSL_ASN1_GetCompleteLen(encode, &encodeLen), res);
if (res == BSL_SUCCESS) {
ASSERT_EQ(encodeLen, ecpLen);
}
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_TEMPLATE_API_TC001(void)
{
BSL_ASN1_TemplateItem item[] = {{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0}};
BSL_ASN1_Template templ = {item, 1};
BSL_ASN1_Buffer asnArr[1] = {0};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
/* templ */
ASSERT_EQ(BSL_ASN1_EncodeTemplate(NULL, asnArr, 1, &encode, &encodeLen), BSL_INVALID_ARG);
templ.templItems = NULL;
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 1, &encode, &encodeLen), BSL_INVALID_ARG);
templ.templItems = item;
templ.templNum = 0;
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 1, &encode, &encodeLen), BSL_INVALID_ARG);
templ.templNum = 1;
/* asnArr */
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, NULL, 1, &encode, &encodeLen), BSL_INVALID_ARG);
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 0, &encode, &encodeLen), BSL_INVALID_ARG);
/* encode */
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 1, NULL, &encodeLen), BSL_INVALID_ARG);
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 1, &encode, NULL), BSL_INVALID_ARG);
encode = (uint8_t*)&encodeLen;
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 1, &encode, &encodeLen), BSL_INVALID_ARG);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_TEMPLATE_ERROR_TC001(void)
{
BSL_ASN1_Template templ = {maxDepthTempl, sizeof(maxDepthTempl) / sizeof(maxDepthTempl[0])};
BSL_ASN1_Buffer asnArr[1] = {0};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 1, &encode, &encodeLen), BSL_ASN1_ERR_MAX_DEPTH);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_TEMPLATE_ERROR_TC002(int tag, int len, int ret)
{
BSL_ASN1_TemplateItem item[] = {{tag, 0, 0}};
BSL_ASN1_Template templ = {item, 1};
uint8_t data = 1;
BSL_ASN1_Buffer asn = {tag, len, &data};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), ret);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_TEMPLATE_ERROR_TC003(Hex *data)
{
BSL_ASN1_TemplateItem items[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_INTEGER, 0, 1},
{BSL_ASN1_TAG_ANY, 0, 1},
{BSL_ASN1_TAG_CHOICE, 0, 1}
};
BSL_ASN1_Template templ = {items, sizeof(items) / sizeof(items[0])};
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_INTEGER, data->len, data->x};
BSL_ASN1_Buffer asns[] = {asn, asn, asn, asn};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
uint32_t expectAsnNum = 3;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, expectAsnNum - 1, &encode, &encodeLen),
BSL_ASN1_ERR_ENCODE_ASN_LACK);
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, expectAsnNum + 1, &encode, &encodeLen),
BSL_ASN1_ERR_ENCODE_ASN_TOO_MUCH);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_TEMPLATE_ERROR_TC004(void)
{
BSL_ASN1_TemplateItem items[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_INTEGER, 0, 1},
};
BSL_ASN1_Template templ = {items, sizeof(items) / sizeof(items[0])};
int iData = 256;
BSL_ASN1_Buffer asn[] = {{BSL_ASN1_TAG_ENUMERATED, sizeof(int), (uint8_t *)&iData}};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asn, sizeof(asn) / sizeof(asn[0]), &encode, &encodeLen),
BSL_ASN1_ERR_TAG_EXPECTED);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_BOOL_FUNC(int data, Hex *expect)
{
bool bData = (bool)data;
BSL_ASN1_TemplateItem item[] = {{BSL_ASN1_TAG_BOOLEAN, 0, 0}};
BSL_ASN1_Template templ = {item, 1};
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BOOLEAN, 1, (uint8_t *)&bData};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), BSL_SUCCESS);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode bool", expect->x, expect->len, encode, encodeLen);
EXIT:
BSL_SAL_Free(encode);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_INT_LIMB_FUNC(int ret, int data, Hex *expect)
{
BSL_ASN1_TemplateItem item[] = {{BSL_ASN1_TAG_INTEGER, 0, 0}};
BSL_ASN1_Template templ = {item, 1};
BSL_ASN1_Buffer asn = {0};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeLimb(BSL_ASN1_TAG_INTEGER, data, &asn), BSL_SUCCESS);
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), ret);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode int", expect->x, expect->len, encode, encodeLen);
EXIT:
BSL_SAL_Free(asn.buff);
if (ret == BSL_SUCCESS) {
BSL_SAL_Free(encode);
}
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_INT_BN_FUNC(Hex *bn, Hex *expect)
{
BSL_ASN1_TemplateItem item[] = {{BSL_ASN1_TAG_INTEGER, 0, 0}};
BSL_ASN1_Template templ = {item, 1};
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_INTEGER, bn->len, bn->x};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), BSL_SUCCESS);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode int", expect->x, expect->len, encode, encodeLen);
EXIT:
BSL_SAL_Free(encode);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_BITSTRING_FUNC(int ret, Hex *data, int unusedBits, Hex *expect)
{
BSL_ASN1_TemplateItem item[] = {{BSL_ASN1_TAG_BITSTRING, 0, 0}};
BSL_ASN1_Template templ = {item, 1};
BSL_ASN1_BitString bs = {data->x, data->len, unusedBits};
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BITSTRING,
data->len == 0 ? 0 : sizeof(BSL_ASN1_BitString),
data->len == 0 ? NULL : (uint8_t *)&bs};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), ret);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode bitstring", expect->x, expect->len, encode, encodeLen);
EXIT:
if (ret == BSL_SUCCESS) {
BSL_SAL_Free(encode);
}
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_TIME_FUNC(int tag, int ret, int year, int month, int day, int hour, int minute, int second,
Hex *expect)
{
BSL_ASN1_TemplateItem item[] = {{tag, 0, 0}};
BSL_ASN1_Template templ = {item, 1};
BSL_TIME time = {year, month, day, hour, minute, 0, second, 0};
BSL_ASN1_Buffer asn = {tag, sizeof(BSL_TIME), (uint8_t *)&time};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), ret);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode time", expect->x, expect->len, encode, encodeLen);
EXIT:
if (ret == BSL_SUCCESS) {
BSL_SAL_Free(encode);
}
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_NULL_FUNC_TC001(Hex *expect)
{
BSL_ASN1_TemplateItem item[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_NULL, 0, 1},
{BSL_ASN1_TAG_NULL, BSL_ASN1_FLAG_OPTIONAL, 1},
{BSL_ASN1_TAG_NULL, BSL_ASN1_FLAG_DEFAULT, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
{BSL_ASN1_TAG_NULL, 0, 2},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_OPTIONAL, 1},
{BSL_ASN1_TAG_NULL, 0, 2},
};
BSL_ASN1_Template templ = {item, sizeof(item) / sizeof(item[0])};
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_NULL, 0, NULL};
BSL_ASN1_Buffer asns[] = {asn, asn, asn, asn, asn};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, sizeof(asns) / sizeof(asn), &encode, &encodeLen), BSL_SUCCESS);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode null", expect->x, expect->len, encode, encodeLen);
EXIT:
BSL_SAL_Free(encode);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_NULL_FUNC_TC002(Hex *expect)
{
uint8_t data = 1;
BSL_ASN1_TemplateItem item[] = {{BSL_ASN1_TAG_NULL, 0, 0}};
BSL_ASN1_Template templ = {item, sizeof(item) / sizeof(item[0])};
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_NULL, 1, &data};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), BSL_SUCCESS);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode null", expect->x, expect->len, encode, encodeLen);
EXIT:
BSL_SAL_Free(encode);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_TEMPLATE_FUNC_TC001(Hex *expect)
{
BSL_ASN1_TemplateItem items[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_INTEGER, 0, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_OPTIONAL | BSL_ASN1_FLAG_HEADERONLY, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_OPTIONAL | BSL_ASN1_FLAG_HEADERONLY, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_OPTIONAL | BSL_ASN1_FLAG_HEADERONLY, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 2},
{BSL_ASN1_TAG_INTEGER, 0, 3},
{BSL_ASN1_TAG_INTEGER, 0, 3},
{BSL_ASN1_TAG_INTEGER, 0, 1},
};
BSL_ASN1_Template templ = {items, sizeof(items) / sizeof(items[0])};
uint8_t iData[] = {0x01, 0x00};
uint8_t data = 0x12;
BSL_ASN1_Buffer asns[] = {
{BSL_ASN1_TAG_INTEGER, sizeof(iData) / sizeof(uint8_t), iData},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 1, &data},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, NULL},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 1, &data},
{BSL_ASN1_TAG_INTEGER, sizeof(iData) / sizeof(uint8_t), iData},
};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, sizeof(asns) / sizeof(asns[0]), &encode, &encodeLen), BSL_SUCCESS);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode headonly", expect->x, expect->len, encode, encodeLen);
EXIT:
BSL_SAL_Free(encode);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_TEMPLATE_FUNC_TC002(Hex *data, Hex *expect)
{
BSL_ASN1_TemplateItem items[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_INTEGER, 0, 1},
{BSL_ASN1_TAG_INTEGER, BSL_ASN1_FLAG_OPTIONAL, 1},
{BSL_ASN1_TAG_INTEGER, BSL_ASN1_FLAG_DEFAULT, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
{BSL_ASN1_TAG_INTEGER, 0, 2},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_OPTIONAL, 1},
{BSL_ASN1_TAG_INTEGER, 0, 2},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_DEFAULT, 1},
{BSL_ASN1_TAG_INTEGER, 0, 2},
};
BSL_ASN1_Template templ = {items, sizeof(items) / sizeof(items[0])};
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_INTEGER, data->len, data->x};
BSL_ASN1_Buffer asns[] = {asn, asn, asn, asn, asn, asn};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, sizeof(asns) / sizeof(asn), &encode, &encodeLen), BSL_SUCCESS);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode optional|default", expect->x, expect->len, encode, encodeLen);
EXIT:
BSL_SAL_Free(encode);
}
/* END_CASE */
static BSL_ASN1_TemplateItem g_templItem1[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_INTEGER, 0, 1},
{BSL_ASN1_TAG_INTEGER, 0, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
{BSL_ASN1_TAG_INTEGER, 0, 2},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
{BSL_ASN1_TAG_INTEGER, 0, 2},
};
static BSL_ASN1_TemplateItem g_templItem2[] = {
{BSL_ASN1_TAG_INTEGER, 0, 0},
{BSL_ASN1_TAG_INTEGER, 0, 0},
{BSL_ASN1_TAG_INTEGER, 0, 0},
{BSL_ASN1_TAG_INTEGER, 0, 0},
};
static BSL_ASN1_TemplateItem g_templItem3[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_INTEGER, BSL_ASN1_FLAG_OPTIONAL, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
{BSL_ASN1_TAG_INTEGER, 0, 2},
{BSL_ASN1_TAG_INTEGER, 0, 0},
{BSL_ASN1_TAG_INTEGER, BSL_ASN1_FLAG_OPTIONAL, 0},
};
static BSL_ASN1_Template g_templ[] = {
{g_templItem1, sizeof(g_templItem1) / sizeof(g_templItem1[0])},
{g_templItem2, sizeof(g_templItem2) / sizeof(g_templItem2[0])},
{g_templItem3, sizeof(g_templItem3) / sizeof(g_templItem3[0])},
};
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_TEMPLATE_FUNC_TC003(Hex *data, int templIdx, Hex *expect)
{
#define MAX_INT_ASN_NUM 4
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_INTEGER, data->len, data->x};
BSL_ASN1_Buffer asns[MAX_INT_ASN_NUM] = {asn, asn, asn, asn};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(g_templ + templIdx, asns, MAX_INT_ASN_NUM, &encode, &encodeLen), BSL_SUCCESS);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode", expect->x, expect->len, encode, encodeLen);
EXIT:
BSL_SAL_Free(encode);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_LIST_API_TC001(void)
{
BSL_ASN1_TemplateItem item[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_NULL, 0, 1},
{BSL_ASN1_TAG_NULL, 0, 1},
};
BSL_ASN1_Template templ = {item, sizeof(item) / sizeof(item[0])};
BSL_ASN1_Buffer asnArr[] = {
{BSL_ASN1_TAG_NULL, 0, NULL},
{BSL_ASN1_TAG_NULL, 0, NULL},
};
uint32_t arrNum = sizeof(asnArr) / sizeof(asnArr[0]);
BSL_ASN1_Buffer out = {0};
/* tag */
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_TIME, 1, &templ, asnArr, arrNum, &out), BSL_INVALID_ARG);
/* listSize */
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_TIME, 0, &templ, asnArr, arrNum, &out), BSL_INVALID_ARG);
/* templ */
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, NULL, asnArr, arrNum, &out), BSL_INVALID_ARG);
templ.templItems = NULL;
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SEQUENCE, 1, &templ, asnArr, arrNum, &out), BSL_INVALID_ARG);
templ.templItems = item;
templ.templNum = 0;
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, arrNum, &out), BSL_INVALID_ARG);
templ.templNum = sizeof(item) / sizeof(item[0]);
/* asnArr */
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, NULL, arrNum, &out), BSL_INVALID_ARG);
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, 0, &out), BSL_INVALID_ARG);
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, arrNum + 1, &templ, asnArr, arrNum, &out), BSL_INVALID_ARG);
/* out */
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, arrNum, NULL), BSL_INVALID_ARG);
out.buff = (uint8_t *)&arrNum;
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, arrNum, &out), BSL_INVALID_ARG);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_LIST_ERROR_TC001(void)
{
BSL_ASN1_TemplateItem item[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_NULL, 0, 1},
}; /* The expected number of asns in the current template is 1. */
BSL_ASN1_Template templ = {item, sizeof(item) / sizeof(item[0])};
BSL_ASN1_Buffer asnArr[] = {{BSL_ASN1_TAG_INTEGER, 0, NULL}};
BSL_ASN1_Buffer out = {0};
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, 1, &out), BSL_ASN1_ERR_TAG_EXPECTED);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_LIST_ERROR_TC002(void)
{
BSL_ASN1_TemplateItem item[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_NULL, 0, 1},
{BSL_ASN1_TAG_NULL, 0, 1},
}; /* The expected number of asns in the current template is 2. */
BSL_ASN1_Template templ = {item, sizeof(item) / sizeof(item[0])};
BSL_ASN1_Buffer asnArr[] = {
{BSL_ASN1_TAG_NULL, 0, NULL},
{BSL_ASN1_TAG_NULL, 0, NULL},
{BSL_ASN1_TAG_NULL, 0, NULL},
};
uint32_t arrNum = sizeof(asnArr) / sizeof(asnArr[0]);
BSL_ASN1_Buffer out = {0};
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, 1, &out), BSL_ASN1_ERR_ENCODE_ASN_LACK);
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, arrNum, &out),
BSL_ASN1_ERR_ENCODE_ASN_TOO_MUCH);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_LIST_ERROR_TC003(int tag, int ret)
{
BSL_ASN1_TemplateItem item[] = {{tag, 0, 0}};
BSL_ASN1_Template templ = {item, 1};
uint8_t data = 1;
BSL_ASN1_Buffer asn = {tag, 1, &data};
BSL_ASN1_Buffer out = {0};
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, &asn, 1, &out), ret);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_LIST_TC001(int listSize, Hex *encode)
{
#ifndef HITLS_BSL_OBJ
(void)listSize;
(void)encode;
SKIP_TEST();
#else
BSL_ASN1_TemplateItem x509Name[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SET, 0, 0},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
{BSL_ASN1_TAG_OBJECT_ID, 0, 2},
{BSL_ASN1_TAG_ANY, 0, 2}
};
BSL_ASN1_Template templ = {x509Name, sizeof(x509Name) / sizeof(x509Name[0])};
BslOidString *o = BSL_OBJ_GetOID(BSL_CID_AT_ORGANIZATIONNAME);
char *oName = "Energy TEST";
BslOidString *cn = BSL_OBJ_GetOID(BSL_CID_AT_COMMONNAME);
char *cnName = "Energy ECC Equipment Root CA 1";
BSL_ASN1_Buffer in[] = {
{BSL_ASN1_TAG_OBJECT_ID, o->octetLen, (uint8_t *)o->octs},
{BSL_ASN1_TAG_PRINTABLESTRING, strlen(oName), (uint8_t *)oName},
{BSL_ASN1_TAG_OBJECT_ID, cn->octetLen, (uint8_t *)cn->octs},
{BSL_ASN1_TAG_PRINTABLESTRING, strlen(cnName), (uint8_t *)cnName},
};
BSL_ASN1_Buffer out = {0};
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SEQUENCE, listSize, &templ, in, sizeof(in) / sizeof(in[0]), &out),
BSL_SUCCESS);
ASSERT_EQ(encode->len, out.len);
ASSERT_COMPARE("Encode list", encode->x, encode->len, out.buff, out.len);
EXIT:
BSL_SAL_FREE(out.buff);
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_DECODE_THEN_ENCODE_FUNC_TC001(int testIdx, char *path)
{
#ifndef HITLS_BSL_SAL_FILE
(void)testIdx;
(void)path;
SKIP_TEST();
#else
BSL_ASN1_Template templ = {g_tests[testIdx].items, g_tests[testIdx].itemNum};
uint32_t asnNum = g_tests[testIdx].asnNum;
uint8_t *rawData = NULL;
uint32_t dataLen = 0;
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
BSL_ASN1_Buffer *decodeAsns = (BSL_ASN1_Buffer *)BSL_SAL_Calloc(asnNum, sizeof(BSL_ASN1_Buffer));
ASSERT_TRUE(decodeAsns != NULL);
/* Decode */
ASSERT_EQ(BSL_SAL_ReadFile(path, &rawData, &dataLen), BSL_SUCCESS);
uint8_t *decode = rawData;
uint32_t decodeLen = dataLen;
ASSERT_EQ(BSL_ASN1_DecodeTemplate(&templ, NULL, &decode, &decodeLen, decodeAsns, asnNum),
BSL_SUCCESS);
ASSERT_EQ(decodeLen, 0);
/* Encode */
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, decodeAsns, asnNum, &encode, &encodeLen), BSL_SUCCESS);
ASSERT_EQ(encodeLen, dataLen);
ASSERT_COMPARE("Decode then encode", rawData, dataLen, encode, encodeLen);
EXIT:
BSL_SAL_Free(decodeAsns);
BSL_SAL_Free(rawData);
BSL_SAL_Free(encode);
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_THEN_DECODE_FUNC_TC001(int boolData, int number, Hex *bitString, int unusedBits, Hex *utf8,
int year, int month, int day, int hour, int minute, int second, Hex *headonly, Hex *expect)
{
bool bData = (bool)boolData;
BSL_ASN1_TemplateItem items[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_BOOLEAN, 0, 1},
{BSL_ASN1_TAG_INTEGER, 0, 1},
{BSL_ASN1_TAG_BITSTRING, 0, 1},
{BSL_ASN1_TAG_NULL, BSL_ASN1_FLAG_OPTIONAL, 1},
{BSL_ASN1_TAG_UTF8STRING, 0, 1},
{BSL_ASN1_TAG_UTCTIME, 0, 1},
{BSL_ASN1_TAG_UTCTIME, BSL_ASN1_FLAG_OPTIONAL, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_HEADERONLY, 1},
{BSL_ASN1_TAG_NULL, 0, 2},
};
BSL_ASN1_Buffer integer = {0};
ASSERT_EQ(BSL_ASN1_EncodeLimb(BSL_ASN1_TAG_INTEGER, number, &integer), BSL_SUCCESS);
BSL_ASN1_BitString bs = {bitString->x, bitString->len, unusedBits};
BSL_TIME time = {year, month, day, hour, minute, 0, second, 0};
BSL_ASN1_Buffer asns[] = {
{BSL_ASN1_TAG_BOOLEAN, sizeof(bool), (uint8_t *)&bData}, // 0
integer, // 1
{BSL_ASN1_TAG_BITSTRING, sizeof(BSL_ASN1_BitString), (uint8_t *)&bs}, // 2
{BSL_ASN1_TAG_NULL, 0, NULL}, // 3
{BSL_ASN1_TAG_UTF8STRING, utf8->len, utf8->x}, // 4
{BSL_ASN1_TAG_UTCTIME, sizeof(BSL_TIME), (uint8_t *)&time}, // 5
{BSL_ASN1_TAG_UTCTIME, 0, NULL}, // 6
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, headonly->len, headonly->x}, // 7
};
uint32_t asnNum = sizeof(asns) / sizeof(asns[0]);
BSL_ASN1_Template templ = {items, sizeof(items) / sizeof(items[0])};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, asnNum, &encode, &encodeLen), BSL_SUCCESS);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode", expect->x, expect->len, encode, encodeLen);
uint8_t *tmp = encode;
uint32_t tmpLen = encodeLen;
BSL_ASN1_Buffer decAns[8] = {0}; // 8 is asnNum
ASSERT_EQ(BSL_ASN1_DecodeTemplate(&templ, NULL, &tmp, &tmpLen, decAns, asnNum), BSL_SUCCESS);
ASSERT_EQ(tmpLen, 0);
bool bRes;
ASSERT_EQ(BSL_ASN1_DecodePrimitiveItem(decAns + 0, &bRes), BSL_SUCCESS); // Check the decoded data with index 0.
ASSERT_EQ(bRes, boolData);
int iRes;
ASSERT_EQ(BSL_ASN1_DecodePrimitiveItem(decAns + 1, &iRes), BSL_SUCCESS); // Check the decoded data with index 1.
ASSERT_EQ(iRes, number);
BSL_ASN1_BitString bs2 = {0};
ASSERT_EQ(BSL_ASN1_DecodePrimitiveItem(decAns + 2, &bs2), BSL_SUCCESS); // Check the decoded data with index 2.
ASSERT_EQ(bs.unusedBits, unusedBits);
BSL_TIME time2 = {0};
ASSERT_EQ(BSL_ASN1_DecodePrimitiveItem(decAns + 5, &time2), BSL_SUCCESS); // Check the decoded data with index 5.
ASSERT_EQ(time2.year, year);
ASSERT_EQ(time2.month, month);
ASSERT_EQ(time2.day, day);
ASSERT_EQ(time2.hour, hour);
ASSERT_EQ(time2.minute, minute);
ASSERT_EQ(time2.second, second);
EXIT:
BSL_SAL_Free(integer.buff);
BSL_SAL_Free(encode);
}
/* END_CASE */
/**
* For test bmpString.
*/
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_BMPSTRING_TC001(Hex *enc, char *dec)
{
int32_t ret;
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BMPSTRING, enc->len, enc->x};
BSL_ASN1_Buffer decode = {BSL_ASN1_TAG_BMPSTRING, 0, NULL};
BSL_ASN1_Buffer encode = {0};
uint8_t tmp[10] = {0xff}; // select len 10.
BSL_ASN1_Buffer wrong = {BSL_ASN1_TAG_BMPSTRING, 10, tmp};
TestMemInit();
ret = BSL_ASN1_DecodePrimitiveItem(&asn, &decode);
ASSERT_EQ(ret, BSL_SUCCESS);
uint32_t decLen = (uint32_t)strlen(dec);
ASSERT_COMPARE("Decode String", decode.buff, decode.len, dec, decLen);
BSL_ASN1_TemplateItem testTempl[] = {
{BSL_ASN1_TAG_BMPSTRING, 0, 0}
};
BSL_ASN1_Template templ = {testTempl, sizeof(testTempl) / sizeof(testTempl[0])};
ret = BSL_ASN1_EncodeTemplate(&templ, &decode, 1, &encode.buff, &encode.len);
ASSERT_EQ(ret, BSL_SUCCESS);
ASSERT_COMPARE("Encode String", encode.buff + 2, encode.len - 2, enc->x, enc->len); // skip 2 bytes header
BSL_SAL_FREE(encode.buff);
ret = BSL_ASN1_EncodeTemplate(&templ, &wrong, 1, &encode.buff, &encode.len);
ASSERT_EQ(ret, BSL_INVALID_ARG);
EXIT:
BSL_SAL_FREE(decode.buff);
BSL_SAL_FREE(encode.buff);
return;
}
/* END_CASE */
/**
* @test SDV_BSL_ASN1_GET_ENCODE_LEN_FUNC_TC001
* @title Test BSL_ASN1_GetEncodeLen function
*/
/* BEGIN_CASE */
void SDV_BSL_ASN1_GET_ENCODE_LEN_FUNC_TC001(int contentLen, int expectLen, int ret)
{
uint32_t encodeLen = 0;
ASSERT_EQ(BSL_ASN1_GetEncodeLen(contentLen, &encodeLen), ret);
if (ret == BSL_SUCCESS) {
ASSERT_EQ(encodeLen, expectLen);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_ASN1_GET_ENCODE_LEN_API_TC001
* @title Test BSL_ASN1_GetEncodeLen abnormal input parameter
*/
/* BEGIN_CASE */
void SDV_BSL_ASN1_GET_ENCODE_LEN_API_TC001(void)
{
uint32_t encodeLen = 0;
// Test null pointer
ASSERT_EQ(BSL_ASN1_GetEncodeLen(1, NULL), BSL_NULL_INPUT);
// Test length overflow
ASSERT_EQ(BSL_ASN1_GetEncodeLen(UINT32_MAX, &encodeLen), BSL_ASN1_ERR_LEN_OVERFLOW);
EXIT:
return;
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/bsl/asn1/test_suite_sdv_asn1.c | C | unknown | 48,673 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_errno.h"
#include "bsl_base64.h"
#include "bsl_uio.h"
#include "bsl_base64.h"
/* END_HEADER */
static const uint8_t src_01[] = "123";
static const char encodeResult_01[] = "MTIz";
static const uint8_t src_02[] = "a";
static const char encodeResult_02[] = "YQ==";
static const uint8_t src_03[] = " ";
static const char encodeResult_03[] = "IA==";
static const uint8_t src_04[] = "\r";
static const char encodeResult_04[] = "DQ==";
static const uint8_t src_05[] = "\n";
static const char encodeResult_05[] = "Cg==";
static const uint8_t src_06[] = "\r\n";
static const char encodeResult_06[] = "DQo=";
static const uint8_t src_07[] = "bas64eVBFH2 46 JF \n 3274jg891 \n 12974";
static const char encodeResult_07[] = "YmFzNjRlVkJGSDIgNDYgSkYgICAKICAzMjc0amc4OTEgICAgCiAgMTI5NzQ=";
static const uint8_t src_08[] = "EIR234hdi234 0 idd3 12EH9kfhwu0914l 39u14109u4 8214 klhr184yu h "
"0923174 hfweh7e0124W R2342E\nWF9\niofh392 281h236891FHWY1990hf732";
static const char encodeResult_08[] =
"RUlSMjM0aGRpMjM0IDAgIGlkZDMgICAgIDEyRUg5a2Zod3UwOTE0bCAgIDM5dTE0MTA5dTQgICAgICAgIDgyMTQga2xocjE4NHl1IGggICAgMDkyMz"
"E3NCBoZndlaDdlMDEyNFcgIFIyMzQyRQpXRjkKaW9maDM5MiAgIDI4MWgyMzY4OTFGSFdZMTk5MGhmNzMy";
static const char encodeResult_08_withNL[] =
"RUlSMjM0aGRpMjM0IDAgIGlkZDMgICAgIDEyRUg5a2Zod3UwOTE0bCAgIDM5dTE0\nMTA5dTQgICAgICAgIDgyMTQga2xocjE4NHl1IGggICAgMDky"
"MzE3NCBoZndlaDdl\nMDEyNFcgIFIyMzQyRQpXRjkKaW9maDM5MiAgIDI4MWgyMzY4OTFGSFdZMTk5MGhm\nNzMy\n";
static const char encodeResult_09[] =
"YUVJUjIzNGhkaTIzNCAwICBpZGQzICAgICAxMkVIOWtmaHd1MDkxNGwgICAzOXUx\nNDEwOXU0ICAgICAgICA4MjE0IGtsaHIxODR5dSBoICAgIDA5"
"MjMxNzQgaGZ3ZWg3\nZTAxMjRXICBSMjM0MkUKV0Y5CmlvZmgzOTIgICAyODFoMjM2ODkxRkhXWTE5OTBo\nZjczMmJhczY0ZVZCRkgyIDQ2IEpGIC"
"AgCiAgMzI3NGpnODkxICAgIAogIDEyOTc0\n";
static const uint8_t src_09[] = "Base64编码和解码测试ChineseVersion";
static const uint8_t src_10[] = "ZnUzeWU4R0hFNzEzMjY0RU5EUUlZSFI4OWhoODlURjczVUhGRElVSDMyOThZZk5FMzE4aGQyODNlajMwNEg0";
static const uint8_t src_11[] =
"aEVXVURKRFE5MkVVMTkwMzcxMzBSSkkyM1VSMDkyMzIzNEQyMUUxMjhZM0UxODI5NEVZM05SRDMyUjI0MjM0RkdG";
static const uint8_t src_12[] =
"ZnUzeWU4R0hFNzEzMjY0RU5EUUlZSFI4OWhoODlURjczVUhGRElVSDMyOThZZk5FMzE4aGQyODNlajMwNEg0emY=";
static const uint8_t src_13[] = "fu3ye8GHE713264ENDQIYHR89hh89TF73UHFDIUH3298Yf";
static const uint8_t src_14[] = "fu3ye8GHE713264ENDQIYHR89hh89TF73UHFDIUH3298Yf2";
static const uint8_t src_15[] = "fu3ye8GHE713264ENDQIYHR89hh89TF73UHFDIUH3298Yf2k";
static const uint8_t src_16[] = "fu3ye8GHE713264ENDQIYHR89hh89TF73UHFDIUH3298YfNE318hd283ej304H";
static const uint8_t src_17[] = "fu3ye8GHE713264ENDQIYHR89hh89TF73UHFDIUH3298YfNE318hd283ej304Hf";
static const uint8_t src_18[] = "fu3ye8GHE713264ENDQIYHR89hh89TF73UHFDIUH3298YfNE318hd283ej304Hfe";
static const uint8_t src_19[] =
"HD13fdwCr23r2t4UI3QW1t2vs23F432R1FChfu3ye8GHE713264ENDQIYHR89hh89TF73UHFDIUH3298Yf23hoifdh3f9832yf3ihnfdkJM32RE832"
"URDOjdjOWIHFD9832RDJkwmdcOJD38E12U38RDHi3ndewifdh3uiry298398r3843nhrdkncihfhHR2398RE2RFQ32";
typedef struct {
const uint8_t *src;
const uint32_t srcLen;
const char *encodeResult;
const uint32_t encodeResultLen;
} BASE64_TEST_DATA;
static const BASE64_TEST_DATA testData[] = {
{
.src = src_01,
.srcLen = (const uint32_t)sizeof(src_01) - 1,
.encodeResult = encodeResult_01,
.encodeResultLen = (const uint32_t)sizeof(encodeResult_01) - 1,
},
{
.src = src_02,
.srcLen = (const uint32_t)sizeof(src_02) - 1,
.encodeResult = encodeResult_02,
.encodeResultLen = (const uint32_t)sizeof(encodeResult_02) - 1,
},
{
.src = src_03,
.srcLen = (const uint32_t)sizeof(src_03) - 1,
.encodeResult = encodeResult_03,
.encodeResultLen = (const uint32_t)sizeof(encodeResult_03) - 1,
},
{
.src = src_04,
.srcLen = (const uint32_t)sizeof(src_04) - 1,
.encodeResult = encodeResult_04,
.encodeResultLen = (const uint32_t)sizeof(encodeResult_04) - 1,
},
{
.src = src_05,
.srcLen = (const uint32_t)sizeof(src_05) - 1,
.encodeResult = encodeResult_05,
.encodeResultLen = (const uint32_t)sizeof(encodeResult_05) - 1,
},
{
.src = src_06,
.srcLen = (const uint32_t)sizeof(src_06) - 1,
.encodeResult = encodeResult_06,
.encodeResultLen = (const uint32_t)sizeof(encodeResult_06) - 1,
},
{
.src = src_07,
.srcLen = (const uint32_t)sizeof(src_07) - 1,
.encodeResult = encodeResult_07,
.encodeResultLen = (const uint32_t)sizeof(encodeResult_07) - 1,
},
{
.src = src_08,
.srcLen = (const uint32_t)sizeof(src_08) - 1,
.encodeResult = encodeResult_08,
.encodeResultLen = (const uint32_t)sizeof(encodeResult_08) - 1,
},
{
.src = src_09,
.srcLen = (const uint32_t)sizeof(src_09) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
{
.src = src_10,
.srcLen = (const uint32_t)sizeof(src_10) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
{
.src = src_11,
.srcLen = (const uint32_t)sizeof(src_11) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
{
.src = src_12,
.srcLen = (const uint32_t)sizeof(src_12) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
{
.src = src_13,
.srcLen = (const uint32_t)sizeof(src_13) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
{
.src = src_14,
.srcLen = (const uint32_t)sizeof(src_14) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
{
.src = src_15,
.srcLen = (const uint32_t)sizeof(src_15) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
{
.src = src_16,
.srcLen = (const uint32_t)sizeof(src_16) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
{
.src = src_17,
.srcLen = (const uint32_t)sizeof(src_17) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
{
.src = src_18,
.srcLen = (const uint32_t)sizeof(src_18) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
{
.src = src_19,
.srcLen = (const uint32_t)sizeof(src_19) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
};
static const int32_t testCnt = sizeof(testData) / sizeof(testData[0]);
/**
* @test SDV_BSL_BASE64_FUNC_TC001
* @spec -
* @title Block coding/decoding test
* @precon nan
* @brief 1. Call BSL_Base64Encode
2. Check whether the encoded result is correct.
3. Call BSL_Base64Decode
4. Check whether the decoded buffer is the same as the original buffer.
5. Check whether the decoded buffer length is the same as the original buffer length.
* @expect 1. BSL_SUCCESS
2. same
3. BSL_SUCCESS
4. same
5. same
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC001(void)
{
TestMemInit();
for (int32_t i = 0; i < 7; i++) {
const uint8_t *srcBuf = testData[i].src;
const uint32_t srcLen = testData[i].srcLen;
uint32_t encodeBufLen = HITLS_BASE64_ENCODE_LENGTH(srcLen);
char encodeBuf[encodeBufLen];
uint32_t decodeBufLen = HITLS_BASE64_DECODE_LENGTH(encodeBufLen);
uint8_t decodeBuf[decodeBufLen];
ASSERT_TRUE(BSL_BASE64_Encode(srcBuf, srcLen, encodeBuf, &encodeBufLen) == BSL_SUCCESS);
ASSERT_TRUE(memcmp((const char *)encodeBuf, testData[i].encodeResult, testData[i].encodeResultLen) == 0);
ASSERT_TRUE(encodeBufLen == testData[i].encodeResultLen);
ASSERT_TRUE(BSL_BASE64_Decode((const char *)encodeBuf, testData[i].encodeResultLen, decodeBuf,
&decodeBufLen) == BSL_SUCCESS);
ASSERT_TRUE(memcmp((const uint8_t *)decodeBuf, srcBuf, srcLen) == 0);
ASSERT_TRUE(decodeBufLen == srcLen);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_BASE64_FUNC_TC002
* @spec -
* @title Encoding and decoding test for short input streams without line breaks
* @precon nan
* @brief 1. Call BSL_Base64EncodeInit
2. Call BSL_Base64EncodeUpdate
3. Call BSL_Base64EncodeFinal
4. Check whether the encoded result is correct.
5. Check whether the encoded length is correct.
6. Call BSL_Base64DecodeInit
7. Call BSL_Base64DecodeUpdate
8. Call BSL_Base64DecodeFinal
9. Check whether the decoded buffer is the same as the original buffer.
10. Check whether the decoded buffer length is the same as the original buffer length.
* @expect 1. BSL_SUCCESS
2. BSL_SUCCESS
3. handling the tail
4. same
5. same
6. BSL_SUCCESS
7. BSL_SUCCESS
8. BSL_SUCCESS
9. same
10. same
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC002(void)
{
for (int32_t i = 0; i < 6; i++) {
const uint8_t *srcBuf = testData[i].src;
const uint32_t srcLen = testData[i].srcLen;
uint32_t encodeBufLen = HITLS_BASE64_ENCODE_LENGTH(srcLen);
char *encodeBuf = malloc(encodeBufLen);
uint32_t decodeBufLen = HITLS_BASE64_DECODE_LENGTH(encodeBufLen);
uint8_t *decodeBuf = malloc(HITLS_BASE64_DECODE_LENGTH(encodeBufLen));
uint32_t tmpLen = encodeBufLen;
uint32_t total = 0;
BSL_Base64Ctx *ctx = BSL_BASE64_CtxNew();
ASSERT_TRUE(encodeBuf != NULL);
ASSERT_TRUE(decodeBuf != NULL);
BSL_BASE64_EncodeInit(ctx);
BSL_BASE64_SetFlags(ctx, BSL_BASE64_FLAGS_NO_NEWLINE);
ASSERT_TRUE(BSL_BASE64_EncodeUpdate(ctx, srcBuf, srcLen, encodeBuf, &tmpLen) == BSL_SUCCESS);
encodeBufLen -= tmpLen;
total += tmpLen;
tmpLen = encodeBufLen;
ASSERT_TRUE(BSL_BASE64_EncodeFinal(ctx, encodeBuf + total, &tmpLen) == BSL_SUCCESS);
total += tmpLen;
ASSERT_TRUE(total == testData[i].encodeResultLen);
ASSERT_TRUE(memcmp((const char *)encodeBuf, testData[i].encodeResult, testData[i].encodeResultLen) == 0);
BSL_BASE64_CtxClear(ctx);
tmpLen = decodeBufLen;
BSL_BASE64_DecodeInit(ctx);
ASSERT_TRUE(BSL_BASE64_DecodeUpdate(ctx, encodeBuf, (const uint32_t)total, decodeBuf, &tmpLen) == BSL_SUCCESS);
total = 0;
decodeBufLen -= tmpLen;
total += tmpLen;
tmpLen = decodeBufLen;
ASSERT_TRUE(BSL_BASE64_DecodeFinal(ctx, decodeBuf + total, &tmpLen) == BSL_SUCCESS);
total += tmpLen;
ASSERT_TRUE(total == srcLen);
ASSERT_TRUE(memcmp((const uint8_t *)decodeBuf, srcBuf, srcLen) == 0);
free(encodeBuf);
free(decodeBuf);
BSL_BASE64_CtxFree(ctx);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_BASE64_FUNC_TC003
* @spec -
* @title Encoding test for long input streams that require line breaks
* @precon nan
* @brief 1. Call BSL_Base64EncodeInit
2. Call BSL_Base64EncodeUpdate
3. Call BSL_Base64EncodeFinal
4. Check whether the encoded result is correct.
5. Check whether the encoded length is correct.
* @expect 1. BSL_SUCCESS
2. BSL_SUCCESS
3. handling the tail
4. same
5. same
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC003(void)
{
const uint8_t *srcBuf = src_08;
const uint32_t srcLen = (const uint32_t)sizeof(src_08) - 1;
uint32_t encodeBufLen = HITLS_BASE64_ENCODE_LENGTH(srcLen);
char *encodeBuf = malloc(encodeBufLen);
uint32_t tmpLen = encodeBufLen;
uint32_t total = 0;
BSL_Base64Ctx *ctx = BSL_BASE64_CtxNew();
ASSERT_TRUE(encodeBuf != NULL);
BSL_BASE64_EncodeInit(ctx);
ASSERT_TRUE(BSL_BASE64_EncodeUpdate(ctx, srcBuf, srcLen, encodeBuf, &tmpLen) == BSL_SUCCESS);
encodeBufLen -= tmpLen;
total += tmpLen;
tmpLen = encodeBufLen;
// encode and check tail for consistency, encodeBuf tail has\n
ASSERT_TRUE(BSL_BASE64_EncodeFinal(ctx, encodeBuf + total, &tmpLen) == BSL_SUCCESS);
total += tmpLen;
ASSERT_TRUE(total == sizeof(encodeResult_08_withNL) - 1);
ASSERT_TRUE(memcmp((const char *)encodeBuf, encodeResult_08_withNL, total) == 0);
EXIT:
free(encodeBuf);
BSL_BASE64_CtxFree(ctx);
}
/* END_CASE */
/**
* @test SDV_BSL_BASE64_FUNC_TC004
* @spec -
* @title Decoding test for long input streams that require line breaks
* @precon nan
* @brief 1. Call BSL_Base64DecodeInit
2. Call BSL_Base64DecodeUpdate
3. Call BSL_Base64DecodeFinal
4. Check whether the decoded buffer is the same as the original buffer.
5. Check whether the decoded buffer length is the same as the original buffer length.
* @expect 1. BSL_SUCCESS
2. BSL_SUCCESS
3. BSL_SUCCESS
4. same
5. same
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC004(void)
{
const uint8_t *srcBuf = src_08;
const uint32_t srcLen = (const uint32_t)sizeof(src_08) - 1;
uint32_t encodeBufLen = sizeof(encodeResult_08_withNL) - 1;
uint32_t decodeBufLen = HITLS_BASE64_DECODE_LENGTH(encodeBufLen);
uint8_t *decodeBuf = malloc(decodeBufLen);
uint32_t tmpLen = decodeBufLen;
uint32_t total = 0;
BSL_Base64Ctx *ctx = BSL_BASE64_CtxNew();
ASSERT_TRUE(decodeBuf != NULL);
BSL_BASE64_DecodeInit(ctx);
ASSERT_TRUE(BSL_BASE64_DecodeUpdate(ctx, encodeResult_08_withNL, encodeBufLen, decodeBuf, &tmpLen) == BSL_SUCCESS);
encodeBufLen -= tmpLen;
total += tmpLen;
tmpLen = encodeBufLen;
ASSERT_TRUE(BSL_BASE64_DecodeFinal(ctx, decodeBuf + total, &tmpLen) == BSL_SUCCESS);
total += tmpLen;
ASSERT_TRUE(total == srcLen);
ASSERT_TRUE(memcmp((const uint8_t *)decodeBuf, srcBuf, total) == 0);
EXIT:
free(decodeBuf);
BSL_BASE64_CtxFree(ctx);
}
/* END_CASE */
/**
* @test SDV_BSL_BASE64_FUNC_TC005
* @spec -
* @title Encoding and decoding test of the block that generates errors
* @precon nan
* @brief 1. Call BSL_Base64Encode
2. Check whether the encoded result is correct.
3. Call BSL_Base64Decode
4. Check whether the decoded buffer is the same as the original buffer.
5. Check whether the decoded buffer length is the same as the original buffer length.
* @expect 1. BSL_SUCCESS
2. same
3. BSL_SUCCESS
4. same
5. same
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC005(void)
{
const char illEncodeResult[] = "MT-1";
uint8_t decodeBuf[4] = {0};
uint32_t decodeBufLen = HITLS_BASE64_DECODE_LENGTH(4);
ASSERT_TRUE(BSL_BASE64_Decode(illEncodeResult, 4, decodeBuf, &decodeBufLen) != BSL_SUCCESS);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_BASE64_FUNC_TC006
* @spec -
* @title Stream Decoding Test with Errors
* @precon nan
* @brief 1. Call BSL_Base64DecodeInit
2. Call BSL_Base64DecodeUpdate
3. Call BSL_Base64DecodeUpdate
* @expect 1. BSL_SUCCESS
2. data after padding error
3. EOF Error in Middle of Block
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC006(void)
{
const char illEncodeResult_1[] = "MT=1";
const char illEncodeResult_2[] = "MT-1";
const char illEncodeResult_3[] = "MT#1";
uint32_t decodeBufLen = HITLS_BASE64_DECODE_LENGTH(4);
uint8_t *decodeBuf = malloc(decodeBufLen);
ASSERT_TRUE(decodeBuf != NULL);
BSL_Base64Ctx *ctx = BSL_BASE64_CtxNew();
BSL_BASE64_SetFlags(ctx, BSL_BASE64_FLAGS_NO_NEWLINE);
BSL_BASE64_DecodeInit(ctx);
ASSERT_TRUE(BSL_BASE64_DecodeUpdate(ctx, illEncodeResult_1, sizeof(illEncodeResult_1),
decodeBuf, &decodeBufLen) == BSL_BASE64_DATA_AFTER_PADDING);
BSL_BASE64_CtxClear(ctx);
BSL_BASE64_DecodeInit(ctx);
/* If the BSL interface is not invoked to parse the PEM file, the returned value is an error code. */
ASSERT_TRUE(BSL_BASE64_DecodeUpdate(ctx, illEncodeResult_2, sizeof(illEncodeResult_2),
decodeBuf, &decodeBufLen) == BSL_BASE64_HEADER);
BSL_BASE64_CtxClear(ctx);
BSL_BASE64_DecodeInit(ctx);
ASSERT_TRUE(BSL_BASE64_DecodeUpdate(ctx, illEncodeResult_3, sizeof(illEncodeResult_3),
decodeBuf, &decodeBufLen) == BSL_INVALID_ARG);
EXIT:
free(decodeBuf);
BSL_BASE64_CtxFree(ctx);
}
/* END_CASE */
/**
* @test SDV_BSL_BASE64_FUNC_TC007
* @spec -
* @title Empty input test
* @precon nan
* @brief 1. Call BSL_Base64Encode
2. Call BSL_Base64Encode
3. Call BSL_Base64Decode
4. Call BSL_Base64Decode
5. Call BSL_Base64EncodeUpdate
6. Call BSL_Base64EncodeFinal
7. Call BSL_Base64DecodeUpdate
8. Call BSL_Base64DecodeFinal
* @expect 1. BSL_NULL_INPUT
2. dstBufLen is insufficient:BSL_BASE64_BUF_NOT_ENOUGH
3. BSL_NULL_INPUT
4. dstBufLen is insufficient:BSL_BASE64_BUF_NOT_ENOUGH
5. BSL_NULL_INPUT
6. BSL_SUCCESS
7. BSL_NULL_INPUT
8. BSL_SUCCESS
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC007(void)
{
uint32_t zeroLen = 0;
const uint32_t srcLen = (const uint32_t)sizeof(src_01);
uint32_t encodeBufLen = HITLS_BASE64_ENCODE_LENGTH(srcLen);
char *encodeBuf = malloc(encodeBufLen);
uint32_t decodeBufLen = HITLS_BASE64_DECODE_LENGTH(encodeBufLen);
uint8_t *decodeBuf = malloc(decodeBufLen);
ASSERT_TRUE(encodeBuf != NULL);
ASSERT_TRUE(decodeBuf != NULL);
/* Block codec empty input test */
ASSERT_TRUE(BSL_BASE64_Encode(NULL, zeroLen, encodeBuf, &encodeBufLen) == BSL_NULL_INPUT);
ASSERT_TRUE(BSL_BASE64_Encode(src_01, sizeof(src_01) - 1, encodeBuf, &zeroLen) == BSL_BASE64_BUF_NOT_ENOUGH);
ASSERT_TRUE(BSL_BASE64_Decode(NULL, 0, decodeBuf, &decodeBufLen) == BSL_NULL_INPUT);
ASSERT_TRUE(BSL_BASE64_Decode(encodeResult_01, 4, decodeBuf, &zeroLen) == BSL_BASE64_BUF_NOT_ENOUGH);
/* Stream encoding/decoding empty input test */
BSL_Base64Ctx *ctx = BSL_BASE64_CtxNew();
BSL_BASE64_EncodeInit(ctx);
ASSERT_TRUE(BSL_BASE64_EncodeUpdate(ctx, NULL, zeroLen, encodeBuf, &encodeBufLen) == BSL_NULL_INPUT);
ASSERT_TRUE(BSL_BASE64_EncodeFinal(ctx, encodeBuf, &encodeBufLen) == BSL_SUCCESS);
BSL_BASE64_CtxClear(ctx);
BSL_BASE64_DecodeInit(ctx);
ASSERT_TRUE(BSL_BASE64_DecodeUpdate(ctx, NULL, (const uint32_t)encodeBufLen,
decodeBuf, &decodeBufLen) == BSL_NULL_INPUT);
ASSERT_TRUE(BSL_BASE64_DecodeFinal(ctx, decodeBuf, &decodeBufLen) == BSL_SUCCESS);
EXIT:
free(encodeBuf);
free(decodeBuf);
BSL_BASE64_CtxFree(ctx);
}
/* END_CASE */
/**
* @test SDV_BSL_BASE64_FUNC_TC008
* @spec -
* @title Multiple update tests
* @precon nan
* @brief 1. Call BSL_Base64EncodeUpdate
2. Call BSL_Base64EncodeUpdate
3. Call BSL_Base64EncodeUpdate
4. Call BSL_Base64EncodeFinal
5. Call BSL_Base64DecodeUpdate
6. Call BSL_Base64DecodeUpdate
7. Call BSL_Base64DecodeUpdate
8. Call BSL_Base64DecodeFinal
* @expect 1. BSL_SUCCESS -> The data is not encoded and is cached in the buffer. dstBufLen is set to 0.
2. BSL_SUCCESS
3. BSL_SUCCESS -> 3 + 44 < 48, The srcBuf is shorter than the length of a buffer. The data is cached in the
buffer, and dstBufLen is set to 0.
4. BSL_SUCCESS -> Handles 3 + 44 characters
5. BSL_SUCCESS -> Data that is not decoded is stored in the buffer, and dstBufLen is set to 0.
6. BSL_SUCCESS
7. BSL_SUCCESS
8. BSL_SUCCESS
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC008(void)
{
uint32_t srcLen = testData[0].srcLen + testData[7].srcLen + testData[6].srcLen;
uint32_t encodeBufLen = HITLS_BASE64_ENCODE_LENGTH(srcLen);
char *encodeBuf = malloc(encodeBufLen);
uint32_t decodeBufLen = HITLS_BASE64_DECODE_LENGTH(encodeBufLen);
uint8_t *decodeBuf = malloc(HITLS_BASE64_DECODE_LENGTH(encodeBufLen));
/*
* The output parameter dstBufLen needs to be updated in real time when the update operation is performed for
* multiple times.
*/
uint32_t tmpLen = encodeBufLen;
uint32_t total = 0;
ASSERT_TRUE(encodeBuf != NULL);
ASSERT_TRUE(decodeBuf != NULL);
/* encode */
BSL_Base64Ctx *ctx = BSL_BASE64_CtxNew();
BSL_BASE64_EncodeInit(ctx);
ASSERT_TRUE(BSL_BASE64_EncodeUpdate(ctx, testData[1].src, testData[1].srcLen, encodeBuf, &tmpLen) ==
BSL_SUCCESS); /* 1bytes */
encodeBufLen -= tmpLen;
total += tmpLen;
tmpLen = encodeBufLen;
ASSERT_TRUE(BSL_BASE64_EncodeUpdate(ctx, testData[7].src, testData[7].srcLen, encodeBuf + total, &tmpLen) ==
BSL_SUCCESS); /* 147bytes */
encodeBufLen -= tmpLen;
total += tmpLen;
tmpLen = encodeBufLen;
ASSERT_TRUE(BSL_BASE64_EncodeUpdate(ctx, testData[6].src, testData[6].srcLen, encodeBuf + total, &tmpLen) ==
BSL_SUCCESS); /* 44bytes */
encodeBufLen -= tmpLen;
total += tmpLen;
tmpLen = encodeBufLen;
ASSERT_TRUE(BSL_BASE64_EncodeFinal(ctx, encodeBuf + total, &tmpLen) == BSL_SUCCESS);
total += tmpLen;
ASSERT_TRUE((sizeof(encodeResult_09) - 1) == total);
ASSERT_TRUE(memcmp((const char *)encodeBuf, encodeResult_09, total) == 0);
BSL_BASE64_CtxClear(ctx);
/* decode */
tmpLen = decodeBufLen;
total = 0;
BSL_BASE64_DecodeInit(ctx);
ASSERT_TRUE(BSL_BASE64_DecodeUpdate(ctx, testData[0].encodeResult,
(const uint32_t)testData[0].encodeResultLen, decodeBuf, &tmpLen) == BSL_SUCCESS); /* 4bytes */
decodeBufLen -= tmpLen;
total += tmpLen;
tmpLen = decodeBufLen;
ASSERT_TRUE(BSL_BASE64_DecodeUpdate(ctx, testData[7].encodeResult,
(const uint32_t)testData[7].encodeResultLen, decodeBuf + total, &tmpLen) == BSL_SUCCESS); /* 196bytes */
decodeBufLen -= tmpLen;
total += tmpLen;
tmpLen = decodeBufLen;
ASSERT_TRUE(BSL_BASE64_DecodeUpdate(ctx, testData[6].encodeResult,
(const uint32_t)testData[6].encodeResultLen, decodeBuf + total, &tmpLen) == BSL_SUCCESS); /* 60bytes */
decodeBufLen -= tmpLen;
total += tmpLen;
tmpLen = decodeBufLen;
ASSERT_TRUE(BSL_BASE64_DecodeFinal(ctx, decodeBuf + total, &tmpLen) == BSL_SUCCESS);
total += tmpLen;
ASSERT_TRUE(srcLen == total);
EXIT:
free(encodeBuf);
free(decodeBuf);
BSL_BASE64_CtxFree(ctx);
}
/* END_CASE */
void Base64BlockEncDec(const uint8_t *buf, const uint32_t len)
{
const uint8_t *src = buf;
const uint32_t srcLen = len;
uint32_t hitlsEncLen = HITLS_BASE64_ENCODE_LENGTH(len);
char *hitlsEncResult = BSL_SAL_Malloc(hitlsEncLen);
uint32_t hitlsDecLen = HITLS_BASE64_DECODE_LENGTH(hitlsEncLen);
uint8_t *hitlsDecResult = BSL_SAL_Malloc(hitlsDecLen);
TRUE_OR_EXIT(BSL_BASE64_Encode(src, srcLen, hitlsEncResult, &hitlsEncLen) == BSL_SUCCESS);
TRUE_OR_EXIT(BSL_BASE64_Decode(hitlsEncResult, hitlsEncLen, hitlsDecResult, &hitlsDecLen) == BSL_SUCCESS);
TRUE_OR_EXIT(hitlsDecLen == srcLen);
EXIT:
BSL_SAL_Free(hitlsEncResult);
BSL_SAL_Free(hitlsDecResult);
}
/**
* @test SDV_BSL_BASE64_FUNC_TC009
* @spec -
* @title Block coding/decoding test
* @precon nan
* @brief 1. Call BSL_Base64Encode/EVP_EncodeBlock
2. Check whether the encoded result is correct.
3. Call BSL_Base64Decode/EVP_DecodeBlock
4. Check whether the decoded buffer is the same as the original buffer.
5. Check whether the decoded buffer length is the same as the original buffer length.
* @expect 1. Succeeded
2. same
3. Succeeded
4. same
5. same
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC009(void)
{
Base64BlockEncDec(testData[0].src, testData[0].srcLen);
for (int i = 8; i < testCnt; i++) {
Base64BlockEncDec(testData[i].src, testData[i].srcLen);
}
}
/* END_CASE */
void Base64Stream(const uint8_t *buf, const uint32_t len)
{
const uint8_t *src = buf;
const uint32_t srcLen = len;
uint32_t hitlsEncLen = HITLS_BASE64_ENCODE_LENGTH(len);
char *hitlsEncResult = BSL_SAL_Malloc(hitlsEncLen);
uint32_t hitlsDecLen = HITLS_BASE64_DECODE_LENGTH(hitlsEncLen);
uint8_t *hitlsDecResult = BSL_SAL_Malloc(hitlsDecLen);
/* encode */
// hitls stream encoding
uint32_t tmpLen = hitlsEncLen;
uint32_t total = 0;
BSL_Base64Ctx *ctx = BSL_BASE64_CtxNew();
BSL_BASE64_EncodeInit(ctx);
TRUE_OR_EXIT(BSL_BASE64_EncodeUpdate(ctx, src, srcLen, hitlsEncResult, &tmpLen) == BSL_SUCCESS);
hitlsEncLen -= tmpLen;
total += tmpLen;
tmpLen = hitlsEncLen;
TRUE_OR_EXIT(BSL_BASE64_EncodeFinal(ctx, hitlsEncResult + total, &tmpLen) == BSL_SUCCESS);
total += tmpLen;
/* decode */
// hitls stream encoding
BSL_BASE64_CtxClear(ctx);
tmpLen = hitlsDecLen;
BSL_BASE64_DecodeInit(ctx);
TRUE_OR_EXIT(BSL_BASE64_DecodeUpdate(ctx, hitlsEncResult, (const uint32_t)total, hitlsDecResult, &tmpLen) ==
BSL_SUCCESS);
total = 0;
hitlsDecLen -= tmpLen;
total += tmpLen;
tmpLen = hitlsDecLen;
TRUE_OR_EXIT(BSL_BASE64_DecodeFinal(ctx, hitlsDecResult + total, &tmpLen) == BSL_SUCCESS);
total += tmpLen;
EXIT:
BSL_SAL_Free(hitlsEncResult);
BSL_SAL_Free(hitlsDecResult);
BSL_BASE64_CtxFree(ctx);
}
/**
* @test SDV_BSL_BASE64_FUNC_TC010
* @spec -
* @title Single-flow encoding/decoding test
* @precon nan
* @brief 1. Call BSL_Base64EncodeInit/EVP_EncodeInit
2. Call BSL_Base64EncodeUpdate/EVP_EncodeUpdate
3. Call BSL_Base64EncodeFinal/EVP_EncodeFinal
4. Check whether the encoded result is correct.
5. Check whether the encoded length is correct.
6. Call BSL_Base64DecodeInit/EVP_DecodeInit
7. Call BSL_Base64DecodeUpdate/EVP_DecodeUpdate
8. Call BSL_Base64DecodeFinal/EVP_DecodeFinal
9. Check whether the decoded buffer is the same as the original buffer.
10. Check whether the decoded buffer length is the same as the original buffer length.
* @expect 1. Succeeded
2. BSL_SUCCESS
3. handling the tail
4. same
5. same
6. Succeeded
7. BSL_SUCCESS
8. BSL_SUCCESS
9. same
10. same
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC010(void)
{
for (int i = 0; i < testCnt; i++) {
Base64Stream(testData[i].src, testData[i].srcLen);
}
}
/* END_CASE */
void Base64StreamMultiUpdate(const BASE64_TEST_DATA data[])
{
uint32_t hitlsEncLen = HITLS_BASE64_ENCODE_LENGTH(512);
char *hitlsEncResult = malloc(hitlsEncLen);
uint32_t hitlsDecLen = HITLS_BASE64_DECODE_LENGTH(hitlsEncLen);
uint8_t *hitlsDecResult = malloc(hitlsDecLen);
/* encode */
// hitls stream encoding
uint32_t tmpLen = hitlsEncLen;
uint32_t total = 0;
BSL_Base64Ctx *ctx = BSL_BASE64_CtxNew();
ASSERT_TRUE(hitlsEncResult != NULL);
ASSERT_TRUE(hitlsDecResult != NULL);
BSL_BASE64_EncodeInit(ctx);
TRUE_OR_EXIT(BSL_BASE64_EncodeUpdate(ctx, data[12].src, data[12].srcLen, hitlsEncResult, &tmpLen) == BSL_SUCCESS);
hitlsEncLen -= tmpLen;
total += tmpLen;
tmpLen = hitlsEncLen;
TRUE_OR_EXIT(BSL_BASE64_EncodeUpdate(ctx, data[13].src, data[13].srcLen, hitlsEncResult + total, &tmpLen) ==
BSL_SUCCESS);
hitlsEncLen -= tmpLen;
total += tmpLen;
tmpLen = hitlsEncLen;
TRUE_OR_EXIT(BSL_BASE64_EncodeUpdate(ctx, data[14].src, data[14].srcLen, hitlsEncResult + total, &tmpLen) ==
BSL_SUCCESS);
hitlsEncLen -= tmpLen;
total += tmpLen;
tmpLen = hitlsEncLen;
TRUE_OR_EXIT(BSL_BASE64_EncodeFinal(ctx, hitlsEncResult + total, &tmpLen) == BSL_SUCCESS);
total += tmpLen;
/* decode */
// hitls stream encoding
BSL_BASE64_CtxClear(ctx);
total = 0;
tmpLen = hitlsDecLen;
BSL_BASE64_DecodeInit(ctx);
TRUE_OR_EXIT(BSL_BASE64_DecodeUpdate(ctx, (const char *)data[9].src, data[9].srcLen, hitlsDecResult, &tmpLen) ==
BSL_SUCCESS);
hitlsDecLen -= tmpLen;
total += tmpLen;
tmpLen = hitlsDecLen;
TRUE_OR_EXIT(BSL_BASE64_DecodeUpdate(ctx, (const char *)data[10].src, data[10].srcLen, hitlsDecResult + total,
&tmpLen) == BSL_SUCCESS);
hitlsDecLen -= tmpLen;
total += tmpLen;
tmpLen = hitlsDecLen;
TRUE_OR_EXIT(BSL_BASE64_DecodeUpdate(ctx, (const char *)data[11].src, data[11].srcLen, hitlsDecResult + total,
&tmpLen) == BSL_SUCCESS);
hitlsDecLen -= tmpLen;
total += tmpLen;
tmpLen = hitlsDecLen;
TRUE_OR_EXIT(BSL_BASE64_DecodeFinal(ctx, hitlsDecResult + total, &tmpLen) == BSL_SUCCESS);
total += tmpLen;
EXIT:
free(hitlsEncResult);
free(hitlsDecResult);
BSL_BASE64_CtxFree(ctx);
}
/**
* @test SDV_BSL_BASE64_FUNC_TC011
* @spec -
* @title Multiple update tests
* @precon nan
* @brief 1. Call BSL_Base64EncodeUpdate/EVP_EncodeUpdate
2. Call BSL_Base64EncodeUpdate/EVP_EncodeUpdate
3. Call BSL_Base64EncodeUpdate/EVP_EncodeUpdate
4. Call BSL_Base64EncodeFinal/EVP_EncodeFinal
5. memcmp encode result
6. Call BSL_Base64DecodeUpdate/EVP_DecodeUpdate
7. Call BSL_Base64DecodeUpdate/EVP_DecodeUpdate
8. Call BSL_Base64DecodeUpdate/EVP_DecodeUpdate
9. Call BSL_Base64DecodeFinal/EVP_DecodeFinal
10. memcmp decode result
* @expect 1.2.3.4. succeeded
5.same
6.7.8.9. succeeded
10.same
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC011(void)
{
Base64StreamMultiUpdate(testData);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC012(char *src, int expectRes)
{
uint32_t srcBufLen = strlen(src);
uint32_t dstBufLen = HITLS_BASE64_DECODE_LENGTH(srcBufLen);
uint8_t *dst = BSL_SAL_Malloc(dstBufLen);
ASSERT_TRUE(dst != NULL);
ASSERT_EQ(BSL_BASE64_Decode(src, srcBufLen, dst, &dstBufLen), (int32_t)expectRes);
EXIT:
BSL_SAL_Free(dst);
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/bsl/base64/test_suite_sdv_base64.c | C | unknown | 31,687 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "bsl_buffer.h"
/* END_HEADER */
/* BEGIN_CASE */
void SDV_BSL_BUFFER_FUNC_buffer_new(void)
{
TestMemInit();
// 1. Allocate a buffer.
BSL_BufMem *buf = BSL_BufMemNew();
ASSERT_EQ(buf->length, 0);
ASSERT_EQ(buf->max, 0);
// 2. len=3, len > buf->max
(void)BSL_BufMemGrowClean(buf, 3);
ASSERT_EQ(buf->length, 3);
ASSERT_EQ(buf->max, 8);
// 3. len=2, len < buf->length
(void)BSL_BufMemGrowClean(buf, 2);
ASSERT_EQ(buf->length, 2);
ASSERT_EQ(buf->max, 8);
// 4. len=6, buf->length < len < buf->max
(void)BSL_BufMemGrowClean(buf, 6);
ASSERT_EQ(buf->length, 6);
ASSERT_EQ(buf->max, 8);
EXIT:
BSL_BufMemFree(buf);
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/bsl/buffer/test_suite_sdv_buffer.c | C | unknown | 1,270 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "bsl_err.h"
#include "avl.h"
#include "bsl_uio.h"
static int32_t PthreadRWLockNew(BSL_SAL_ThreadLockHandle *lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
pthread_rwlock_t *newLock;
newLock = (pthread_rwlock_t *)BSL_SAL_Malloc(sizeof(pthread_rwlock_t));
if (newLock == NULL) {
return BSL_MALLOC_FAIL;
}
if (pthread_rwlock_init(newLock, NULL) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
*lock = newLock;
return BSL_SUCCESS;
}
static void PthreadRWLockFree(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return;
}
pthread_rwlock_destroy((pthread_rwlock_t *)lock);
BSL_SAL_FREE(lock);
}
static int32_t PthreadRWLockReadLock(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
if (pthread_rwlock_rdlock((pthread_rwlock_t *)lock) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
return BSL_SUCCESS;
}
static int32_t PthreadRWLockWriteLock(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
if (pthread_rwlock_wrlock((pthread_rwlock_t *)lock) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
return BSL_SUCCESS;
}
static int32_t PthreadRWLockUnlock(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
if (pthread_rwlock_unlock((pthread_rwlock_t *)lock) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
return BSL_SUCCESS;
}
static uint64_t PthreadGetId(void)
{
return (uint64_t)pthread_self();
}
static void PushErrorFixTimes(int32_t times)
{
while (times) {
BSL_ERR_PUSH_ERROR(times);
times--;
}
}
static void RegThreadFunc(void)
{
BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_NEW_CB_FUNC, PthreadRWLockNew);
BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_FREE_CB_FUNC, PthreadRWLockFree);
BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_READ_LOCK_CB_FUNC, PthreadRWLockReadLock);
BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_WRITE_LOCK_CB_FUNC, PthreadRWLockWriteLock);
BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_UNLOCK_CB_FUNC, PthreadRWLockUnlock);
BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_GET_ID_CB_FUNC, PthreadGetId);
}
/* END_HEADER */
/**
* @test SDV_BSL_ERR_FUNC_TC001
* @title Error code test in single-thread mode
* @precon Set the memory allocation and release functions.
* @brief
* 1. Initializes BSL_ERR. Expected result 1 is obtained.
* 2. Invoke the interface to obtain the error when no error is pushed. Expected result 2 is obtained.
* 3. Push an BSL_UIO_FAIL error when no memory function is registered. Expected result 3 is obtained.
* 4. Push the BSL_UIO_FAIL and BSL_UIO_IO_EXCEPTION error and obtain last error. Expected result 4 is obtained.
* 5. Peek last error file and error line. Expected result 5 is obtained.
* 6. Get last error file and error line. Expected result 6 is obtained.
* 7. Push an error after clear the error stack, and then obtain the error. Expected result 7 is obtained.
* 8. Delete the error stack of the thread. Expected result 8 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2. BSL_SUCCESS
* 3. BSL_UIO_FAIL
* 4. BSL_UIO_IO_EXCEPTION
* 5. BSL_UIO_FAIL
* 6. BSL_UIO_FAIL
* 7. BSL_SUCCESS
* 8. BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_ERR_FUNC_TC001(void)
{
TestMemInit();
int32_t err;
ASSERT_TRUE(BSL_ERR_Init() == BSL_SUCCESS);
/* no error is pushed */
ASSERT_TRUE(BSL_ERR_GetLastError() == BSL_SUCCESS);
/* If no memory function is registered, push an error and allocate an error stack. */
BSL_ERR_PushError(BSL_UIO_FAIL, __FILENAME__, __LINE__);
ASSERT_TRUE(BSL_ERR_GetLastError() == BSL_UIO_FAIL);
/* Push the BSL_UIO_FAIL and BSL_UIO_IO_EXCEPTION error to the error stack. */
BSL_ERR_PushError(BSL_UIO_FAIL, __FILENAME__, __LINE__);
BSL_ERR_PushError(BSL_UIO_IO_EXCEPTION, __FILENAME__, __LINE__);
err = BSL_ERR_GetLastError();
ASSERT_TRUE(err == BSL_UIO_IO_EXCEPTION);
const char *file = NULL;
uint32_t line = 0;
err = BSL_ERR_PeekLastErrorFileLine(&file, &line);
ASSERT_TRUE(err == BSL_UIO_FAIL);
ASSERT_TRUE(strcmp(file, __FILENAME__) == 0);
file = NULL;
line = 0;
err = BSL_ERR_GetLastErrorFileLine(&file, &line);
ASSERT_TRUE(err == BSL_UIO_FAIL);
ASSERT_TRUE(strcmp(file, __FILENAME__) == 0);
ASSERT_TRUE(BSL_ERR_GetLastError() == BSL_SUCCESS);
BSL_ERR_PushError(BSL_UIO_FAIL, __FILENAME__, __LINE__);
BSL_ERR_ClearError();
ASSERT_TRUE(BSL_ERR_GetLastError() == BSL_SUCCESS);
BSL_ERR_RemoveErrorStack(false);
ASSERT_TRUE(BSL_ERR_GetLastError() == BSL_SUCCESS);
EXIT:
BSL_ERR_DeInit();
return;
}
/* END_CASE */
/**
* @test SDV_BSL_ERR_STACK_FUNC_TC001
* @title After stacks are not pushed or cleared, call BSL_ERR_GetLastError to query all error stacks.
* @precon nan
* @brief
* 1. Call BSL_SAL_CallBack_Ctrl to initialize the memory. Expected result 1 is obtained.
* 2. Call BSL_SAL_CallBack_Ctrl to initialize the thread. Expected result 2 is obtained.
* 3. Call BSL_ERR_Init for initialization. Expected result 3 is obtained.
* 4. Call BSL_ERR_GetLastError to obtain stack information. Expected result 4 is obtained.
* 5. Call ERR_PUSH_ERROR to push stack layer 5. Expected result 5 is obtained.
* 6. Call BSL_ERR_ClearError to clear the stack. Expected result 6 is obtained.
* 7. Call BSL_ERR_GetLastError to obtain stack information. Expected result 7 is obtained.
* 8. Call BSL_ERR_RemoveErrorStack to delete the stack. Expected result 8 is obtained.
* 9. Call BSL_ERR_GetLastError to obtain stack information. Expected result 9 is obtained.
* 10. Call BSL_ERR_DeInit to deinitialize. Expected result 10 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2. BSL_SUCCESS
* 3. BSL_SUCCESS
* 4. BSL_SUCCESS is returned when the error code is obtained.
* 5. BSL_SUCCESS
* 6. BSL_SUCCESS
* 7. BSL_SUCCESS is returned when the error code is obtained.
* 8. BSL_SUCCESS
* 9. BSL_SUCCESS is returned when the error code is obtained.
* 10. BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_ERR_STACK_FUNC_TC001(int isRemoveAll)
{
TestMemInit();
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_NEW_CB_FUNC, PthreadRWLockNew) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_FREE_CB_FUNC, PthreadRWLockFree) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_READ_LOCK_CB_FUNC, PthreadRWLockReadLock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_WRITE_LOCK_CB_FUNC, PthreadRWLockWriteLock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_UNLOCK_CB_FUNC, PthreadRWLockUnlock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_GET_ID_CB_FUNC, PthreadGetId) == BSL_SUCCESS);
ASSERT_TRUE(BSL_ERR_Init() == BSL_SUCCESS);
ASSERT_TRUE(BSL_ERR_GetLastError() == BSL_SUCCESS);
PushErrorFixTimes(5);
ASSERT_TRUE(BSL_ERR_PeekLastErrorFileLine(NULL, NULL) == 1);
ASSERT_TRUE(BSL_ERR_GetLastErrorFileLine(NULL, NULL) == 1);
ASSERT_TRUE(BSL_ERR_GetErrorFileLine(NULL, NULL) == 5);
BSL_ERR_ClearError();
ASSERT_TRUE(BSL_ERR_GetLastError() == BSL_SUCCESS);
BSL_ERR_RemoveErrorStack((isRemoveAll == 1) ? true : false);
ASSERT_TRUE(BSL_ERR_GetLastError() == BSL_SUCCESS);
BSL_ERR_PushError(1, "2", 3);
uint32_t lineNo = 0;
char *file = NULL;
ASSERT_TRUE(BSL_ERR_PeekLastErrorFileLine(NULL, &lineNo) == 1);
ASSERT_TRUE(lineNo == 0);
ASSERT_TRUE(BSL_ERR_PeekErrorFileLine(NULL, &lineNo) == 1);
ASSERT_TRUE(lineNo == 0);
ASSERT_TRUE(BSL_ERR_PeekLastErrorFileLine((const char **)&file, &lineNo) == 1);
ASSERT_TRUE(strcmp(file, "2") == 0);
ASSERT_TRUE(lineNo == 3);
lineNo = 0;
ASSERT_TRUE(BSL_ERR_PeekErrorFileLine((const char **)&file, &lineNo) == 1);
ASSERT_TRUE(strcmp(file, "2") == 0);
ASSERT_TRUE(lineNo == 3);
ASSERT_TRUE(BSL_ERR_GetError() == 1);
BSL_ERR_PUSH_ERROR(BSL_SUCCESS);
lineNo = 0;
BSL_ERR_PushError(1, NULL, 3);
ASSERT_TRUE(BSL_ERR_PeekLastErrorFileLine(NULL, &lineNo) == 1);
ASSERT_TRUE(lineNo == 0);
ASSERT_TRUE(BSL_ERR_PeekErrorFileLine(NULL, &lineNo) == 1);
ASSERT_TRUE(lineNo == 0);
ASSERT_TRUE(BSL_ERR_PeekLastErrorFileLine((const char **)&file, &lineNo) == 1);
ASSERT_TRUE(strcmp(file, "NA") == 0);
ASSERT_TRUE(lineNo == 0);
ASSERT_TRUE(BSL_ERR_PeekErrorFileLine((const char **)&file, &lineNo) == 1);
ASSERT_TRUE(strcmp(file, "NA") == 0);
ASSERT_TRUE(lineNo == 0);
EXIT:
BSL_ERR_ClearError();
BSL_ERR_DeInit();
}
/* END_CASE */
/**
* @test SDV_BSL_ERR_COMPATIBILITY_FUNC_TC001
* @title Test the compatibility of the err module in different CMake versions.
* @precon Set the memory allocation and release functions.
* @brief
* 1. Initializes BSL_ERR. Expected result 1 is obtained.
* 2. Construct an exception to trigger the ERR module to push the stack. Expected result 2 is obtained.
* 3. Obtains the push-stack information, Expected result 3 and 4 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2. BSL_NULL_INPUT
* 3. "uio_abstraction.c"
* 4. BSL_NULL_INPUT
*/
/* BEGIN_CASE */
void SDV_BSL_ERR_COMPATIBILITY_FUNC_TC001(void)
{
#ifndef HITLS_BSL_UIO_PLT
SKIP_TEST();
#else
TestMemInit();
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_NEW_CB_FUNC, PthreadRWLockNew) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_FREE_CB_FUNC, PthreadRWLockFree) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_READ_LOCK_CB_FUNC, PthreadRWLockReadLock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_WRITE_LOCK_CB_FUNC, PthreadRWLockWriteLock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_UNLOCK_CB_FUNC, PthreadRWLockUnlock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_GET_ID_CB_FUNC, PthreadGetId) == BSL_SUCCESS);
ASSERT_TRUE(BSL_ERR_Init() == BSL_SUCCESS);
// Construct an exception to trigger the error code module to push the stack.
ASSERT_TRUE(BSL_UIO_SetMethodType(NULL, 1) == BSL_NULL_INPUT);
char *file = NULL;
uint32_t line = 0;
int32_t err = BSL_ERR_GetLastErrorFileLine((const char **)&file, &line);
ASSERT_TRUE(strcmp(file, "uio_abstraction.c") == 0);
ASSERT_TRUE(err == BSL_NULL_INPUT);
EXIT:
BSL_ERR_ClearError();
BSL_ERR_DeInit();
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_ERR_STACK_API_TC001
* @title BSL_ERR_ClearError interface testing
* @precon nan
* @brief
* 1.Call BSL_ERR_RemoveErrorStack to delete the stack. Expected result 2 is obtained.
* 2.Call BSL_ERR_ClearError to clear the stack. Expected result 3 is obtained.
* 3.Call BSL_ERR_ClearError repeatedly to clear the stack. Expected result 4 is obtained.
* @expect
* 1.BSL_SUCCESS
* 2.SUCCESS
* 3.SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_ERR_STACK_API_TC001(int isRemoveAll)
{
TestMemInit();
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_NEW_CB_FUNC, PthreadRWLockNew) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_FREE_CB_FUNC, PthreadRWLockFree) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_READ_LOCK_CB_FUNC, PthreadRWLockReadLock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_WRITE_LOCK_CB_FUNC, PthreadRWLockWriteLock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_UNLOCK_CB_FUNC, PthreadRWLockUnlock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_GET_ID_CB_FUNC, PthreadGetId) == BSL_SUCCESS);
ASSERT_TRUE(BSL_ERR_Init() == BSL_SUCCESS);
BSL_ERR_RemoveErrorStack((isRemoveAll == 1) ? true : false);
BSL_ERR_ClearError();
BSL_ERR_ClearError();
EXIT:
BSL_ERR_DeInit();
}
/* END_CASE */
/**
* @test SDV_BSL_ERR_MARK_FUNC_TC001
* @title Registering and Obtaining Error Descriptions
* @precon nan
* @brief
* 1. Set flags. Expected result 1 is obtained.
* 2. Push the error code on the stack. If no flag is set, invoke the pop to mark interface
* and obtain the latest error code. Expected result 2 is obtained.
* 3. Push three error codes into the stack and set a flag for the second error code. Expected result 3 is obtained.
* 4. Push three error codes into the stack, set flags for the second and third error codes, clear the latest flag,
* and invoke pop to mark to obtain the latest error code. Expected result 4 is obtained.
* @expect
* 1. Return BSL_ERR_ERR_NO_ERROR.
* 2. Return BSL_ERR_ERR_NO_MARK, and the error code is 0.
* 3. The flag is set successfully. The second error code is returned
* when the latest error code is obtained for the first time.
* The first error code is returned when the latest error code is obtained for the second time.
* 4. The latest error code is the second error code.
*/
/* BEGIN_CASE */
void SDV_BSL_ERR_MARK_FUNC_TC001(void)
{
ASSERT_TRUE(BSL_ERR_Init() == BSL_SUCCESS);
int32_t ret;
ret = BSL_ERR_SetMark();
ASSERT_TRUE(ret == BSL_ERR_ERR_NO_STACK);
BSL_ERR_PUSH_ERROR(BSL_UIO_FAIL);
BSL_ERR_PUSH_ERROR(BSL_UIO_IO_BUSY);
BSL_ERR_PUSH_ERROR(BSL_UIO_IO_EXCEPTION);
ret = BSL_ERR_PopToMark();
ASSERT_TRUE(ret == BSL_ERR_ERR_NO_MARK);
ret = BSL_ERR_GetLastError();
ASSERT_TRUE(ret == BSL_SUCCESS);
BSL_ERR_PUSH_ERROR(BSL_UIO_FAIL);
BSL_ERR_PUSH_ERROR(BSL_UIO_IO_BUSY);
ret = BSL_ERR_SetMark();
ASSERT_TRUE(ret == BSL_SUCCESS);
BSL_ERR_PUSH_ERROR(BSL_UIO_IO_EXCEPTION);
ret = BSL_ERR_PopToMark();
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_ERR_GetLastError();
ASSERT_TRUE(ret == BSL_UIO_IO_BUSY);
ret = BSL_ERR_GetLastError();
ASSERT_TRUE(ret == BSL_UIO_FAIL);
ret = BSL_ERR_GetLastError();
ASSERT_TRUE(ret == BSL_SUCCESS);
BSL_ERR_PUSH_ERROR(BSL_UIO_FAIL);
BSL_ERR_PUSH_ERROR(BSL_UIO_IO_BUSY);
ret = BSL_ERR_SetMark();
ASSERT_TRUE(ret == BSL_SUCCESS);
BSL_ERR_PUSH_ERROR(BSL_UIO_IO_EXCEPTION);
ret = BSL_ERR_SetMark();
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_ERR_ClearLastMark();
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_ERR_PopToMark();
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_ERR_GetLastError();
ASSERT_TRUE(ret == BSL_UIO_IO_BUSY);
EXIT:
BSL_ERR_DeInit();
}
/* END_CASE */
/**
* @test SDV_BSL_ERR_STRING_FUNC_TC001
* @title Registering and Obtaining Error Descriptions
* @precon nan
* @brief
* 1. The registration list is empty. Expected result 1 is obtained.
* 2. The registration list is not empty. The number of registrations is 0. Expected result 2 is obtained.
* 3. The registration list is not empty, and the number of registrations is 2. Expected result 3 is obtained.
* 4. Obtains the first error description. Expected result 4 is obtained.
* 5. Obtains the second error description. Expected result 5 is obtained.
* @expect
* 1. Return BSL_NULL_INPUT.
* 2. Return BSL_NULL_INPUT.
* 3. Return BSL_SUCCESS.
* 4. The result is the first error description.
* 5. The result is the second error description.
*/
/* BEGIN_CASE */
void SDV_BSL_ERR_STRING_FUNC_TC001(void)
{
RegThreadFunc();
ASSERT_TRUE(BSL_ERR_Init() == BSL_SUCCESS);
ASSERT_TRUE(BSL_ERR_AddErrStringBatch(NULL, 0) == BSL_NULL_INPUT);
ASSERT_TRUE(BSL_ERR_AddErrStringBatch((void *)-1, 0) == BSL_NULL_INPUT);
const char *uioFail = "uio is failed";
const char *tlvFail = "tlv needed type";
const BSL_ERR_Desc descList[] = {
{BSL_UIO_FAIL, uioFail},
{BSL_TLV_ERR_NO_WANT_TYPE, tlvFail},
};
ASSERT_TRUE(BSL_ERR_AddErrStringBatch(descList, 2) == BSL_SUCCESS);
ASSERT_TRUE(BSL_ERR_GetString(BSL_UIO_FAIL) == uioFail);
ASSERT_TRUE(BSL_ERR_GetString(BSL_TLV_ERR_NO_WANT_TYPE) == tlvFail);
EXIT:
BSL_ERR_RemoveErrStringBatch();
BSL_ERR_DeInit();
}
/* END_CASE */
/**
* @test SDV_BSL_ERR_AVLLR_FUNC_TC001
* @title A balanced binary tree is unbalanced due to insertion of nodes into the right subtree of the left subtree, and thus rotated to balance the test.
* @brief
* 1. insert 100
* 2. insert 120
* 3. insert 80
* 4. insert 70
* 5. insert 90
* 6. insert 85
* 7. delete 90
* 8. delete 200
* 9. delete 100
* 10. delete 120
* @expect
* 1. root node is 100
* 2. root node is 100
* 3. root node is 100
* 4. root node is 100
* 5. root node is 100
* 6. root node is 90
* 7. root node is 85
* 8. root node is 85
* 9. root node is 85
* 10. root node is 80
*/
/* BEGIN_CASE */
void SDV_BSL_ERR_AVLLR_FUNC_TC001(void)
{
TestMemInit();
ASSERT_TRUE(BSL_ERR_Init() == BSL_SUCCESS);
BSL_AvlTree *root = NULL;
root = BSL_AVL_InsertNode(root, 100, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 120, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 80, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 70, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 90, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 85, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 90);
root = BSL_AVL_DeleteNode(root, 90, NULL);
ASSERT_TRUE(root->nodeId == 85);
root = BSL_AVL_DeleteNode(root, 200, NULL);
ASSERT_TRUE(root->nodeId == 85);
root = BSL_AVL_DeleteNode(root, 100, NULL);
ASSERT_TRUE(root->nodeId == 85);
root = BSL_AVL_DeleteNode(root, 120, NULL);
ASSERT_TRUE(root->nodeId == 80);
BSL_AVL_DeleteTree(root, NULL);
EXIT:
BSL_ERR_DeInit();
}
/* END_CASE */
/**
* @test SDV_BSL_ERR_AVLLL_FUNC_TC001
* @title A balanced binary tree is unbalanced due to insertion of nodes into the left subtree of the left subtree, and thus rotated to balance the test.
* @brief
* 1. insert 100
* 2. insert 120
* 3. insert 80
* 4. insert 70
* 5. insert 90
* 6. insert 65
* 7. find 90
* 8. find 67
* 9. delete 70
* 10. delete 65
* @expect
* 1. root node is 100
* 2. root node is 100
* 3. root node is 100
* 4. root node is 100
* 5. root node is 100, the structure of the tree is
100
/ \
/ \
80 120
/ \
70 90
* 6. root node is 80, the structure of the tree is
80
/ \
/ \
70 100
/ / \
65 90 120
* 7. find
* 8. Couldn't find
* 9. root node is 80
* 10. root node is 100
*/
/* BEGIN_CASE */
void SDV_BSL_ERR_AVLLL_FUNC_TC001(void)
{
TestMemInit();
ASSERT_TRUE(BSL_ERR_Init() == BSL_SUCCESS);
BSL_AvlTree *root = NULL;
root = BSL_AVL_InsertNode(root, 100, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 120, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 80, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 70, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 90, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 65, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 80);
ASSERT_TRUE(BSL_AVL_SearchNode(root, 90) != NULL);
ASSERT_TRUE(BSL_AVL_SearchNode(root, 67) == NULL);
root = BSL_AVL_DeleteNode(root, 70, NULL);
ASSERT_TRUE(root->nodeId == 80);
root = BSL_AVL_DeleteNode(root, 65, NULL);
ASSERT_TRUE(root->nodeId == 100);
BSL_AVL_DeleteTree(root, NULL);
EXIT:
BSL_ERR_DeInit();
}
/* END_CASE */
/**
* @test SDV_BSL_ERR_AVLRL_FUNC_TC001
* @title A balanced binary tree is unbalanced due to insertion of nodes into the left subtree of the right subtree, and thus rotated to balance the test.
* @brief
* 1. insert 100
* 2. insert 80
* 3. insert 120
* 4. insert 110
* 5. insert 130
* 6. insert 105
* @expect
* 1. root node is 100
* 2. root node is 100
* 3. root node is 100
* 4. root node is 100
* 5. root node is 100
* 6. root node is 110
*/
/* BEGIN_CASE */
void SDV_BSL_ERR_AVLRL_FUNC_TC001(void)
{
TestMemInit();
ASSERT_TRUE(BSL_ERR_Init() == BSL_SUCCESS);
BSL_AvlTree *root = NULL;
root = BSL_AVL_InsertNode(root, 100, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 80, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 120, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 110, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 130, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 105, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 110);
BSL_AVL_DeleteTree(root, NULL);
EXIT:
BSL_ERR_DeInit();
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/bsl/err/test_suite_sdv_err.c | C | unknown | 22,292 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <string.h>
#include "securec.h"
#include "bsl_errno.h"
#include "list_base.h"
#include "bsl_hash.h"
#include "bsl_hash_list.h"
#include "bsl_sal.h"
#define BACKET_SIZE 64
#define MAX_NAME_LEN 64
typedef struct userData {
int id;
const char name[MAX_NAME_LEN];
} UserData;
void *UserHashKeyDupFunc(void *src, size_t size)
{
char *retKey;
char *tmpKey = (char *)src;
if (size > MAX_NAME_LEN) {
return NULL;
}
retKey = (char *)BSL_SAL_Calloc(1, size);
ASSERT_TRUE((char *)retKey != (char *)NULL);
ASSERT_TRUE(strcpy_s(retKey, size, tmpKey) == EOK);
EXIT:
return (void *)retKey;
}
void *UserHashDataDupFunc(void *src, size_t size)
{
UserData *ret = NULL;
UserData *tmpSrc = (UserData *)src;
ret = (UserData *)BSL_SAL_Calloc(1, sizeof(UserData));
ASSERT_TRUE(ret != (UserData *)NULL);
ASSERT_TRUE(memcpy_s(ret, size + 1, tmpSrc, size) == EOK);
EXIT:
return ret;
}
int UserDataCmpFunc(uintptr_t data1, uintptr_t data2)
{
return strcmp((const char*)data1, (const char*)data2);
}
void BslListFreeFunc(void *data)
{
if (data != NULL) {
BSL_SAL_Free(data);
}
}
bool ListNodeCmpFunc(const void *node, uintptr_t data)
{
const ListRawNode *t = (ListRawNode *)node;
return (uintptr_t)(t->prev) == data;
}
/* END_HEADER */
/**
* @test SDV_BSL_HASH_LIST_FUNC_TC001
* @title Hash list normal capability test
* @precon nan
* @brief
* 1. Call BSL_HASH_Create to create a hash list header. Expected result 1 is obtained.
* 2. Call BSL_HASH_Insert to add data to the hash list. Expected result 2 is obtained.
* 3. Call BSL_HASH_Size get list size. Expected result 3 is obtained.
* 4. Call BSL_CstlHashErase BSL_CstlHashClear BSL_CstlHashDestory delete data,
* Expected result 4 is obtained.
* @expect
* 1. success
* 2. BSL_SUCCESS
* 3. size is 6
* 4. success
*/
/* BEGIN_CASE */
void SDV_BSL_HASH_LIST_FUNC_TC001(void)
{
int i;
BSL_HASH_Hash *hash;
uintptr_t tmpValue;
UserData *userValue;
BSL_HASH_Iterator it;
uintptr_t tmpKey;
uint8_t key[6] = {28, 29, 30, 31, 32, 33};
UserData value[6] = {{16, "bsl_cstl001"},
{18, "bsl_cstl002"},
{15, "bsl_cstl003"},
{17, "bsl_cstl004"},
{17, "bsl_cstl005"},
{16, "bsl_cstl001"}};
ListDupFreeFuncPair valueFunc = {UserHashDataDupFunc, BSL_SAL_Free};
TestMemInit();
hash = BSL_HASH_Create(BACKET_SIZE, NULL, NULL, NULL, &valueFunc);
ASSERT_TRUE(hash != (BSL_HASH_Hash *)NULL);
for (i = 0; i < 5; i++) {
ASSERT_TRUE(BSL_HASH_Insert(hash, key[i], 0, (uintptr_t)&value[i], sizeof(UserData)) == BSL_SUCCESS);
}
ASSERT_TRUE(BSL_HASH_Put(hash, key[i], 0, (uintptr_t)&value[i], sizeof(UserData), NULL) == BSL_SUCCESS);
ASSERT_TRUE(BSL_HASH_Size(hash) == (size_t)6);
ASSERT_TRUE(BSL_HASH_At(hash, key[4], &tmpValue) == BSL_SUCCESS);
userValue = (UserData *)tmpValue;
ASSERT_TRUE(userValue->id == value[4].id);
ASSERT_TRUE(strcmp(userValue->name, value[4].name) == 0);
it = BSL_HASH_Find(hash, key[4]);
ASSERT_TRUE(it != BSL_HASH_IterEnd(hash));
ASSERT_TRUE(BSL_HASH_HashIterKey(hash, it) == (uintptr_t)key[4]);
userValue = (UserData *)BSL_HASH_IterValue(hash, it);
ASSERT_TRUE(userValue != (UserData *)NULL);
ASSERT_TRUE(userValue->id == value[4].id);
ASSERT_TRUE(strcmp(userValue->name, value[4].name) == 0);
(void)BSL_HASH_Erase(hash, key[4]);
ASSERT_TRUE(BSL_HASH_Size(hash) == (size_t)5);
for (it = BSL_HASH_IterBegin(hash); it != BSL_HASH_IterEnd(hash);) {
tmpKey = BSL_HASH_HashIterKey(hash, it);
it = BSL_HASH_Erase(hash, tmpKey);
}
ASSERT_TRUE(BSL_HASH_Size(hash) == (size_t)0);
BSL_HASH_Destory(hash);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_HASH_LIST_FUNC_TC002
* @title Hash list normal capability test, key type is string.
* @precon nan
* @brief
* 1. Call BSL_HASH_Create to create a hash list header. Expected result 1 is obtained.
* 2. Call BSL_HASH_Insert to add data to the hash list. Expected result 2 is obtained.
* 3. Call BSL_HASH_Size get list size. Expected result 3 is obtained.
* 4. Call BSL_CstlHashErase BSL_CstlHashClear BSL_CstlHashDestory delete data,
* Expected result 4 is obtained.
* @expect
* 1. success
* 2. BSL_SUCCESS
* 3. size is 6
* 4. success
*/
/* BEGIN_CASE */
void SDV_BSL_HASH_LIST_FUNC_TC002(void)
{
uint32_t i;
BSL_HASH_Hash *hash;
const char *key[6] = {"7201028", "7201029", "7201030", "7201031", "7201032", "7201033"};
UserData value[6] = {{16, "bsl_cstl001"},
{18, "bsl_cstl002"},
{15, "bsl_cstl003"},
{17, "bsl_cstl004"},
{17, "bsl_cstl005"},
{16, "bsl_cstl001"}};
char *tmpKey;
uintptr_t tmpValue;
UserData *userValue;
BSL_HASH_Iterator it;
ListDupFreeFuncPair keyFunc = {UserHashKeyDupFunc, BSL_SAL_Free};
ListDupFreeFuncPair valueFunc = {UserHashDataDupFunc, BSL_SAL_Free};
hash = BSL_HASH_Create(BACKET_SIZE, BSL_HASH_CodeCalcStr, BSL_HASH_MatchStr, &keyFunc, &valueFunc);
ASSERT_TRUE(hash != (BSL_HASH_Hash *)NULL);
for (i = 0; i < 6; i++) {
ASSERT_TRUE(
BSL_HASH_Insert(hash, (uintptr_t)key[i], strlen(key[i]) + 1, (uintptr_t)&value[i], sizeof(UserData)) ==
BSL_SUCCESS);
}
ASSERT_TRUE(BSL_HASH_Put(hash, (uintptr_t)key[1], strlen(key[1]) + 1, (uintptr_t)&value[1], sizeof(UserData), NULL)
== BSL_SUCCESS);
ASSERT_TRUE(BSL_HASH_Empty(hash) == false);
ASSERT_TRUE(BSL_HASH_Size(hash) == (size_t)6);
ASSERT_TRUE(BSL_HASH_At(hash, (uintptr_t)key[4], &tmpValue) == BSL_SUCCESS);
userValue = (UserData *)tmpValue;
ASSERT_TRUE(userValue->id == value[4].id);
ASSERT_TRUE(strcmp(userValue->name, value[4].name) == 0);
it = BSL_HASH_Find(hash, (uintptr_t)key[4]);
ASSERT_TRUE(it != BSL_HASH_IterEnd(hash));
ASSERT_TRUE(strcmp((const char *)BSL_HASH_HashIterKey(hash, it), key[4]) == 0);
userValue = (UserData *)BSL_HASH_IterValue(hash, it);
ASSERT_TRUE(userValue != (UserData *)NULL);
ASSERT_TRUE(userValue->id == value[4].id);
ASSERT_TRUE(strcmp(userValue->name, value[4].name) == 0);
(void)BSL_HASH_Erase(hash, (uintptr_t)key[4]);
ASSERT_TRUE(BSL_HASH_Size(hash) == (size_t)5);
for (it = BSL_HASH_IterBegin(hash); it != BSL_HASH_IterEnd(hash);) {
tmpKey = (char *)BSL_HASH_HashIterKey(hash, it);
it = BSL_HASH_Erase(hash, (uintptr_t)tmpKey);
}
ASSERT_TRUE(BSL_HASH_Size(hash) == (size_t)0);
BSL_HASH_Destory(hash);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_HASH_LIST_FUNC_TC003
* @title bsl list normal capability test, key type is string.
* @precon nan
* @brief
* 1. Call BSL_ListInit to create a hash list header. Expected result 1 is obtained.
* 2. Call BSL_ListPushFront and BSL_ListPushBack to add data to the hash list. Expected result 2 is obtained.
* 3. Perform find and delete. Expected result 3 is obtained.
* 4. Call BSL_ListIterErase delete data. Expected result 4 is obtained.
* @expect
* 1. success
* 2. BSL_SUCCESS
* 3. success
* 4. success
*/
/* BEGIN_CASE */
void SDV_BSL_HASH_LIST_FUNC_TC003(void)
{
uint32_t i;
BSL_List *list = BSL_SAL_Calloc(1, sizeof(BSL_List));
ASSERT_TRUE(list != NULL);
const char *data[7] = {"7201028", "7201029", "7201030", "7201031", "7201032", "7201033", "777888"};
BSL_ListIterator it = NULL;
ListDupFreeFuncPair valueFunc = {UserHashKeyDupFunc, BSL_SAL_Free};
ASSERT_EQ(BSL_ListInit(list, &valueFunc), BSL_SUCCESS);
for (i = 0; i < 5; i++) {
ASSERT_EQ( BSL_ListPushFront(list, (uintptr_t)data[i], strlen(data[i]) + 1), BSL_SUCCESS);
}
ASSERT_EQ(BSL_ListPushBack(list, (uintptr_t)data[i], strlen(data[i]) + 1), BSL_SUCCESS);
ASSERT_TRUE(BSL_ListSize(list) == (size_t)i + 1);
ASSERT_TRUE(strcmp((const char* )BSL_ListFront(list), data[4]) == 0);
ASSERT_TRUE(strcmp((const char* )BSL_ListBack(list), data[5]) == 0);
it = BSL_ListIterFind(list, UserDataCmpFunc, (uintptr_t)data[1]);
ASSERT_TRUE(it != BSL_ListIterEnd(list));
ASSERT_TRUE(strcmp((const char* )BSL_ListIterData(it), data[1]) == 0);
ASSERT_TRUE(BSL_ListInsert(list, it, (uintptr_t)data[6], strlen(data[6]) + 1) == BSL_SUCCESS);
ASSERT_TRUE(BSL_ListIterPrev(list, it) != NULL);
ASSERT_TRUE(BSL_ListIterNext(list, it) != NULL);
ASSERT_TRUE(BSL_ListIterBegin(list) != NULL);
ASSERT_TRUE(BSL_ListIterEnd(list) != NULL);
ASSERT_TRUE(BSL_ListPopFront(list) == BSL_SUCCESS);
ASSERT_TRUE(BSL_ListPopBack(list) == BSL_SUCCESS);
ASSERT_TRUE(BSL_ListIterErase(list, it) != NULL);
EXIT:
BSL_ListDeinit(list);
BSL_SAL_Free(list);
return;
}
/* END_CASE */
/**
* @test SDV_BSL_HASH_LIST_FUNC_TC004
* @title raw list normal capability test.
* @precon nan
* @brief
* 1. Call ListRawInit to create a raw list header. Expected result 1 is obtained.
* 2. Call ListRawPushFront to add node to the list. Expected result 2 is obtained.
* 3. Perform find and delete. Expected result 3 is obtained.
* 4. Call ListRawDeinit delete list. Expected result 4 is obtained.
* @expect
* 1. create success
* 2. add success
* 3. success
* 4. success
*/
/* BEGIN_CASE */
void SDV_BSL_HASH_LIST_FUNC_TC004(void)
{
uint32_t i;
ListRawNode *node = BSL_SAL_Calloc(6, sizeof(ListRawNode));
ASSERT_TRUE(node != NULL);
RawList *list = BSL_SAL_Calloc(1, sizeof(RawList));
ASSERT_TRUE(list != NULL);
ASSERT_EQ(ListRawInit(list, NULL), BSL_SUCCESS);
for (i = 0; i < 6; i++) {
ASSERT_EQ(ListRawPushFront(list, &node[i]), BSL_SUCCESS);
}
ListRawNode *it = ListRawBack(list);
ASSERT_TRUE(it != NULL);
ASSERT_TRUE(it->prev != NULL);
it = ListRawGetPrev(list, &node[1]);
ASSERT_TRUE(it != NULL);
ASSERT_TRUE(it->next != NULL);
it = ListRawFindNode(list, ListNodeCmpFunc, (uintptr_t)&node[1]);
ASSERT_TRUE(it != NULL);
ASSERT_EQ(ListRawPopFront(list), BSL_SUCCESS);
ASSERT_EQ(ListRawPopBack(list), BSL_SUCCESS);
ASSERT_EQ(ListRawDeinit(list), BSL_SUCCESS);
EXIT:
BSL_SAL_Free(list);
BSL_SAL_Free(node);
return;
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/bsl/hash/test_suite_sdv_hash.c | C | unknown | 11,088 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "securec.h"
#include "bsl_errno.h"
#include "bsl_list.h"
#include "bsl_list_internal.h"
/* END_HEADER */
typedef struct {
int value;
int key;
} LIST_NODE;
#define MAX_NAME_LEN 64
/* User Structure Definition */
typedef struct userListData {
int id;
char name[MAX_NAME_LEN];
} UserData;
static void EmptyFree(void *data)
{
(void)data;
}
void UserDataFree(void *data)
{
(void)data;
return;
}
static int Compare(const void *data1, const void *data2)
{
return **(int **)data1 > **(int **)data2;
}
static int32_t UserDataCompare(const void *data1, const void *data2)
{
if (data1 == NULL || data2 == NULL) {
return 1;
}
UserData *tmp1 = (UserData *)data1;
UserData *tmp2 = (UserData *)data2;
if (tmp1->id != tmp2->id) {
return -1;
}
if (strlen(tmp1->name) != strlen(tmp2->name)) {
return -1;
}
if (memcmp(tmp1->name, tmp2->name, strlen(tmp1->name)) != 0) {
return -1;
}
return 0;
}
// data1:(pList)->curr->data, data2:pSearchFor
static int32_t UserDataCompareByName(const void *data1, const void *data2)
{
if (data1 == NULL || data2 == NULL) {
return 1;
}
UserData *tmp1 = (UserData *)data1;
char *tmp2 = (char *)data2;
if (strlen(tmp1->name) != strlen(tmp2)) {
return -1;
}
if (memcmp(tmp1->name, tmp2, strlen(tmp2)) != 0) {
return -1;
}
return 0;
}
static int32_t UserDataSort(const void *a, const void *b)
{
if (a == NULL || b == NULL) {
return -1;
}
UserData *tmp1 = *(UserData **)a;
UserData *tmp2 = *(UserData **)b;
return (tmp1->id - tmp2->id);
}
static void *UserDataCopy(const void *a)
{
if (a == NULL) {
return NULL;
}
UserData *src = (UserData *)a;
UserData *dest = (UserData *)BSL_SAL_Malloc(sizeof(UserData));
if (dest == NULL) {
return NULL;
}
(void)memset_s(dest, sizeof(UserData), 0, sizeof(UserData));
dest->id = src->id;
if (memcpy_s(dest->name, MAX_NAME_LEN, src->name, strlen(src->name)) != EOK) {
BSL_SAL_FREE(dest);
return NULL;
}
return dest;
}
/**
* @test SDV_BSL_LIST_FUNC_TC001
* @title Linked list normal capability test
* @precon nan
* @brief
* 1. Call BSL_LIST_New to create a linked list header. Expected result 1 is obtained.
* 2. Call BSL_LIST_AddElement to add data to the linked list. Expected result 2 is obtained.
* 3. Repeat step 2 twice. Expected result 2 is obtained.
* 4. Call BSL_LIST_COUNT to obtain the number of data records in the current linked list.
* Expected result 3 is obtained.
* 5. Get the number of nodes in the list after delete the current element of list. Expected result 4 is obtained.
* 6. Call BSL_LIST_Copy to copy data to the new linked list. Expected result 5 is obtained.
* @expect
* 1. success
* 2. BSL_SUCCESS
* 3. 3
* 4. 2
* 5. success
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_FUNC_TC001(void)
{
TestMemInit();
BslList *listHeader = BSL_LIST_New(sizeof(LIST_NODE));
ASSERT_TRUE(listHeader != NULL);
LIST_NODE *node1 = (LIST_NODE *)BSL_SAL_Malloc(sizeof(LIST_NODE));
ASSERT_TRUE(node1 != NULL);
node1->key = 1;
node1->value = 2;
int ret = BSL_LIST_AddElement(listHeader, node1, BSL_LIST_POS_END);
ASSERT_TRUE(ret == BSL_SUCCESS);
LIST_NODE *node2 = (LIST_NODE *)BSL_SAL_Malloc(sizeof(LIST_NODE));
ASSERT_TRUE(node2 != NULL);
node2->key = 1;
node2->value = 2;
ret = BSL_LIST_AddElement(listHeader, node2, BSL_LIST_POS_END);
ASSERT_TRUE(ret == BSL_SUCCESS);
LIST_NODE *node3 = (LIST_NODE *)BSL_SAL_Malloc(sizeof(LIST_NODE));
ASSERT_TRUE(node3 != NULL);
node3->key = 1;
node3->value = 2;
ret = BSL_LIST_AddElement(listHeader, node3, BSL_LIST_POS_END);
ASSERT_TRUE(ret == BSL_SUCCESS);
int num = BSL_LIST_COUNT(listHeader);
ASSERT_TRUE(num == 3);
BSL_LIST_DeleteCurrent(listHeader, NULL);
num = BSL_LIST_COUNT(listHeader);
ASSERT_TRUE(num == 2);
BslList *destHeader = BSL_LIST_Copy(listHeader, NULL, NULL);
ASSERT_TRUE(destHeader != NULL);
num = BSL_LIST_COUNT(destHeader);
ASSERT_TRUE(num == 2);
BSL_LIST_FREE(destHeader, NULL);
BSL_LIST_FREE(listHeader, NULL);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_FUNC_TC002
* @title SDV_BSL_LIST_FUNC_TC002
* @precon None
* @brief List maximum element test.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_FUNC_TC002(void)
{
int arr[] = {0};
BslList *list = NULL;
list = BSL_LIST_New(sizeof(int));
ASSERT_TRUE(list != NULL);
ASSERT_EQ(BSL_LIST_SetMaxElements(65535), BSL_SUCCESS);
for (int i = 0; i < 65535; i++) {
ASSERT_EQ(BSL_LIST_AddElement(list, arr, BSL_LIST_POS_AFTER), BSL_SUCCESS);
}
ASSERT_EQ(BSL_LIST_COUNT(list), 65535);
ASSERT_EQ(BSL_LIST_AddElement(list, arr, BSL_LIST_POS_AFTER), BSL_LIST_FULL);
EXIT:
BSL_LIST_FREE(list, EmptyFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_MAX_ELEMENTS_FUNC_TC001
* @title list max elements test
* @precon nan
* @brief
* 1. Call BSL_LIST_New to create the head node of the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_SetMaxElements to set the maximum number of data records stored in the linked list to 65535.
* Expected result 2 is obtained.
* 3. Add 65535 records to the linked list. Expected result 3 is obtained.
* 4. Obtain the maximum data volume supported by the current linked list. Expected result 4 is obtained.
* 5. Obtain the number of data records in the current linked list. Expected result 5 is obtained.
* 6. Add data to the linked list again. Expected result 6 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2. BSL_SUCCESS
* 3. BSL_SUCCESS
* 4. 65535
* 5. 65535
* 6. BSL_LIST_FULL
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_MAX_ELEMENTS_FUNC_TC001(void)
{
int arr[] = {0};
BslList *list = NULL;
list = BSL_LIST_New(-1);
ASSERT_TRUE(list == NULL);
list = BSL_LIST_New(sizeof(int));
ASSERT_TRUE(list != NULL);
ASSERT_EQ(BSL_LIST_SetMaxElements(65535), BSL_SUCCESS);
for (int i = 0; i < 65535; i++) {
ASSERT_EQ(BSL_LIST_AddElement(list, arr, BSL_LIST_POS_AFTER), BSL_SUCCESS);
}
ASSERT_EQ(BSL_LIST_GetMaxElements(), 65535);
ASSERT_EQ(BSL_LIST_COUNT(list), 65535);
ASSERT_EQ(BSL_LIST_AddElement(list, arr, BSL_LIST_POS_AFTER), BSL_LIST_FULL);
EXIT:
BSL_LIST_FREE(list, EmptyFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_DETACH_FUNC_TC001
* @title list detach test
* @precon nan
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_DetachCurrent to detach the current. Expected result 2 is obtained.
* 3. Call BSL_LIST_DetachNode to detach a node. Expected result 3 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2. success
* 3. success
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_DETACH_FUNC_TC001(void)
{
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
UserData data[9] = {
{1, "Alice"},
{2, "Bob"},
{3, "Celina"},
{4, "Dave"},
{5, "Emma"},
{6, "Frank"},
{7, "Grace"},
{8, "Helen"},
{9, "Iris"}
};
// Linked list IDs range from 1 to 9.
for (int i = 0; i < 9; i++) {
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[i], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
}
/*
* The curr is the last node. After the node is detached and released,
* last is the last but one node in the original linked list.
*/
BSL_LIST_DetachCurrent(testList);
ASSERT_TRUE(BSL_LIST_COUNT(testList) == 8);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_LAST(testList), &data[7]) == 0);
// Delete Dave.
BslListNode *detachNode = testList->first->next->next->next;
BSL_LIST_DetachNode(testList, &detachNode);
ASSERT_TRUE(UserDataCompare(detachNode->data, &data[4]) == 0); // Dave's position became Emma.
/* When the deleted node is the current node, the current node will be
* updated to the next node first; otherwise, it will be updated to the previous node.
*/
testList->curr = testList->last->prev;
ASSERT_TRUE(UserDataCompare(BSL_LIST_CURR_ELMT(testList), &data[6]) == 0);
ASSERT_TRUE(UserDataCompare(testList->curr->next->data, &data[7]) == 0);
BSL_LIST_DetachNode(testList, &testList->curr);
ASSERT_TRUE(UserDataCompare(BSL_LIST_CURR_ELMT(testList), &data[7]) == 0);
ASSERT_TRUE(UserDataCompare(testList->curr->prev->data, &data[5]) == 0);
BSL_LIST_DetachNode(testList, &testList->curr);
ASSERT_TRUE(UserDataCompare(BSL_LIST_CURR_ELMT(testList), &data[5]) == 0);
EXIT:
BSL_LIST_FREE(testList, UserDataFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_SEARCH_FUNC_TC001
* @title list search test
* @precon nan
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_Search to search for specified data. Expected result 2 is obtained.
* 3. Call BSL_LIST_Search to search for specified data. Expected result 3 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2. Data search succeeded.
* 3. Data search succeeded.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_SEARCH_FUNC_TC001(void)
{
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
UserData data[5] = {
{1, "Alice"},
{2, "Bob"},
{3, "Celina"},
{4, "Dave"},
{5, "Emma"}
};
// The sequence of linked list IDs is 1 - 2 - 3 - 4 - 5.
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[2], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[1], BSL_LIST_POS_BEFORE) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[0], BSL_LIST_POS_BEGIN) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[4], BSL_LIST_POS_END) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[3], BSL_LIST_POS_BEFORE) == BSL_SUCCESS);
int errNum = 0;
UserData *tmp1 = BSL_LIST_Search(testList, "Celina", UserDataCompareByName, NULL);
ASSERT_TRUE(UserDataCompare(tmp1, &data[2]) == 0);
UserData *tmp2 = BSL_LIST_Search(testList, "Dave", UserDataCompareByName, &errNum);
ASSERT_TRUE(UserDataCompare(tmp2, &data[3]) == 0);
EXIT:
BSL_LIST_FREE(testList, UserDataFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_GET_NODE_FUNC_TC001
* @title list GET NODE interface testing
* @precon nan
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_FirstNode to get the first node in the linked list. Expected result 2 is obtained.
* 3. Call BSL_LIST_GetData to get data from the node. Expected result 3 is obtained.
* 4. Call BSL_LIST_GetNextNode to get the next node. Expected result 4 is obtained.
* 5. Call BSL_LIST_GetData to get data from the node. Expected result 5 is obtained.
* 6. Call BSL_LIST_GetNextNode to get the next node. Expected result 6 is obtained.
* 7. Call BSL_LIST_GetData to get data from the node. Expected result 7 is obtained.
* 8. Call BSL_LIST_GetNextNode to get the prev node. Expected result 8 is obtained.
* 9. Call BSL_LIST_GetData to get data from the node. Expected result 9 is obtained.
* 10. Call BSL_LIST_Curr to get the current element in the list. Expected result 10 is obtained.
* 11. Call BSL_LIST_GetIndexNode to get the node at the given index in the list.
* Expected result 11 is obtained.
* 12. Call BSL_LIST_Curr to get the current element in the list. Expected result 12 is obtained.
* @expect
* 1. Data added successfully. return BSL_SUCCESS.
* 2. The first node is obtained successfully.
* 3. Succeeded in obtaining data from the node, which is the same as the original data.
* 4. The next node is obtained successfully.
* 5. Succeeded in obtaining data from the node, which is the same as the original data.
* 6. The next node is obtained successfully.
* 7. Succeeded in obtaining data from the node, which is the same as the original data.
* 8. The prev node is obtained successfully.
* 9. Succeeded in obtaining data from the node, which is the same as the original data.
* 10. The current node is obtained successfully, which is the same as the original data.
* 11. The index node is obtained successfully, which is the same as the original data.
* 12. The current node is obtained successfully, which is the same as the original data.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_GET_NODE_FUNC_TC001(void)
{
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
UserData data[5] = {
{1, "Alice"},
{2, "Bob"},
{3, "Celina"},
{4, "Dave"},
{5, "Emma"}
};
for (int i = 0; i < 5; i++) {
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[i], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
}
BslListNode *tmp = BSL_LIST_FirstNode(NULL);
ASSERT_TRUE(tmp == NULL);
tmp = BSL_LIST_FirstNode(testList);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GetData(tmp), &data[0]) == 0);
tmp = BSL_LIST_GetNextNode(NULL, (const BslListNode *)BSL_LIST_FirstNode(testList));
ASSERT_TRUE(tmp == NULL);
tmp = BSL_LIST_GetNextNode(testList, (const BslListNode *)BSL_LIST_FirstNode(testList));
ASSERT_TRUE(UserDataCompare(BSL_LIST_GetData(tmp), &data[1]) == 0);
tmp = BSL_LIST_GetNextNode(testList, (const BslListNode *)tmp);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GetData(tmp), &data[2]) == 0);
tmp = BSL_LIST_GetPrevNode(tmp);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GetData(tmp), &data[1]) == 0);
// curr points to 4.
UserData *curTmp = *(UserData **)BSL_LIST_Curr(testList);
ASSERT_TRUE(UserDataCompare(curTmp, &data[4]) == 0);
// The subscript of the list starts from 0.
UserData *getTmp = BSL_LIST_GetIndexNode(3, testList);
ASSERT_TRUE(UserDataCompare(&data[3], getTmp) == 0);
// BSL_LIST_GetIndexNode changes the curr point to 3.
curTmp = *(UserData **)BSL_LIST_Curr(testList);
ASSERT_TRUE(UserDataCompare(curTmp, &data[3]) == 0);
EXIT:
BSL_LIST_FREE(testList, UserDataFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_COPY_FUNC_TC001
* @title list Copy test
* @precon nan
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_Copy to copy the linked list to the new linked list
* and check whether the data in the two linked lists is the same. Expected result 2 is obtained.
* @expect
* 1. Data added successfully. return BSL_SUCCESS.
* 2. The data in the two linked lists is the same.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_COPY_FUNC_TC001(void)
{
BslList *srcList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(srcList != NULL);
UserData data[3] = { {1, "Alice"}, {2, "Bob"}, {3, "Celina"} };
for (int i = 0; i < 3; i++) {
ASSERT_TRUE(BSL_LIST_AddElement(srcList, &data[i], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
}
BslList *destList = BSL_LIST_Copy(srcList, UserDataCopy, UserDataFree);
UserData *srcTmp = BSL_LIST_GET_FIRST(srcList);
UserData *destTmp = BSL_LIST_GET_FIRST(destList);
ASSERT_TRUE(UserDataCompare((const void *)srcTmp, (const void *)destTmp) == 0);
srcTmp = BSL_LIST_GET_LAST(srcList);
destTmp = BSL_LIST_GET_LAST(destList);
ASSERT_TRUE(UserDataCompare((const void *)srcTmp, (const void *)destTmp) == 0);
ASSERT_TRUE(UserDataCompare(destList->first->next->data, srcList->first->next->data) == 0);
EXIT:
BSL_LIST_FREE(destList, NULL);
BSL_LIST_FREE(srcList, UserDataFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_SORT_FUNC_TC001
* @title list sort test
* @precon nan
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_Sort to sort the linked list and view the sorting result. Expected result 2 is obtained.
* @expect
* 1. Data added successfully. return BSL_SUCCESS.
* 2. Linked list sorting succeeded.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_SORT_FUNC_TC001(void)
{
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
UserData data[6] = { {3, "Celina"}, {2, "Bob"}, {1, "Alice"}, {6, "Frank"}, {4, "Dave"}, {5, "Emma"} };
for (int i = 0; i < 6; i++) {
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[i], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
}
BSL_LIST_Sort(testList, UserDataSort);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_FIRST(testList), &data[2]) == 0);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_LAST(testList), &data[3]) == 0);
ASSERT_TRUE(UserDataCompare(testList->first->next->next->next->data, &data[4]) == 0);
EXIT:
BSL_LIST_FREE(testList, UserDataFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_SORT_FUNC_TC002
* @title list sort test
* @precon nan
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_GetMaxQsortCount to get max qsort count. Expected result 2 is obtained.
* 3. Call BSL_LIST_SetMaxQsortCount to set max qsort count. Expected result 3 is obtained.
* 4. Call BSL_LIST_GetMaxQsortCount to get max qsort count. Expected result 4 is obtained.
* 5. Call BSL_LIST_Sort to sort the linked list and view the sorting result. Expected result 5 is obtained.
* @expect
* 1. Data added successfully. return BSL_SUCCESS.
* 2. The obtained count is the same as the default count.
* 3. Succeeded in setting the max qsort count.
* 4. The obtained count is the same as the count.
* 5. Linked list sorting succeeded.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_SORT_FUNC_TC002(void)
{
int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
BslList *list1 = NULL;
list1 = BSL_LIST_New(sizeof(int));
ASSERT_TRUE(list1 != NULL);
ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 4, BSL_LIST_POS_AFTER), BSL_SUCCESS);
ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 3, BSL_LIST_POS_AFTER), BSL_SUCCESS);
ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 2, BSL_LIST_POS_AFTER), BSL_SUCCESS);
ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 1, BSL_LIST_POS_AFTER), BSL_SUCCESS);
ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 7, BSL_LIST_POS_AFTER), BSL_SUCCESS);
ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 5, BSL_LIST_POS_AFTER), BSL_SUCCESS);
ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 8, BSL_LIST_POS_AFTER), BSL_SUCCESS);
ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 6, BSL_LIST_POS_AFTER), BSL_SUCCESS);
ASSERT_EQ(BSL_LIST_GetMaxQsortCount(), 100000);
ASSERT_EQ(BSL_LIST_SetMaxQsortCount(67108865), BSL_INVALID_ARG);
ASSERT_EQ(BSL_LIST_SetMaxQsortCount(10000), BSL_SUCCESS);
ASSERT_EQ(BSL_LIST_GetMaxQsortCount(), 10000);
list1 = BSL_LIST_Sort(list1, Compare);
ASSERT_TRUE(list1 != NULL);
int *p = BSL_LIST_GET_FIRST(list1);
ASSERT_TRUE(p != NULL && *p == 1);
p = BSL_LIST_GET_NEXT(list1);
ASSERT_TRUE(p != NULL && *p == 2);
p = BSL_LIST_GET_NEXT(list1);
ASSERT_TRUE(p != NULL && *p == 3);
p = BSL_LIST_GET_NEXT(list1);
ASSERT_TRUE(p != NULL && *p == 4);
p = BSL_LIST_GET_NEXT(list1);
ASSERT_TRUE(p != NULL && *p == 5);
p = BSL_LIST_GET_NEXT(list1);
ASSERT_TRUE(p != NULL && *p == 6);
p = BSL_LIST_GET_NEXT(list1);
ASSERT_TRUE(p != NULL && *p == 7);
p = BSL_LIST_GET_NEXT(list1);
ASSERT_TRUE(p != NULL && *p == 8);
EXIT:
BSL_LIST_FREE(list1, EmptyFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_ADD_GET_FUNC_TC001
* @title The list add and GET* interfaces testing.
* @precon nan
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_CURR_ELMT. Expected result 2 is obtained.
* 3. Call BSL_LIST_NEXT_ELMT. Expected result 3 is obtained.
* 4. Call BSL_LIST_PREV_ELMT. Expected result 4 is obtained.
* 5. Call BSL_LIST_LAST_ELMT. Expected result 5 is obtained.
* 6. Call BSL_LIST_FIRST_ELMT. Expected result 6 is obtained.
* 7. Call BSL_LIST_GET_FIRST. Expected result 7 is obtained.
* 8. Call BSL_LIST_GET_LAST. Expected result 8 is obtained.
* 9. Call BSL_LIST_GET_CURRENT. Expected result 9 is obtained.
* 10. Call BSL_LIST_GET_NEXT. Expected result 10 is obtained.
* 11. Call BSL_LIST_GET_PREV. Expected result 11 is obtained.
* 12. Call BSL_LIST_GetIndexNode. Expected result 12 is obtained.
* 13. Call BSL_LIST_GetElmtIndex. Expected result 13 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2~13. SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_ADD_GET_FUNC_TC001(void)
{
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
ASSERT_TRUE(BSL_LIST_COUNT(testList) == 0);
UserData data[4] = {
{1, "bsl_list_001"},
{2, "bsl_list_002"},
{3, "bsl_list_003"},
{4, "bsl_list_004"},
};
// The sequence of linked list IDs is 3 - 2 - 1 - 4.
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[0], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[1], BSL_LIST_POS_BEFORE) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[2], BSL_LIST_POS_BEGIN) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[3], BSL_LIST_POS_END) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_COUNT(testList) == 4);
// Obtaining the macro of a node does not change the value of curr.
ASSERT_TRUE(UserDataCompare(BSL_LIST_CURR_ELMT(testList), &data[3]) == 0);
ASSERT_TRUE(BSL_LIST_NEXT_ELMT(testList) == NULL);
ASSERT_TRUE(UserDataCompare(BSL_LIST_PREV_ELMT(testList), &data[0]) == 0);
ASSERT_TRUE(UserDataCompare(BSL_LIST_LAST_ELMT(testList), &data[3]) == 0);
ASSERT_TRUE(UserDataCompare(BSL_LIST_FIRST_ELMT(testList), &data[2]) == 0);
// Note that the Get function changes the value of curr.
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_FIRST(testList), &data[2]) == 0);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_LAST(testList), &data[3]) == 0);
UserData *curTmp = *(UserData **)BSL_LIST_Curr(testList);
ASSERT_TRUE(UserDataCompare(curTmp, &data[3]) == 0);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_PREV(testList), &data[0]) == 0);
// Therefore, this is the next of curr->prev.
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_NEXT(testList), &data[3]) == 0);
// The curr points to 3
curTmp = *(UserData **)BSL_LIST_Curr(testList);
ASSERT_TRUE(UserDataCompare(curTmp, &data[3]) == 0);
// The subscript of the list starts from 0.
UserData *tmp = BSL_LIST_GetIndexNode(2, testList);
ASSERT_TRUE(UserDataCompare(&data[0], tmp) == 0);
// BSL_LIST_GetIndexNode changes curr to 2.
curTmp = *(UserData **)BSL_LIST_Curr(testList);
ASSERT_TRUE(UserDataCompare(curTmp, &data[0]) == 0);
ASSERT_TRUE(BSL_LIST_GetElmtIndex(&data[1], testList) == 1);
EXIT:
BSL_LIST_FREE(testList, UserDataFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_CONCAT_FUNC_TC001
* @title list concat test
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_Concat to combine two linked lists and compare whether the data in the linked lists is correct.
* Expected result 2 is obtained.
* @expect
* 1. Data added successfully. return BSL_SUCCESS.
* 2. Linked list combination succeeded.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_CONCAT_FUNC_TC001(void)
{
BslList *destList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(destList != NULL);
BslList *srcList1 = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(srcList1 != NULL);
BslList *srcList2 = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(srcList2 != NULL);
UserData data[6] = { {1, "Alice"}, {2, "Bob"}, {3, "Celina"}, {4, "Dave"}, {5, "Emma"}, {6, "Frank"} };
for (int i = 0; i < 3; i++) {
ASSERT_TRUE(BSL_LIST_AddElement(srcList1, &data[i], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
}
for (int i = 3; i < 6; i++) {
ASSERT_TRUE(BSL_LIST_AddElement(srcList2, &data[i], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
}
// Add to an empty linked list
destList = BSL_LIST_Concat(destList, srcList1);
// Add to non-empty linked list
destList = BSL_LIST_Concat(destList, srcList2);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_FIRST(destList), &data[0]) == 0);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_LAST(destList), &data[5]) == 0);
ASSERT_TRUE(UserDataCompare(destList->first->next->next->next->data, &data[3]) == 0);
EXIT:
BSL_LIST_FREE(destList, UserDataFree);
BSL_SAL_FREE(srcList1);
BSL_SAL_FREE(srcList2); // The nodes are free, so just use the free linked list itself.
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_REVERSE_FUNC_TC001
* @title list reverse test
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_RevList to reverse the linked list. Expected result 2 is obtained.
* @expect
* 1. Data added successfully. return BSL_SUCCESS.
* 2. Succeeded in reversing the linked list.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_REVERSE_FUNC_TC001(void)
{
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
UserData data[3] = { {1, "Alice"}, {2, "Bob"}, {3, "Celina"} };
for (int i = 0; i < 3; i++) {
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[i], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
}
BSL_LIST_RevList(testList);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_FIRST(testList), &data[2]) == 0);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_LAST(testList), &data[0]) == 0);
EXIT:
BSL_LIST_FREE(testList, UserDataFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_DETELE_NODE_FUNC_TC001
* @title list delete test
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_FirstNode to get the first node in the linked list. Expected result 2 is obtained.
* 3. Call BSL_LIST_DeleteNode to delete the first node. Expected result 3 is obtained.
* 4. Call BSL_LIST_DeleteAll to delete all node. Expected result 4 is obtained.
* @expect
* 1. Data added successfully. return BSL_SUCCESS.
* 2. Succeeded in reversing the linked list.
* 3. The deletion is successful, and the number of nodes decreases by 1.
* 4. The deletion is successful. The number of nodes is 0.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_DELETE_NODE_FUNC_TC001(void)
{
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
UserData data[3] = { {1, "Alice"}, {2, "Bob"}, {3, "Celina"} };
UserData *data1 = BSL_SAL_Malloc(sizeof(UserData) * 3);
ASSERT_TRUE(data1 != NULL);
memcpy_s(data1, sizeof(UserData) * 3, data, sizeof(UserData) *3);
for (int i = 0; i < 3; i++) {
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data1[i], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
}
BslListNode *tmp = BSL_LIST_FirstNode(testList);
BSL_LIST_DeleteNode(testList, tmp, UserDataFree);
ASSERT_TRUE(BSL_LIST_COUNT(testList) == 2);
BSL_LIST_DeleteAll(testList, UserDataFree);
ASSERT_TRUE(BSL_LIST_COUNT(testList) == 0);
EXIT:
free(data1);
BSL_LIST_FREE(testList, UserDataFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_DETELE_NODE_FUNC_TC002
* @title list delete test
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_DeleteAllAfterSort to delete all node. Expected result 2 is obtained.
* @expect
* 1. Data added successfully. return BSL_SUCCESS.
* 2. The deletion is successful. The number of nodes is 0.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_DELETE_NODE_FUNC_TC002(void)
{
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
UserData data[3] = { {1, "Alice"}, {2, "Bob"}, {3, "Celina"} };
UserData *data1 = BSL_SAL_Malloc(sizeof(UserData) * 3);
ASSERT_TRUE(data1 != NULL);
memcpy_s(data1, sizeof(UserData) * 3, data, sizeof(UserData) *3);
for (int i = 0; i < 3; i++) {
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data1[i], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
}
BSL_LIST_DeleteAllAfterSort(testList);
ASSERT_TRUE(BSL_LIST_COUNT(testList) == 0);
EXIT:
free(data1);
BSL_LIST_FREE(testList, UserDataFree);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_LIST_API_TC001
* @title list previous node test
* @brief
* 1. Check if previous element is NULL. Expected result 1 is obtained.
* 2. Call BSL_LIST_AddElement to add data to the linked list. Expected result 2 is obtained.
* 3. Check if previous element is NULL. Expected result 3 is obtained.
* @expect
* 1. The previous node is NULL.
* 2. Data added successfully. return BSL_SUCCESS.
* 3. The previous node is not NULL.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_LIST_Pre_API_TC001()
{
int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
/* when list is NULL */
int **prv = BSL_LIST_Prev(NULL);
ASSERT_EQ(prv, NULL);
/* pstList->curr == NULL */
BslList *list = BSL_LIST_New(sizeof(int));
ASSERT_TRUE(list != NULL);
prv = BSL_LIST_Prev(list);
ASSERT_EQ(prv, NULL);
/* pstList->curr != NULL, pstList->curr->prev == NULL */
ASSERT_EQ(BSL_LIST_AddElement(list, arr + 0, BSL_LIST_POS_AFTER), BSL_SUCCESS);
prv = BSL_LIST_Prev(list);
ASSERT_EQ(prv, NULL);
/* pstList->curr != NULL, pstList->curr->prev != NULL */
ASSERT_EQ(BSL_LIST_AddElement(list, arr + 1, BSL_LIST_POS_AFTER), BSL_SUCCESS);
prv = BSL_LIST_Prev(list);
ASSERT_TRUE(prv != NULL && **prv == 0);
/* pstList->curr == NULL, pstList->last != NULL */
prv = BSL_LIST_Prev(list);
ASSERT_EQ(prv, NULL);
prv = BSL_LIST_Prev(list);
ASSERT_TRUE(prv != NULL && **prv == 1);
EXIT:
BSL_LIST_FREE(list, EmptyFree);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_LIST_Next_API_TC002
* @title list next node test
* @brief
* 1. Check if next node is NULL. Expected result 1 is obtained.
* 2. Call BSL_LIST_AddElement to add data to the linked list. Expected result 2 is obtained.
* 3. Check if next node is NULL. Expected result 3 is obtained.
* @expect
* 1. The next node is NULL.
* 2. Data added successfully. return BSL_SUCCESS.
* 3. The next node is not NULL.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_LIST_Next_API_TC002()
{
int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
/* when list is NULL */
int **next = BSL_LIST_Prev(NULL);
ASSERT_EQ(next, NULL);
/* pstList->curr == NULL */
BslList *list = BSL_LIST_New(sizeof(int));
ASSERT_TRUE(list != NULL);
next = BSL_LIST_Next(list);
ASSERT_EQ(next, NULL);
/* pstList->curr != NULL, pstList->curr->next == NULL */
ASSERT_EQ(BSL_LIST_AddElement(list, arr + 0, BSL_LIST_POS_BEFORE), BSL_SUCCESS);
next = BSL_LIST_Next(list);
ASSERT_EQ(next, NULL);
/* pstList->curr != NULL, pstList->curr->next != NULL */
ASSERT_EQ(BSL_LIST_AddElement(list, arr + 1, BSL_LIST_POS_BEFORE), BSL_SUCCESS);
next = BSL_LIST_Next(list);
ASSERT_TRUE(next != NULL && **next == 0);
/* pstList->curr == NULL, pstList->first != NULL */
next = BSL_LIST_Next(list);
ASSERT_EQ(next, NULL);
next = BSL_LIST_Next(list);
ASSERT_TRUE(next != NULL && **next == 1);
EXIT:
BSL_LIST_FREE(list, EmptyFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_SET_MAX_FUNC_TC001
* @title list is* Interface test
* @brief 1. BSL_LIST_SetMaxQsortCount
2. BSL_LIST_GetMaxQsortCount
3. BSL_LIST_SetMaxElements
4. BSL_LIST_GetMaxElements
* @expect 1. BSL_SUCCESS
2. g_maxQsortElem = 100001
3. BSL_SUCCESS
4. g_maxListCount = 65536
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_SET_MAX_FUNC_TC001(void)
{
ASSERT_TRUE(BSL_LIST_SetMaxQsortCount(100001) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_GetMaxQsortCount() == 100001);
ASSERT_TRUE(BSL_LIST_SetMaxElements((1 << 16)) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_GetMaxElements() == (1 << 16));
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_INVALID_INPUT_FUNC_TC001
* @title list invalid or empty input parameter value test
* @brief 0. BSL_LIST_AddElement
1. BSL_LIST_AddElement
2. BSL_LIST_Search
3. BSL_LIST_Concat
4. BSL_LIST_Sort
5. BSL_LIST_Copy
6. BSL_LIST_Copy
7. BSL_LIST_GetData
8. BSL_LIST_FirstNode
9. BSL_LIST_GetNextNode
10. BSL_LIST_GetPrevNode
11. BSL_LIST_SetMaxQsortCount
12. BSL_LIST_SetMaxElements
* @expect 0. BSL_INVALID_ARG
1. BSL_LIST_DATA_NOT_AVAILABLE
2. NULL
3. NULL
4. NULL
5. NULL
6. NULL
7. NULL
8. NULL
9. NULL
10. BSL_LIST_GetPrevNode
11. BSL_INVALID_ARG
12. BSL_INVALID_ARG
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_INVALID_INPUT_FUNC_TC001(void)
{
ASSERT_TRUE(BSL_LIST_AddElement(NULL, NULL, BSL_LIST_POS_BEFORE) == BSL_INVALID_ARG);
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
ASSERT_TRUE(BSL_LIST_AddElement(testList, NULL, BSL_LIST_POS_BEFORE) == BSL_LIST_DATA_NOT_AVAILABLE);
ASSERT_TRUE(BSL_LIST_Search(NULL, NULL, UserDataCompare, NULL) == NULL);
ASSERT_TRUE(BSL_LIST_Concat(NULL, NULL) == NULL);
ASSERT_TRUE(BSL_LIST_Sort(NULL, NULL) == NULL);
ASSERT_TRUE(BSL_LIST_Copy(NULL, UserDataCopy, UserDataFree) == NULL);
ASSERT_TRUE(BSL_LIST_Copy(testList, UserDataCopy, UserDataFree) == NULL);
ASSERT_TRUE(BSL_LIST_GetData(NULL) == NULL);
ASSERT_TRUE(BSL_LIST_FirstNode(NULL) == NULL);
ASSERT_TRUE(BSL_LIST_GetNextNode(NULL, NULL) == NULL);
ASSERT_TRUE(BSL_LIST_GetPrevNode(NULL) == NULL);
ASSERT_TRUE(BSL_LIST_SearchEx(NULL, NULL, NULL) == NULL);
ASSERT_TRUE(BSL_LIST_GetIndexNodeEx(0, NULL, NULL) == NULL);
ASSERT_TRUE(BSL_LIST_SetMaxQsortCount(10) == BSL_INVALID_ARG);
ASSERT_TRUE(BSL_LIST_SetMaxElements(10) == BSL_INVALID_ARG);
EXIT:
BSL_SAL_FREE(testList);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_DELETE_FUNC_TC001
* @title test the function of deleting a node.
* @brief
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_DELETE_FUNC_TC001(void)
{
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
ASSERT_TRUE(BSL_LIST_AddElement(testList, "aaaa", BSL_LIST_POS_BEFORE) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_AddElement(testList, "bbbb", BSL_LIST_POS_BEFORE) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_COUNT(testList) == 2);
BslListNode *tmpNode = NULL;
for (BslListNode *node = BSL_LIST_FirstNode(testList); node != NULL;) {
tmpNode = node;
char *name = BSL_LIST_GetData(tmpNode);
if (name == NULL) {
continue;
}
node = BSL_LIST_GetNextNode(testList, tmpNode);
if (strcmp(name, "aaaa") == 0) {
BSL_LIST_DeleteNode(testList, (const BslListNode *)tmpNode, UserDataFree);
continue;
}
if (strcmp(name, "bbbb") == 0) {
BSL_LIST_DeleteNode(testList, (const BslListNode *)tmpNode, UserDataFree);
continue;
}
}
ASSERT_TRUE(BSL_LIST_COUNT(testList) == 0);
ASSERT_TRUE(BSL_LIST_AddElement(testList, "cccc", BSL_LIST_POS_BEFORE) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_COUNT(testList) == 1);
BSL_LIST_DeleteCurrent(testList, UserDataFree);
EXIT:
BSL_SAL_FREE(testList);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_FREE_WITHOUT_FUNC_TC001
* @title test BSL_LIST_FreeWithoutData functions
* @precon nan
* @brief
* 1.Call BSL_LIST_New create a list, Expected result 1 is obtained.
* 2.Call BSL_LIST_FreeWithoutData free normal list, Expected result 2 is obtained.
* 3.Call BSL_LIST_FreeWithoutData free empty list, Expected result 2 is obtained.
* @expect
* 1. The list is created successfully.
* 2. The list is free successfully.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_FREE_WITHOUT_FUNC_TC001(void)
{
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
BSL_LIST_FreeWithoutData(testList);
testList = NULL;
EXIT:
BSL_LIST_FreeWithoutData(testList);
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/bsl/list/test_suite_sdv_list.c | C | unknown | 37,411 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include "bsl_sal.h"
#include "bsl_errno.h"
#include "bsl_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
static uintptr_t g_binlogFlag = 0;
// Binlog fixed-length callback
static void BinLogFix(uint32_t logId, uint32_t logLevel, uint32_t logType,
void *format, void *para1, void *para2, void *para3, void *para4)
{
(void)logId;
(void)logLevel;
(void)logType;
(void)format;
(void)para2;
(void)para3;
(void)para4;
g_binlogFlag = (uintptr_t)para1;
}
// Binlog variable-length callback
static void BinLogVar(uint32_t logId, uint32_t logLevel, uint32_t logType, void *format, void *para)
{
(void)logId;
(void)logLevel;
(void)logType;
(void)format;
g_binlogFlag = (uintptr_t)para;
}
void BinLogFixLenFunc(uint32_t logId, uint32_t logLevel, uint32_t logType,
void *format, void *para1, void *para2, void *para3, void *para4)
{
(void)logId;
(void)logLevel;
(void)logType;
(void)format;
(void)para1;
(void)para2;
(void)para3;
(void)para4;
}
void BinLogVarLenFunc(uint32_t logId, uint32_t logLevel, uint32_t logType,
void *format, void *para)
{
(void)logId;
(void)logLevel;
(void)logType;
(void)format;
(void)para;
}
static FILE *g_LogOutput = NULL;
// Binlog fixed-length callback, output to a file
static void BinLogFixFunc(uint32_t logId, uint32_t logLevel, uint32_t logType,
void *format, void *para1, void *para2, void *para3, void *para4)
{
uint8_t *pucFormat = (uint8_t *)format;
uint8_t ucTemp;
uint8_t ucNo = 0;
fprintf(g_LogOutput, "HITLS_BIN_LOG[FIXLEN]: logId=%u, logLevel=%u, logType=%u.\n", logId, logLevel, logType);
/* Search for all format specifiers */
while (*pucFormat != '\0') {
if (*pucFormat == '%') {
/* Get the second character */
ucTemp = *(pucFormat + 1);
if ((ucTemp == 'd') || (ucTemp == 'l') || (ucTemp == 'p') || (ucTemp == 'u') || (ucTemp == 'x')) {
ucNo++;
}
}
pucFormat++;
}
switch(ucNo) {
case 0: // Pure character strings are not output.
break;
case 1: // Output parameters only
fprintf(g_LogOutput, "0x%lX\n", (uint64_t)para1);
break;
case 2: // Output parameters only
fprintf(g_LogOutput, "0x%lX 0x%lX\n", (uint64_t)para1, (uint64_t)para2);
break;
case 3: // Output parameters only
fprintf(g_LogOutput, "0x%lX 0x%lX 0x%lX\n", (uint64_t)para1, (uint64_t)para2, (uint64_t)para3);
break;
case 4: // Output parameters only
fprintf(g_LogOutput, "0x%lX 0x%lX 0x%lX 0x%lX\n", (uint64_t)para1, (uint64_t)para2, (uint64_t)para3,
(uint64_t)para4);
break;
default: // The number of parameters is incorrect.
fprintf(g_LogOutput, "Invalid Number of Format Specifiers in LOG\n");
return;
}
}
// Binlog variable-length callback, output to a file
static void BinLogVarFunc(uint32_t logId, uint32_t logLevel, uint32_t logType, void *format, void *para)
{
uint8_t *pucFormat = (uint8_t *)format;
uint8_t ucTemp;
uint8_t ucValidNo = 0;
fprintf(g_LogOutput, "HITLS_BIN_LOG[VARLEN]: logId=%u, logLevel=%u, logType=%u.\n", logId, logLevel, logType);
while (*pucFormat != '\0') {
if (*pucFormat == '%') {
/* Get the second character */
ucTemp = *(pucFormat + 1);
if (ucTemp == 's') { // Only the %s parameter can be contained.
ucValidNo++;
}
}
pucFormat++;
}
if (ucValidNo != 1) {
fprintf(g_LogOutput, "Invalid Number of %%s present in Var Len LOG\n");
}
fprintf(g_LogOutput, "%s\n", (const char *)para);
}
/* END_HEADER */
/**
* @test SDV_BSL_LOG_VERSION_API_TC001
* @title Obtaining the HiTLS version number of the log submodule of the BSL module
* @precon nan
* @brief
* 1. The buffer of the received version string is empty
* or the buffer length of the received version string is empty. Expected result 1 is obtained.
* 2. The buffer length of the received version string is less than the minimum length.
* Expected result 2 is obtained.
* 3. Received version and length of memory application. Expected result 3 is obtained.
* @expect
* 1. Return BSL_LOG_ERR_BAD_PARAM
* 2. Return BSL_LOG_ERR_BAD_PARAM
* 3. Succeeded. The version length is equal to the current version length,
* and the version string content is equal to the current version string content.
*/
/* BEGIN_CASE */
void SDV_BSL_LOG_VERSION_API_TC001(void)
{
char version[200];
uint32_t versionLen = 100;
ASSERT_TRUE(BSL_LOG_GetVersion(NULL, NULL) == BSL_LOG_ERR_BAD_PARAM);
ASSERT_TRUE(BSL_LOG_GetVersion((char *)version, &versionLen) == BSL_LOG_ERR_BAD_PARAM);
versionLen = 200;
ASSERT_TRUE(BSL_LOG_GetVersion((char *)version, &versionLen) == BSL_SUCCESS);
ASSERT_TRUE(versionLen == strlen("openHiTLS 0.2.0 15 May 2025"));
ASSERT_TRUE(memcmp(version, "openHiTLS 0.2.0 15 May 2025", versionLen) == 0);
uint64_t versionNum = BSL_LOG_GetVersionNum();
ASSERT_EQ(versionNum, 0x00200000ULL);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_REG_BIN_LOG_FUNC_TC001
* @title Setting the Log Callback Hook
* @precon nan
* @brief
* 1. Call the BSL_LOG_RegBinLogFunc interface and leave the input parameter empty. Expected result 1 is obtained.
* 2. Call BSL_LOG_RegBinLogFunc. If funcs is not empty, fixLenFunc is empty,
* and varLenFunc is empty, expected result 2 is obtained.
* 3. Call BSL_LOG_RegBinLogFunc. If funcs is not empty, fixLenFunc is empty,
* and varLenFunc is not empty, expected result 3 is obtained.
* 4. Call BSL_LOG_RegBinLogFunc. If funcs, fixLenFunc, and varLenFunc are not empty, expected result 4 is obtained.
* 5. Call BSL_LOG_RegBinLogFunc. Ensure that funcs and fixLenFunc are not empty,
* and varLenFunc are empty. Expected result 5 is obtained.
* 6. Call BSL_LOG_RegBinLogFunc repeatedly. If funcs, fixLenFunc, and varLenFunc are not empty.
* Expected result 6 is obtained.
* @expect
* 1.BSL_NULL_INPUT
* 2.BSL_NULL_INPUT
* 3.BSL_NULL_INPUT
* 4.BSL_SUCCESS
* 5.BSL_NULL_INPUT
* 6.BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_REG_BIN_LOG_FUNC_TC001(void)
{
TestMemInit();
BSL_LOG_BinLogFuncs func = {0};
ASSERT_TRUE(BSL_LOG_RegBinLogFunc(NULL) == BSL_NULL_INPUT);
func.fixLenFunc = NULL;
func.varLenFunc = NULL;
ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_NULL_INPUT);
func.fixLenFunc = NULL;
func.varLenFunc = BinLogVarLenFunc;
ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_NULL_INPUT);
func.fixLenFunc = BinLogFixLenFunc;
func.varLenFunc = BinLogVarLenFunc;
ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_SUCCESS);
func.fixLenFunc = BinLogFixLenFunc;
func.varLenFunc = NULL;
ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_NULL_INPUT);
func.fixLenFunc = BinLogFixLenFunc;
func.varLenFunc = BinLogVarLenFunc;
ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_SUCCESS);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_BIN_LOG_API_TC001
* @title Testing the Log Recording of the Log Submodule of the BSL Module
* @precon
* @brief
* 1. Setting an invalid dotting log level. Expected result 1 is obtained.
* 2. Set a valid dotting log level and obtain the dotting log level. Expected result 2 is obtained.
* 3. Set the parameter of the dotting log callback function to NULL. Expected result 3 is obtained.
* 4. The parameter and member of the callback function for setting dotting logs are not NULL.
* Expected result 4 is obtained.
* 5. The parameter of the callback function for setting dotting logs is not NULL.
* The callback function for four parameters is not NULL, and the callback function for one parameter is NULL.
* Expected result 5 is obtained.
* 6. The parameter of the callback function for setting dotting logs is not NULL.
* The value 1 of the callback function is not NULL. The value 4 of the callback function is NULL.
* Expected result 6 is obtained.
* 7. The parameter and member of the callback function for setting dotting logs are not NULL.
* Expected result 7 is obtained.
* 8. Overwrite the callback function for setting dotting logs. Expected result 8 is obtained.
* 9. Invoke the 4 parameter dotting to filter logs by log level. Expected result 9 is obtained.
* 10. Invoke the 4 parameter dotting, and the log level is not filtered. Expected result 10 is obtained.
* 11. Invoke variable parameter dotting and log level filtering. Expected result 11 is obtained.
* 12. Invoke variable parameter dotting, and log level filtering is not performed. Expected result 12 is obtained.
* @expect
* 1. BSL_LOG_ERR_BAD_PARAM
* 2. BSL_LOG_LEVEL_ERR
* 3. BSL_LOG_LEVEL_ERR
* 4. BSL_LOG_ERR_BAD_PARAM
* 5. BSL_LOG_LEVEL_ERR
* 6. BSL_NULL_INPUT
* 7. BSL_SUCCESS
* 8. BSL_SUCCESS
* 9. The global return value is not modified.
* 10. The global return value is changed to para1.
* 11. The global return value is not modified.
* 12. The global return value is changed to para.
*/
/* BEGIN_CASE */
void SDV_BSL_BIN_LOG_API_TC001(void)
{
int32_t ret;
int32_t retlevel;
ret = BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_DEBUG + 1);
ASSERT_TRUE(ret != BSL_SUCCESS);
/*
* The get loglevel command is used to obtain the default value
* when the loglevel command fails to be set for the first time.
*/
retlevel = BSL_LOG_GetBinLogLevel();
ASSERT_TRUE(retlevel == BSL_LOG_LEVEL_ERR);
ret = BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_ERR);
ASSERT_TRUE(ret == BSL_SUCCESS);
// The BSL_LOG_GetBinLogLevel function is replaced.
retlevel = BSL_LOG_GetBinLogLevel();
ASSERT_TRUE(retlevel == BSL_LOG_LEVEL_ERR);
// If the set loglevel operation fails, get loglevel to obtain the original value.
ret = BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_DEBUG + 1);
ASSERT_TRUE(ret != BSL_SUCCESS);
retlevel = BSL_LOG_GetBinLogLevel();
ASSERT_TRUE(retlevel == BSL_LOG_LEVEL_ERR);
ret = BSL_LOG_RegBinLogFunc(NULL);
ASSERT_TRUE(ret != BSL_SUCCESS);
BSL_LOG_BinLogFuncs funcs = {NULL, NULL};
ret = BSL_LOG_RegBinLogFunc(&funcs);
ASSERT_TRUE(ret != BSL_SUCCESS);
funcs.fixLenFunc = BinLogFix;
funcs.varLenFunc = NULL;
ret = BSL_LOG_RegBinLogFunc(&funcs);
ASSERT_TRUE(ret != BSL_SUCCESS);
funcs.fixLenFunc = NULL;
funcs.varLenFunc = BinLogVar;
ret = BSL_LOG_RegBinLogFunc(&funcs);
ASSERT_TRUE(ret != BSL_SUCCESS);
funcs.fixLenFunc = BinLogFix;
funcs.varLenFunc = BinLogVar;
ret = BSL_LOG_RegBinLogFunc(&funcs);
ASSERT_TRUE(ret == BSL_SUCCESS);
g_binlogFlag = 0;
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID05001, BSL_LOG_LEVEL_DEBUG, BSL_LOG_BINLOG_TYPE_RUN, "this is test %d %d", 1, 2, 0, 0);
ASSERT_TRUE(g_binlogFlag == 0);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID05001, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "this is test %d %d", 1, 2, 0, 0);
ASSERT_TRUE(g_binlogFlag == 1);
const char *s = "abc";
g_binlogFlag = 0;
BSL_LOG_BINLOG_VARLEN(BINLOG_ID05001, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN, "this is test %s", s);
ASSERT_TRUE(g_binlogFlag == 0);
BSL_LOG_BINLOG_VARLEN(BINLOG_ID05001, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "this is test %s", s);
ASSERT_TRUE(g_binlogFlag == (uintptr_t)s);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_SET_BIN_LOG_LEVEL_API_TC001
* @title Setting the log level
* @precon nan
* @brief
* 1. Call the BSL_LOG_SetBinLogLevel interface with the input parameter BSL_LOG_LEVEL_SEC - 1.
* Expected result 1 is obtained.
* 2. Call the BSL_LOG_SetBinLogLevel interface with the input parameter BSL_LOG_LEVEL_SEC.
* Expected result 2 is obtained.
* 3. Call the BSL_LOG_SetBinLogLevel interface with the input parameter BSL_LOG_LEVEL_FATAL.
* Expected result 3 is obtained.
* 4. Call the BSL_LOG_SetBinLogLevel interface with the input parameter BSL_LOG_LEVEL_ERR.
* Expected result 4 is obtained.
* 5. Call the BSL_LOG_SetBinLogLevel interface with the input parameter BSL_LOG_LEVEL_WARN.
* Expected result 5 is obtained.
* 6. Call the BSL_LOG_SetBinLogLevel interface with the input parameter BSL_LOG_LEVEL_INFO.
* Expected result 6 is obtained.
* 7. Call the BSL_LOG_SetBinLogLevel interface with the input parameter BSL_LOG_LEVEL_DEBUG.
* Expected result 7 is obtained.
* 8. Call the BSL_LOG_SetBinLogLevel interface with the input parameter BSL_LOG_LEVEL_DEBUG + 1.
* Expected result 8 is obtained.
* @expect
* 1.BSL_LOG_ERR_BAD_PARAM
* 2.BSL_SUCCESS
* 3.BSL_SUCCESS
* 4.BSL_SUCCESS
* 5.BSL_SUCCESS
* 6.BSL_SUCCESS
* 7.BSL_SUCCESS
* 8.BSL_LOG_ERR_BAD_PARAM
*/
/* BEGIN_CASE */
void SDV_BSL_SET_BIN_LOG_LEVEL_API_TC001(void)
{
TestMemInit();
ASSERT_TRUE(BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_SEC - 1) == BSL_LOG_ERR_BAD_PARAM);
ASSERT_TRUE(BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_SEC) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_FATAL) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_ERR) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_WARN) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_INFO) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_DEBUG) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_DEBUG + 1) == BSL_LOG_ERR_BAD_PARAM);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_BIN_LOG_FUNC_TC001
* @title Demo of dotting logs of the BSL module. The log file is /tmp/HITLS_binlog_test.log.
* @precon nan
* @brief
* 1. Clean up and reopen the file. Expected result 1 is obtained.
* 2. Setting the log level. Expected result 2 is obtained.
* 3. Registering the Dotting Log Function. Expected result 3 is obtained.
* 4. Invoke the 4 parameter dotting to filter logs by log level. Expected result 4 is obtained.
* 5. Invoke the four-parameter dot. Expected result 5 is obtained.
* 6. Invoke the 1 parameter measurement point.
* @expect
* 1. Succeeded in clearing the remaining log files.
* 2. BSL_SUCCESS
* 3. BSL_SUCCESS
* 4. No output is generated in the log file.
* 5. The log file has output.
* 6. The log file has output.
*/
/* BEGIN_CASE */
void SDV_BSL_BIN_LOG_FUNC_TC001(void)
{
int32_t ret;
const char *filename = "./HITLS_binlog_test.log";
remove(filename);
g_LogOutput = fopen(filename, "w");
ASSERT_TRUE(g_LogOutput != NULL);
ret = BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_ERR);
ASSERT_TRUE(ret == BSL_SUCCESS);
BSL_LOG_BinLogFuncs funcs = {BinLogFixFunc, BinLogVarFunc};
ret = BSL_LOG_RegBinLogFunc(&funcs);
ASSERT_TRUE(ret == BSL_SUCCESS);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID05001, BSL_LOG_LEVEL_DEBUG, BSL_LOG_BINLOG_TYPE_RUN,
"this is test %d %d", 1, 2, 0, 0);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID05002, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"this is test %d %d", 1, 2, 2147483647, 4294967295);
BSL_LOG_BINLOG_VARLEN(BINLOG_ID05003, BSL_LOG_LEVEL_FATAL, BSL_LOG_BINLOG_TYPE_RUN,
"this is test msg: %s", "hello world");
EXIT:
fclose(g_LogOutput); // flush and close
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/bsl/log/test_suite_sdv_log.c | C | unknown | 16,340 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include "securec.h"
#include "bsl_errno.h"
#include "bsl_obj.h"
#include "bsl_obj_internal.h"
/* END_HEADER */
extern BslOidInfo g_oidTable[];
extern uint32_t g_tableSize;
/**
* @test SDV_BSL_OBJ_CID_OID_FUNC_TC001
* @title check whether the relative sequence of cid and oid tables is corrent
* @expect success
*/
/* BEGIN_CASE */
void SDV_BSL_OBJ_CID_OID_FUNC_TC001()
{
int32_t cidIndex = 0;
int32_t oidIndex = 0;
int32_t ret = 0;
while (cidIndex < BSL_CID_MAX && oidIndex < (int32_t)g_tableSize) {
if ((int32_t)g_oidTable[oidIndex].cid == cidIndex) {
ret++;
cidIndex++;
oidIndex++;
continue;
}
if ((int32_t)g_oidTable[oidIndex].cid > cidIndex) {
cidIndex++;
continue;
}
oidIndex++;
}
ASSERT_TRUE(ret == (int32_t)g_tableSize);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_OBJ_CREATE_SIGN_ID_TC001
* @title Test BSL_OBJ_CreateSignId functionality
* @expect success
*/
/* BEGIN_CASE */
void SDV_BSL_OBJ_CREATE_SIGN_ID_TC001(void)
{
#ifndef HITLS_BSL_HASH
SKIP_TEST();
#else
BslCid signId = BSL_CID_MAX - 1;
BslCid asymId = BSL_CID_RSA;
BslCid hashId = BSL_CID_MAX - 2;
TestMemInit();
ASSERT_EQ(BSL_OBJ_CreateSignId(signId, asymId, hashId), BSL_SUCCESS);
BslCid retrievedAsymId = BSL_OBJ_GetAsymAlgIdFromSignId(signId);
ASSERT_EQ(asymId, retrievedAsymId);
BslCid retrievedHashId = BSL_OBJ_GetHashIdFromSignId(signId);
ASSERT_EQ(hashId, retrievedHashId);
BslCid retrievedSignId = BSL_OBJ_GetSignIdFromHashAndAsymId(asymId, hashId);
ASSERT_EQ(signId, retrievedSignId);
ASSERT_EQ(BSL_OBJ_CreateSignId(signId, asymId, hashId), BSL_SUCCESS);
signId = BSL_CID_SHA256WITHRSAENCRYPTION;
ASSERT_EQ(BSL_OBJ_CreateSignId(signId, asymId, hashId), BSL_SUCCESS);
ASSERT_EQ(BSL_OBJ_CreateSignId(BSL_CID_UNKNOWN, asymId, hashId), BSL_INVALID_ARG);
ASSERT_EQ(BSL_OBJ_CreateSignId(signId, BSL_CID_UNKNOWN, hashId), BSL_INVALID_ARG);
ASSERT_EQ(BSL_OBJ_CreateSignId(signId, asymId, BSL_CID_UNKNOWN), BSL_INVALID_ARG);
BSL_OBJ_FreeSignHashTable();
EXIT:
return;
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_OBJ_CREATE_TC001
* @title Test BSL_OBJ_Create functionality
* @expect success
*/
/* BEGIN_CASE */
void SDV_BSL_OBJ_CREATE_TC001()
{
#ifndef HITLS_BSL_HASH
SKIP_TEST();
#else
char *testOidName = "TEST-OID";
BslCid testCid = BSL_CID_MAX + 1;
char testOidData[] = "\52\206\110\206\367\15\1\11\30";
BslOidString testOid = {9, testOidData, BSL_OID_GLOBAL};
const char *aesOidName = "AES128-CBC";
BslCid aesCid = BSL_CID_AES128_CBC;
char aesOidData[] = "\140\206\110\1\145\3\4\1\2";
TestMemInit();
ASSERT_EQ(BSL_OBJ_Create(aesOidData, 9, aesOidName, aesCid), BSL_SUCCESS);
ASSERT_EQ(BSL_OBJ_Create(testOidData, 9, testOidName, testCid), BSL_SUCCESS);
BslCid retrievedCid = BSL_OBJ_GetCID(&testOid);
ASSERT_EQ(testCid, retrievedCid);
BslOidString *retrievedOid = BSL_OBJ_GetOID(testCid);
ASSERT_TRUE(retrievedOid != NULL);
ASSERT_EQ(testOid.octetLen, retrievedOid->octetLen);
ASSERT_EQ(memcmp(testOid.octs, retrievedOid->octs, testOid.octetLen), 0);
const char *retrievedName = BSL_OBJ_GetOidNameFromOid(&testOid);
ASSERT_TRUE(retrievedName != NULL);
ASSERT_EQ(strcmp(testOidName, retrievedName), 0);
ASSERT_EQ(BSL_OBJ_Create(testOidData, 9, testOidName, testCid), BSL_SUCCESS);
ASSERT_EQ(BSL_OBJ_Create(NULL, 9, testOidName, testCid), BSL_INVALID_ARG);
ASSERT_EQ(BSL_OBJ_Create(testOidData, 9, NULL, testCid), BSL_INVALID_ARG);
ASSERT_EQ(BSL_OBJ_Create(testOidData, 9, testOidName, BSL_CID_UNKNOWN), BSL_INVALID_ARG);
BSL_OBJ_FreeHashTable();
EXIT:
return;
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_OBJ_HASH_TABLE_LOOKUP_TC001
* @title Test hash table lookup functionality for OIDs and CIDs
* @expect success
*/
/* BEGIN_CASE */
void SDV_BSL_OBJ_HASH_TABLE_LOOKUP_TC001()
{
#ifndef HITLS_BSL_HASH
SKIP_TEST();
#else
int32_t ret;
BslOidString testOid1, testOid2;
const char *testOidName1 = "TEST-OID-1";
const char *testOidName2 = "TEST-OID-2";
BslCid testCid1 = BSL_CID_MAX + 1;
BslCid testCid2 = BSL_CID_MAX + 2;
char testOidData1[] = "\52\206\110\206\367\15\1\11\31";
char testOidData2[] = "\52\206\110\206\367\15\1\11\32";
testOid1.octetLen = sizeof(testOidData1);
testOid1.octs = testOidData1;
testOid1.flags = BSL_OID_GLOBAL;
testOid2.octetLen = sizeof(testOidData2);
testOid2.octs = testOidData2;
testOid2.flags = BSL_OID_GLOBAL;
TestMemInit();
ret = BSL_OBJ_Create(testOidData1, sizeof(testOidData1), testOidName1, testCid1);
ASSERT_EQ(BSL_SUCCESS, ret);
ret = BSL_OBJ_Create(testOidData2, sizeof(testOidData2), testOidName2, testCid2);
ASSERT_EQ(BSL_SUCCESS, ret);
BslCid retrievedCid1 = BSL_OBJ_GetCID(&testOid1);
ASSERT_EQ(testCid1, retrievedCid1);
BslCid retrievedCid2 = BSL_OBJ_GetCID(&testOid2);
ASSERT_EQ(testCid2, retrievedCid2);
BslOidString *retrievedOid1 = BSL_OBJ_GetOID(testCid1);
ASSERT_TRUE(retrievedOid1 != NULL);
ASSERT_EQ(testOid1.octetLen, retrievedOid1->octetLen);
ASSERT_EQ(memcmp(testOid1.octs, retrievedOid1->octs, testOid1.octetLen), 0);
BslOidString *retrievedOid2 = BSL_OBJ_GetOID(testCid2);
ASSERT_TRUE(retrievedOid2 != NULL);
ASSERT_EQ(testOid2.octetLen, retrievedOid2->octetLen);
ASSERT_EQ(memcmp(testOid2.octs, retrievedOid2->octs, testOid2.octetLen), 0);
const char *retrievedName1 = BSL_OBJ_GetOidNameFromOid(&testOid1);
ASSERT_TRUE(retrievedName1 != NULL);
ASSERT_EQ(strcmp(testOidName1, retrievedName1), 0);
const char *retrievedName2 = BSL_OBJ_GetOidNameFromOid(&testOid2);
ASSERT_TRUE(retrievedName2 != NULL);
ASSERT_EQ(strcmp(testOidName2, retrievedName2), 0);
BSL_OBJ_FreeHashTable();
EXIT:
return;
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_OBJ_GetOIDNUMBERICSTRING_FUNC_TC001
* @title Test converting an ASN.1 OID to its numeric representation
* @expect success
*/
/* BEGIN_CASE */
void SDV_BSL_OBJ_GetOIDNUMBERICSTRING_FUNC_TC001(Hex *str, char *expect)
{
char *oid = NULL;
uint8_t *hexOid = NULL;
TestMemInit();
oid = BSL_OBJ_GetOidNumericString(str->x, str->len);
ASSERT_TRUE(oid != NULL);
ASSERT_EQ(memcmp(oid, expect, strlen(expect)), 0);
uint32_t outLen = 0;
hexOid = BSL_OBJ_GetOidFromNumericString(expect, strlen(expect), &outLen);
ASSERT_TRUE(hexOid != NULL);
ASSERT_EQ(outLen, str->len);
ASSERT_COMPARE("test obj", hexOid, outLen, str->x, str->len);
EXIT:
if (oid != NULL) {
free(oid);
}
BSL_SAL_Free(hexOid);
return;
}
/* END_CASE */
/**
* @test SDV_BSL_OBJ_GetOIDNUMBERICSTRING_FUNC_TC002
* @title Test converting an ASN.1 OID to its numeric representation (Counterexample)
* @expect success
*/
/* BEGIN_CASE */
void SDV_BSL_OBJ_GetOIDNUMBERICSTRING_FUNC_TC002(Hex *str)
{
ASSERT_TRUE(BSL_OBJ_GetOidNumericString(str->x, str->len) == NULL);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_OBJ_GetOIDNUMBERICSTRING_FUNC_TC001
* @title Exception Parameter Testing for the BSL_OBJ_GetOidFromNumericString Function.
* @expect success
*/
/* BEGIN_CASE */
void SDV_BSL_OBJ_GETOID_FROM_NUMBERIC_FUNC_TC001(char *expect)
{
TestMemInit();
uint32_t outLen = 0;
uint8_t *hexOid = NULL;
ASSERT_TRUE(BSL_OBJ_GetOidFromNumericString(NULL, 0, &outLen) == NULL);
ASSERT_TRUE(BSL_OBJ_GetOidFromNumericString(expect, strlen(expect), NULL) == NULL);
hexOid = BSL_OBJ_GetOidFromNumericString(expect, strlen(expect), &outLen);
ASSERT_TRUE(hexOid == NULL);
EXIT:
BSL_SAL_FREE(hexOid);
return;
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/bsl/obj/test_suite_sdv_obj.c | C | unknown | 8,453 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include "bsl_sal.h"
#include "bsl_params.h"
#include "bsl_err.h"
#include "bsl_log.h"
/* END_HEADER */
/* BEGIN_CASE */
void SDV_BSL_BSL_PARAM_InitValue_API_TC001()
{
BSL_Param param = {0};
int32_t val = 1;
bool valBool = true;
int32_t *valPtr = &val;
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 0, BSL_PARAM_TYPE_UINT32,
&val, sizeof(val)), BSL_PARAMS_INVALID_KEY);
ASSERT_EQ(BSL_PARAM_InitValue(NULL, 1, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_INVALID_ARG);
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 1, BSL_PARAM_TYPE_UINT32, NULL, sizeof(val)), BSL_INVALID_ARG);
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 1, 100, &val, sizeof(val)), BSL_PARAMS_INVALID_TYPE);
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 1, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 1, BSL_PARAM_TYPE_BOOL, &valBool, sizeof(valBool)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 1, BSL_PARAM_TYPE_FUNC_PTR, valPtr, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 1, BSL_PARAM_TYPE_CTX_PTR, valPtr, 0), BSL_SUCCESS);
valPtr = NULL;
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 1, BSL_PARAM_TYPE_FUNC_PTR, valPtr, 0), BSL_SUCCESS);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_BSL_PARAM_SetValue_API_TC001()
{
BSL_Param param = {0};
int32_t val = 1;
bool valBool = true;
int32_t *valPtr = &val;
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 1, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_SetValue(¶m, 0, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_PARAMS_INVALID_KEY);
ASSERT_EQ(BSL_PARAM_SetValue(NULL, 1, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_INVALID_ARG);
ASSERT_EQ(BSL_PARAM_SetValue(¶m, 2, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_PARAMS_MISMATCH);
ASSERT_EQ(BSL_PARAM_SetValue(¶m, 1, BSL_PARAM_TYPE_UINT32, &val, 5), BSL_INVALID_ARG);
ASSERT_EQ(BSL_PARAM_SetValue(¶m, 1, BSL_PARAM_TYPE_UINT32, NULL, sizeof(val)), BSL_INVALID_ARG);
val = 4;
ASSERT_EQ(BSL_PARAM_SetValue(¶m, 1, BSL_PARAM_TYPE_OCTETS_PTR, &val, sizeof(val)), BSL_PARAMS_MISMATCH);
ASSERT_EQ(BSL_PARAM_SetValue(¶m, 1, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_SUCCESS);
int32_t retVal = 0;
uint32_t retValLen = sizeof(retVal);
ASSERT_EQ(BSL_PARAM_GetValue(¶m, 1, BSL_PARAM_TYPE_UINT32, &retVal, &retValLen), BSL_SUCCESS);
ASSERT_EQ(retVal, val);
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 1, BSL_PARAM_TYPE_BOOL, &valBool, sizeof(valBool)), BSL_SUCCESS);
valBool = false;
ASSERT_EQ(BSL_PARAM_SetValue(¶m, 1, BSL_PARAM_TYPE_BOOL, &valBool, sizeof(valBool)), BSL_SUCCESS);
uint32_t boolSize = sizeof(valBool);
ASSERT_EQ(BSL_PARAM_GetValue(¶m, 1, BSL_PARAM_TYPE_BOOL, &valBool, &boolSize), BSL_SUCCESS);
ASSERT_EQ(valBool, false);
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 1, BSL_PARAM_TYPE_FUNC_PTR, valPtr, 0), BSL_SUCCESS);
*valPtr = 0;
ASSERT_EQ(BSL_PARAM_SetValue(¶m, 1, BSL_PARAM_TYPE_FUNC_PTR, valPtr, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_GetPtrValue(¶m, 1, BSL_PARAM_TYPE_FUNC_PTR, (void **)&valPtr, NULL), BSL_SUCCESS);
ASSERT_EQ(*valPtr, 0);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_BSL_PARAM_FindParam_API_TC001()
{
BSL_Param param[6] = {0};
int32_t val = 1;
bool valBool = true;
int32_t *valPtr = &val;
ASSERT_EQ(BSL_PARAM_InitValue(¶m[0], 1, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[1], 2, BSL_PARAM_TYPE_BOOL, &valBool, sizeof(valBool)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[2], 3, BSL_PARAM_TYPE_FUNC_PTR, valPtr, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[3], 4, BSL_PARAM_TYPE_CTX_PTR, valPtr, 0), BSL_SUCCESS);
BSL_Param *temp = NULL;
temp = BSL_PARAM_FindParam(param, 1);
ASSERT_EQ(temp, ¶m[0]);
temp = BSL_PARAM_FindParam(param, 2);
ASSERT_EQ(temp, ¶m[1]);
temp = BSL_PARAM_FindParam(param, 5);
ASSERT_EQ(temp, NULL);
EXIT:
return;
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/bsl/params/test_suite_sdv_params.c | C | unknown | 4,766 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "bsl_sal.h"
#include "bsl_params.h"
#include "bsl_err.h"
#include "bsl_list.h"
#include "crypt_eal_cipher.h"
/* END_HEADER */
/* BEGIN_CASE */
void SDV_BSL_BSL_PARAM_MAKER_New_API_TC001()
{
BSL_ParamMaker *maker = BSL_PARAM_MAKER_New();
ASSERT_TRUE(maker != NULL);
EXIT:
if (maker) {
BSL_PARAM_MAKER_Free(maker);
}
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_BSL_PARAM_MAKER_Push_Value_API_TC001()
{
int32_t val = 1;
bool valBool = true;
int32_t *valPtr = &val;
int32_t key = 1;
BSL_ParamMaker *maker = BSL_PARAM_MAKER_New();
ASSERT_TRUE(maker != NULL);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(NULL, key, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_NULL_INPUT);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_UINT32, NULL, sizeof(val)), BSL_NULL_INPUT);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_BOOL, &valBool, sizeof(valBool)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_FUNC_PTR, valPtr, sizeof(valPtr)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_CTX_PTR, valPtr, sizeof(valPtr)), BSL_SUCCESS);
valPtr = NULL;
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_FUNC_PTR, valPtr, 0), BSL_SUCCESS);
EXIT:
if (maker) {
BSL_PARAM_MAKER_Free(maker);
}
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_BSL_PARAM_MAKER_ToParam_API_TC001()
{
int32_t val = 1;
uint8_t u8 = 10;
uint16_t u16 = 20;
uint32_t u32 = 100;
bool valBool = true;
int32_t key = 1;
int32_t index = 1;
BSL_ParamMaker *maker = BSL_PARAM_MAKER_New();
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_UINT32, &u32, sizeof(u32)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_BOOL, &valBool, sizeof(valBool)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_INT32, &val, sizeof(val)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_UINT8, &u8, sizeof(u8)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_UINT16, &u16, sizeof(u16)), BSL_SUCCESS);
BSL_Param *params = BSL_PARAM_MAKER_ToParam(maker);
ASSERT_TRUE(params != NULL);
BSL_Param *temp = NULL;
key = 1;
temp = BSL_PARAM_FindParam(params, key++);
ASSERT_EQ(temp->value, params->value);
ASSERT_EQ(*((uint32_t *)temp->value), u32);
temp = BSL_PARAM_FindParam(params, key++);
ASSERT_EQ(temp->value, (¶ms[index++])->value);
ASSERT_EQ(*((bool *)temp->value), valBool);
temp = BSL_PARAM_FindParam(params, key++);
ASSERT_EQ(temp->value, (¶ms[index++])->value);
ASSERT_EQ(*((int32_t *)temp->value), val);
temp = BSL_PARAM_FindParam(params, key++);
ASSERT_EQ(temp->value, (¶ms[index++])->value);
ASSERT_EQ(*((uint8_t *)temp->value), u8);
temp = BSL_PARAM_FindParam(params, key++);
ASSERT_EQ(temp->value, (¶ms[index++])->value);
ASSERT_EQ(*((uint16_t *)temp->value), u16);
EXIT:
if (maker) {
BSL_PARAM_MAKER_Free(maker);
}
if (params) {
BSL_PARAM_Free(params);
}
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_BSL_PARAM_MAKER_ToParam_API_TC002()
{
char str[] = "aaa";
uint32_t u32 = 100;
uint32_t *ptr = &u32;
unsigned char OCTETS[1];
OCTETS[0] = 'a';
int32_t key = 1;
int32_t index = 1;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
BSL_ParamMaker *maker = BSL_PARAM_MAKER_New();
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_UTF8_STR, &str, sizeof(str)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_CTX_PTR, ctx, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_UINT32_PTR, ptr, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_OCTETS, &OCTETS, sizeof(OCTETS)), BSL_SUCCESS);
BSL_Param *params = BSL_PARAM_MAKER_ToParam(maker);
BSL_Param *temp = NULL;
key = 1;
temp = BSL_PARAM_FindParam(params, key++);
ASSERT_EQ(temp->value, params->value);
ASSERT_TRUE(memcmp((char *)temp->value, str, sizeof(str)) == 0);
temp = BSL_PARAM_FindParam(params, key++);
ASSERT_EQ(temp->value, (¶ms[index++])->value);
ASSERT_TRUE(memcmp((CRYPT_EAL_CipherCtx *)temp->value, ctx, 0) == 0);
temp = BSL_PARAM_FindParam(params, key++);
ASSERT_EQ(temp->value, (¶ms[index++])->value);
ASSERT_EQ(*((uint32_t *)temp->value), u32);
temp = BSL_PARAM_FindParam(params, key++);
ASSERT_EQ(temp->value, (¶ms[index++])->value);
ASSERT_TRUE(memcmp((unsigned char *)temp->value, &OCTETS, sizeof(OCTETS)) == 0);
BSL_PARAM_Free(params);
params = NULL;
key = 1;
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_UTF8_STR, &str, sizeof(str) - 2), BSL_SUCCESS);
params = BSL_PARAM_MAKER_ToParam(maker);
temp = BSL_PARAM_FindParam(params, key);
ASSERT_EQ(temp->value, params->value);
ASSERT_TRUE(memcmp((char *)temp->value, str, sizeof(str) - 2) == 0);
ASSERT_TRUE(memcmp((char *)temp->value, str, sizeof(str)) == 0);
EXIT:
if (maker) {
BSL_PARAM_MAKER_Free(maker);
}
if (params) {
BSL_PARAM_Free(params);
}
if (ctx) {
CRYPT_EAL_CipherFreeCtx(ctx);
}
return;
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/bsl/params/test_suite_sdv_params_maker.c | C | unknown | 6,184 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "securec.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "bsl_pem_internal.h"
/* END_HEADER */
/* BEGIN_CASE */
void SDV_BSL_PEM_ISPEM_FUNC_TC001(char *data, int expflag)
{
char *encode = data;
uint32_t encodeLen = strlen(data);
bool isPem = BSL_PEM_IsPemFormat(encode, encodeLen);
ASSERT_TRUE(isPem == (bool)expflag);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_PEM_ISPEM_FUNC_TC002(void)
{
char *aa = "aaaaaaaa";
ASSERT_TRUE(BSL_PEM_IsPemFormat(NULL, 0) == false);
ASSERT_TRUE(BSL_PEM_IsPemFormat(aa, strlen(aa)) == false);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_PEM_PARSE_FUNC_TC001(char *encode, char *head, char *tail, int expRes)
{
BSL_PEM_Symbol sym = {head, tail};
char *pemdata = encode;
uint32_t len = strlen(encode);
uint8_t *asn1Encode = NULL;
uint32_t asn1Len;
TestMemInit();
ASSERT_EQ(BSL_PEM_DecodePemToAsn1(&pemdata, &len, &sym, &asn1Encode, &asn1Len), expRes);
EXIT:
BSL_SAL_Free(asn1Encode);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_PEM_PARSE_FUNC_TC002(void)
{
BSL_PEM_Symbol sym = {BSL_PEM_EC_PRI_KEY_BEGIN_STR, BSL_PEM_EC_PRI_KEY_END_STR};
char *pemdata = "-----BEGIN EC PRIVATE KEY-----\n"
"MHcCAQEEIAadtjyegBKXLH9xvNDvH24j7cn3PsaNSXSMIVmvJZM7oAoGCCqGSM49\n"
"AwEHoUQDQgAEPFKNDGyE7HES1hPd8mXydX4QunGvk37ISPOhXJStzxTt8sWdcEtV\n"
"gaXhArNx9Dz8pKIhoGcviy8xML3wPICv9Q==\n"
"-----END EC PRIVATE KEY-----\n"
"-----BEGIN EC PRIVATE KEY-----\n"
"MHcCAQEEIAadtjyegBKXLH9xvNDvH24j7cn3PsaNSXSMIVmvJZM7oAoGCCqGSM49\n"
"AwEHoUQDQgAEPFKNDGyE7HES1hPd8mXydX4QunGvk37ISPOhXJStzxTt8sWdcEtV\n"
"gaXhArNx9Dz8pKIhoGcviy8xML3wPICv9Q==\n"
"-----END EC PRIVATE KEY-----\n";
int32_t len = strlen(pemdata);
char *next = pemdata;
uint32_t nextLen = len;
uint8_t *asn1Encode = NULL;
uint32_t asn1Len;
TestMemInit();
ASSERT_TRUE(BSL_PEM_DecodePemToAsn1(&next, &nextLen, &sym, &asn1Encode, &asn1Len) == BSL_SUCCESS);
BSL_SAL_Free(asn1Encode);
ASSERT_TRUE(BSL_PEM_DecodePemToAsn1(&next, &nextLen, &sym, &asn1Encode, &asn1Len) == BSL_SUCCESS);
EXIT:
BSL_SAL_Free(asn1Encode);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_PEM_PARSE_FUNC_TC003(void)
{
BSL_PEM_Symbol sym = {BSL_PEM_EC_PRI_KEY_BEGIN_STR, BSL_PEM_EC_PRI_KEY_END_STR};
char *pemdata = "-----BEGIN EC PRIVATE KEY-----END EC PRIVATE KEY------------------END-----\n";
int32_t len = strlen(pemdata);
char *next = pemdata;
uint32_t nextLen = len;
uint8_t *asn1Encode = NULL;
uint32_t asn1Len;
ASSERT_TRUE(BSL_PEM_DecodePemToAsn1(&next, &nextLen, &sym, &asn1Encode, &asn1Len) == BSL_PEM_SYMBOL_NOT_FOUND);
EXIT:
BSL_SAL_Free(asn1Encode);
return;
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/bsl/pem/test_suite_sdv_pem.c | C | unknown | 3,581 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_errno.h"
#include "sal_atomic.h"
#define TEST_THREAD_DEFAULT_TC001_WRITE_CNT 100000
#define TEST_WRITE_PID_CNT 2
#define TEST_READ_PID_CNT 2
int g_threadDefaultWrite001 = 0;
int g_threadDefaultRead001 = 0;
uint64_t g_threadDefaultId001 = 0;
static void *StdMalloc(uint32_t len)
{
return malloc((size_t)len);
}
static int32_t pthreadRWLockNew(BSL_SAL_ThreadLockHandle *lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
pthread_rwlock_t *newLock;
newLock = (pthread_rwlock_t *)BSL_SAL_Malloc(sizeof(pthread_rwlock_t));
if (newLock == NULL) {
return BSL_MALLOC_FAIL;
}
if (pthread_rwlock_init(newLock, NULL) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
*lock = newLock;
return BSL_SUCCESS;
}
static void pthreadRWLockFree(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return;
}
pthread_rwlock_destroy((pthread_rwlock_t *)lock);
BSL_SAL_FREE(lock);
}
static int32_t pthreadRWLockReadLock(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
if (pthread_rwlock_rdlock((pthread_rwlock_t *)lock) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
return BSL_SUCCESS;
}
static int32_t pthreadRWLockWriteLock(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
if (pthread_rwlock_wrlock((pthread_rwlock_t *)lock) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
return BSL_SUCCESS;
}
static int32_t pthreadRWLockUnlock(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
if (pthread_rwlock_unlock((pthread_rwlock_t *)lock) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
return BSL_SUCCESS;
}
static uint64_t pthreadGetId(void)
{
return (uint64_t)pthread_self();
}
#ifdef HITLS_BSL_SAL_THREAD
static void *TEST_Read(void *arg)
{
BSL_SAL_ThreadLockHandle lock = (BSL_SAL_ThreadLockHandle)arg;
int32_t ret = BSL_SAL_ThreadReadLock(lock);
g_threadDefaultRead001 = g_threadDefaultWrite001;
BSL_SAL_ThreadUnlock(lock);
ASSERT_TRUE(ret == BSL_SUCCESS);
EXIT:
return NULL;
}
static void *TEST_Write(void *arg)
{
BSL_SAL_ThreadLockHandle lock = (BSL_SAL_ThreadLockHandle)arg;
int32_t ret = BSL_SUCCESS;
for (size_t i = 0; i < TEST_THREAD_DEFAULT_TC001_WRITE_CNT; i++) {
if (BSL_SAL_ThreadWriteLock(lock) != BSL_SUCCESS) {
ret = BSL_SAL_ERR_UNKNOWN;
}
g_threadDefaultWrite001++;
g_threadDefaultId001 = BSL_SAL_ThreadGetId();
BSL_SAL_ThreadUnlock(lock);
}
ASSERT_TRUE(ret == BSL_SUCCESS);
EXIT:
return NULL;
}
#endif
/* END_HEADER */
/**
* @test SDV_BSL_SAL_REGMEM_API_TC001
* @title Registering memory-related functions
* @precon nan
* @brief
* 1. Call BSL_SAL_Malloc to allocate 0-byte space. Expected result 1 is obtained.
* 2. Call BSL_SAL_Malloc to allocate 1-byte space. Expected result 2 is obtained.
* 3. Call BSL_SAL_Calloc to allocate a large memory space. Expected result 3 is obtained.
* 4. Call BSL_SAL_CallBack_Ctrl to transfer an exception parameter. Expected result 4 is obtained.
* 5. Call BSL_SAL_CallBack_Ctrl to transfer an normal parameter. Expected result 5 is obtained.
* 6. Call BSL_SAL_Malloc to allocate 8-byte space. Expected result 6 is obtained.
* 7. Call BSL_SAL_FREE to free 8-byte space. Expected result 7 is obtained.
* @expect
* 1. Failed to apply for the memory. NULL is returned.
* 2. Memory application succeeded.
* 3. Failed to apply for the memory. NULL is returned.
* 4. Failed to register the callback, return BSL_SAL_ERR_BAD_PARAM
* 5. Registration callback succeeded, return BSL_SUCCESS.
* 6. Memory application succeeded.
* 7. The memory is released successfully.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_REGMEM_API_TC001(void)
{
void *ptr = NULL;
ptr = BSL_SAL_Malloc(0);
ASSERT_TRUE(ptr == NULL);
#ifdef HITLS_BSL_SAL_MEM
ptr = BSL_SAL_Malloc(1);
ASSERT_TRUE(ptr != NULL);
BSL_SAL_FREE(ptr);
#endif
ptr = BSL_SAL_Calloc(0xFFFFFFFF, 0xFFFFFFFF);
ASSERT_TRUE(ptr == NULL);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(0, NULL) == BSL_SAL_ERR_BAD_PARAM);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_MALLOC, NULL) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_MALLOC, StdMalloc) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_FREE, free) == BSL_SUCCESS);
ptr = BSL_SAL_Malloc(0);
ASSERT_TRUE(ptr != NULL);
BSL_SAL_FREE(ptr);
ASSERT_TRUE(ptr == NULL);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_REG_THREAD_API_TC001
* @title Register thread-related functions.
* @precon nan
* @brief
* 1. Call BSL_SAL_CallBack_Ctrl to transfer an exception parameter. Expected result 1 is obtained.
* 2. Call BSL_SAL_CallBack_Ctrl to transfer an normal parameter. Expected result 2 is obtained.
* 3. Call BSL_SAL_ThreadLockNew to transfer an exception parameter. Expected result 3 is obtained.
* 4. Call BSL_SAL_ThreadReadLock to transfer an exception parameter. Expected result 4 is obtained.
* 5. Call BSL_SAL_ThreadWriteLock to transfer an exception parameter. Expected result 5 is obtained.
* 6. Call BSL_SAL_ThreadUnlock to transfer an exception parameter. Expected result 6 is obtained.
* 7. Call BSL_SAL_ThreadLockFree to transfer an exception parameter. Expected result 7 is obtained.
* @expect
* 1. Failed to register the callback, return BSL_SAL_ERR_BAD_PARAM
* 2. Registration callback succeeded, return BSL_SUCCESS.
* 9. Failed to create the new lock, return BSL_SAL_ERR_BAD_PARAM
* 10. Failed to create the read lock, return BSL_SAL_ERR_BAD_PARAM
* 11. Failed to create the write lock, return BSL_SAL_ERR_BAD_PARAM
* 12. Failed to unlock, return BSL_SAL_ERR_BAD_PARAM
* 13. No return value
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_REG_THREAD_API_TC001(void)
{
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(0, NULL) == BSL_SAL_ERR_BAD_PARAM);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(0, NULL) == BSL_SAL_ERR_BAD_PARAM);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_NEW_CB_FUNC, pthreadRWLockNew) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_FREE_CB_FUNC, pthreadRWLockFree) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_READ_LOCK_CB_FUNC, pthreadRWLockReadLock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_WRITE_LOCK_CB_FUNC, pthreadRWLockWriteLock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_UNLOCK_CB_FUNC, pthreadRWLockUnlock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_GET_ID_CB_FUNC, pthreadGetId) == BSL_SUCCESS);
// Cannot create a lock handle because the pointer of the pointer is NULL.
ASSERT_TRUE(BSL_SAL_ThreadLockNew(NULL) == BSL_SAL_ERR_BAD_PARAM);
ASSERT_TRUE(BSL_SAL_ThreadReadLock(NULL) == BSL_SAL_ERR_BAD_PARAM);
ASSERT_TRUE(BSL_SAL_ThreadWriteLock(NULL) == BSL_SAL_ERR_BAD_PARAM);
ASSERT_TRUE(BSL_SAL_ThreadUnlock(NULL) == BSL_SAL_ERR_BAD_PARAM);
BSL_SAL_ThreadLockFree(NULL);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_MEM_API_TC001
* @title Test the memory application function when the memory registration callback function is not invoked.
* @precon nan
* @brief
* 1. Call BSL_SAL_Malloc to allocate 100-byte space. Expected result 1 is obtained.
* 2. Call BSL_SAL_ClearFree to free 100-byte space. Expected result 2 is obtained.
* @expect
* 1. Memory application succeeded.
* 2. The memory is released successfully.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_MEM_API_TC001(void)
{
#ifndef HITLS_BSL_SAL_MEM
SKIP_TEST();
#else
// 1
void *obj = BSL_SAL_Malloc(100);
ASSERT_TRUE(obj != NULL);
memset_s(obj, 100, 0x1, 100);
BSL_SAL_ClearFree(obj, 100);
EXIT:
return;
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_MEM_API_TC001
* @title Test the memory application function when the memory registration callback function is not invoked.
* @precon nan
* @brief
* 1. Call BSL_SAL_Malloc to allocate 1-byte space. Expected result 1 is obtained.
* 2. Call BSL_SAL_Calloc to allocate 1000-byte space. Expected result 2 is obtained.
* @expect
* 1. Memory application succeeded.
* 2. Memory application succeeded.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_MEM_API_TC002(void)
{
#ifndef HITLS_BSL_SAL_MEM
SKIP_TEST();
#else
// 1
void *obj = BSL_SAL_Malloc(1);
ASSERT_TRUE(obj != NULL);
BSL_SAL_FREE(obj);
uint8_t objZero3[1000] = {0};
uint8_t *obj3 = (uint8_t *)BSL_SAL_Calloc(1000, sizeof(uint8_t));
ASSERT_TRUE(obj3 != NULL);
ASSERT_TRUE(memcmp(objZero3, obj3, 1000) == 0);
BSL_SAL_FREE(obj3);
EXIT:
return;
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_DUMP_API_TC001
* @title Test the function of the dump interface when the memory-related callback is not registered.
* @precon nan
* @brief
* 1. Call BSL_SAL_Dump with the source memory address set to NULL. Expected result 1 is obtained.
* 2. Call BSL_SAL_Dump to set the total memory size to 0. Expected result 2 is obtained.
* 3. Call BSL_SAL_Dump interface to transfer normal parameters. Expected result 3 is obtained.
* @expect
* 1. Failed to duplicate the memory space. Return NULL.
* 2. Failed to duplicate the memory space. Return NULL.
* 3. Succeeded in duplicate the memory space.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_DUMP_API_TC001(void)
{
#ifndef HITLS_BSL_SAL_MEM
SKIP_TEST();
#else
uint32_t memLen = 1024U;
void *testPtr = NULL;
void *srcPtr = BSL_SAL_Malloc(memLen);
ASSERT_TRUE(srcPtr != NULL);
// 1
ASSERT_TRUE(BSL_SAL_Dump(NULL, memLen) == NULL);
// 2
ASSERT_TRUE(BSL_SAL_Dump(srcPtr, 0) == NULL);
// 3
testPtr = BSL_SAL_Dump(srcPtr, memLen);
ASSERT_TRUE(testPtr != NULL);
ASSERT_TRUE(memcmp(testPtr, srcPtr, memLen) == 0);
EXIT:
BSL_SAL_FREE(srcPtr);
BSL_SAL_FREE(testPtr);
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_REALLOC_API_TC001
* @title Test functions related to reallocation when the memory-related callback is not registered.
* @precon nan
* @brief
* 1. The size of the extended memory is smaller than the original size. Expected result 1 is obtained.
* 2. The size of the extended memory is smaller than the original size. Expected result 2 is obtained.
* @expect
* 1. Success. The extended memory address is returned.
* 2. Success. The extended memory address is returned. No ASAN alarm is generated for realloc memory read/write.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_REALLOC_API_TC001(void)
{
#ifndef HITLS_BSL_SAL_MEM
SKIP_TEST();
#else
uint32_t originSize = 2000u;
uint32_t biggerSize = 3000u;
uint32_t smallerSize = 1000u;
void *obj = BSL_SAL_Malloc(originSize);
ASSERT_TRUE(obj != NULL);
// 1
void *obj2 = BSL_SAL_Realloc(obj, smallerSize, originSize);
// 2
uint8_t *obj3 = (uint8_t *)BSL_SAL_Realloc(obj2, biggerSize, smallerSize);
ASSERT_TRUE(obj3 != NULL);
ASSERT_TRUE(memset_s(obj3, biggerSize, 1, biggerSize) == EOK);
ASSERT_TRUE(obj3[biggerSize - 1] == 1);
// The realloc releases the obj. Therefore, the obj does not need to be released.
// The value of realloc size to 0 is an implementation definition. Therefore, the test is not performed.
EXIT:
BSL_SAL_FREE(obj3);
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_THREAD_CREATE_FUNC_TC001
* @title Creating and Closing Threads test
* @precon nan
* @brief
* 1. Unregistered thread-related callback and create a thread lock. Expected result 1 is obtained.
* 2. Call BSL_SAL_ThreadCreate to transfer abnormal parameters. Expected result 2 is obtained.
* 3. Call BSL_SAL_ThreadCreate to transfer normal parameters. Expected result 3 is obtained.
* 4. Call BSL_SAL_ThreadClose to transfer normal parameters. Expected result 4 is obtained.
* 5. Call BSL_SAL_ThreadClose to transfer abnormal parameters. Expected result 5 is obtained.
* 6. Release the lock. Expected result 6 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2. BSL_SAL_ERR_BAD_PARAM
* 3. BSL_SUCCESS
* 4. The thread is closed successfully.
* 5. No return value
* 6. Lock released successfully.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_THREAD_CREATE_FUNC_TC001(void)
{
#ifndef HITLS_BSL_SAL_THREAD
SKIP_TEST();
#else
BSL_SAL_ThreadLockHandle lock = NULL;
ASSERT_TRUE(BSL_SAL_ThreadLockNew(&lock) == BSL_SUCCESS);
BSL_SAL_ThreadId thread = NULL;
int32_t ret = BSL_SAL_ThreadCreate(&thread, NULL, NULL);
ASSERT_TRUE(ret == BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_ThreadCreate(NULL, TEST_Read, NULL);
ASSERT_TRUE(ret == BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_ThreadCreate(&thread, TEST_Read, lock);
ASSERT_TRUE(ret == BSL_SUCCESS);
BSL_SAL_ThreadClose(thread);
BSL_SAL_ThreadClose(NULL);
BSL_SAL_ThreadLockFree(lock);
EXIT:
return;
#endif
}
/* END_CASE */
static void TestRunOnce(void)
{
return;
}
/**
* @test SDV_BSL_SAL_THREAD_API_TC001
* @title Creating and Disabling Condition Variable Test
* @precon nan
* @brief
* 1. Call BSL_SAL_ThreadRunOnce to transfer abnormal parameters. Expected result 1 is obtained.
* 2. Call BSL_SAL_ThreadRunOnce to transfer normal parameters. Expected result 2 is obtained.
* @expect
* 1. BSL_SAL_ERR_BAD_PARAM
* 2. BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_THREAD_API_TC001(void)
{
uint32_t isErrInit = 0;
ASSERT_EQ(BSL_SAL_ThreadRunOnce(NULL, TestRunOnce), BSL_SAL_ERR_BAD_PARAM);
ASSERT_EQ(BSL_SAL_ThreadRunOnce(&isErrInit, NULL), BSL_SAL_ERR_BAD_PARAM);
ASSERT_EQ(BSL_SAL_ThreadRunOnce(&isErrInit, TestRunOnce), BSL_SUCCESS);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_CONDVAR_CREATE_FUNC_TC001
* @title Creating and Disabling Condition Variable Test
* @precon nan
* @brief
* 1. Call BSL_SAL_CreateCondVar to transfer abnormal parameters. Expected result 1 is obtained.
* 2. Call BSL_SAL_CreateCondVar to transfer normal parameters. Expected result 2 is obtained.
* 3. Call BSL_SAL_CondSignal to transfer abnormal parameters. Expected result 3 is obtained.
* 4. Call BSL_SAL_CondSignal to transfer normal parameters. Expected result 4 is obtained.
* 5. Call BSL_SAL_DeleteCondVar to transfer abnormal parameters. Expected result 5 is obtained.
* 6. Call BSL_SAL_DeleteCondVar to transfer normal parameters. Expected result 6 is obtained.
* 7. Call BSL_SAL_DeleteCondVar to delete the deleted condVar. Expected result 7 is obtained.
* @expect
* 1. BSL_SAL_ERR_BAD_PARAM
* 2. BSL_SUCCESS
* 3. BSL_SAL_ERR_BAD_PARAM
* 4. BSL_SUCCESS
* 5. BSL_SAL_ERR_BAD_PARAM
* 6. BSL_SUCCESS
* 7. BSL_SAL_ERR_UNKNOWN
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_CONDVAR_CREATE_FUNC_TC001(void)
{
#ifndef HITLS_BSL_SAL_THREAD
SKIP_TEST();
#else
BSL_SAL_CondVar condVar = NULL;
int32_t ret = BSL_SAL_CreateCondVar(NULL);
ASSERT_TRUE(ret == BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_CreateCondVar(&condVar);
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_SAL_CondSignal(NULL);
ASSERT_TRUE(ret == BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_CondSignal(condVar);
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_SAL_DeleteCondVar(NULL);
ASSERT_TRUE(ret == BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_DeleteCondVar(condVar);
ASSERT_TRUE(ret == BSL_SUCCESS);
EXIT:
return;
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_CONDVAR_WAIT_API_TC001
* @title Creating and Disabling Condition Variable Test
* @precon nan
* @brief
* 1. Call BSL_SAL_CreateCondVar to create a condition variable. Expected result 1 is obtained.
* 2. Unregistered thread-related callback and create a thread lock. Expected result 2 is obtained.
* 3. Call BSL_SAL_CondTimedwaitMs to transfer abnormal parameters. Expected result 3 is obtained.
* 4. Call BSL_SAL_CondTimedwaitMs to transfer normal parameters. Expected result 4 is obtained.
* 5. Release the lock. Expected result 5 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2. BSL_SUCCESS
* 3. BSL_SAL_ERR_BAD_PARAM
* 4. BSL_SUCCESS
* 5. Lock released successfully.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_CONDVAR_WAIT_API_TC001(void)
{
#ifndef HITLS_BSL_SAL_THREAD
SKIP_TEST();
#else
BSL_SAL_ThreadLockHandle lock = NULL;
ASSERT_TRUE(BSL_SAL_ThreadLockNew(&lock) == BSL_SUCCESS);
BSL_SAL_CondVar condVar = NULL;
int32_t ret = BSL_SAL_CreateCondVar(&condVar);
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_SAL_CondTimedwaitMs(NULL, condVar, 10);
ASSERT_TRUE(ret == BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_CondTimedwaitMs(lock, condVar, 1);
ASSERT_TRUE(ret == BSL_SAL_ERR_UNKNOWN);
ret = BSL_SAL_DeleteCondVar(condVar);
ASSERT_TRUE(ret == BSL_SUCCESS);
BSL_SAL_ThreadLockFree(lock);
EXIT:
return;
#endif
}
/* END_CASE */
#ifdef HITLS_BSL_SAL_THREAD
static BSL_SAL_CondVar g_condVar = NULL;
static pthread_mutex_t g_lock;
static void *ThreadTest(void *arg)
{
(void)arg;
int32_t ret1 = BSL_SAL_CondTimedwaitMs(&g_lock, g_condVar, 10000000);
ASSERT_TRUE(ret1 == BSL_SUCCESS);
EXIT:
return NULL;
}
#endif
/**
* @test SDV_BSL_SAL_CONDVAR_WAIT_FUNC_TC001
* @title Creating and Disabling Condition Variable Test
* @precon nan
* @brief
* 1. Call BSL_SAL_CreateCondVar to create a condition variable. Expected result 1 is obtained.
* 2. Call BSL_SAL_ThreadCreate to create the timedwait thread. Expected result 2 is obtained.
* 3. Call BSL_SAL_CondSignal to transfer normal parameters. Expected result 3 is obtained.
* 4. Call BSL_SAL_DeleteCondVar to transfer normal parameters. Expected result 4 is obtained.
* 5. Release the lock. Expected result 5 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2. BSL_SUCCESS
* 3. BSL_SUCCESS
* 4. BSL_SUCCESS
* 5. Lock released successfully.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_CONDVAR_WAIT_FUNC_TC001(void)
{
#ifndef HITLS_BSL_SAL_THREAD
SKIP_TEST();
#else
int32_t ret = BSL_SAL_CreateCondVar(&g_condVar);
ASSERT_TRUE(ret == BSL_SUCCESS);
pthread_mutex_init(&g_lock, NULL);
BSL_SAL_ThreadId thread = NULL;
ret = BSL_SAL_ThreadCreate(&thread, ThreadTest, NULL);
ASSERT_TRUE(ret == BSL_SUCCESS);
sleep(1); // Wait one seconds to send the signal
pthread_mutex_lock(&g_lock);
ret = BSL_SAL_CondSignal(g_condVar);
ASSERT_TRUE(ret == BSL_SUCCESS);
pthread_mutex_unlock(&g_lock);
BSL_SAL_ThreadClose(thread);
ret = BSL_SAL_DeleteCondVar(g_condVar);
ASSERT_TRUE(ret == BSL_SUCCESS);
pthread_mutex_destroy(&g_lock);
EXIT:
return;
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_STR_API_TC001
* @title Test on the function of inputting abnormal parameters for character string processing of the BSL module
* @precon nan
* @brief
* 1. Call BSL_SAL_StrcaseCmp to transfer abnormal parameters. Expected result 1 is obtained.
* 2. Call BSL_SAL_Memchr to transfer abnormal parameters. Expected result 2 is obtained.
* 3. Call BSL_SAL_Atoi to transfer abnormal parameters. Expected result 3 is obtained.
* 4. Call BSL_SAL_Strnlen to transfer abnormal parameters. Expected result 4 is obtained.
* @expect
* 1. BSL_NULL_INPUT
* 2. NULL
* 3. 0
* 4. 0
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_STR_API_TC001(void)
{
#ifndef HITLS_BSL_SAL_STR
SKIP_TEST();
#else
char *str1 = "aaastr1";
char *str2 = "aaastr2";
ASSERT_TRUE(BSL_SAL_StrcaseCmp(str1, NULL) == BSL_NULL_INPUT);
ASSERT_TRUE(BSL_SAL_StrcaseCmp(NULL, str2) == BSL_NULL_INPUT);
ASSERT_TRUE(BSL_SAL_Memchr(NULL, 's', 10) == NULL);
ASSERT_TRUE(BSL_SAL_Atoi(NULL) == 0);
ASSERT_TRUE(BSL_SAL_Strnlen(NULL, 0) == 0);
EXIT:
return;
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_STR_FUNC_TC001
* @title Character string processing function of the BSL module
* @precon nan
* @brief
* 1. Call BSL_SAL_StrcaseCmp to transfer normal parameters. Expected result 1 is obtained.
* 2. Call BSL_SAL_Memchr to transfer normal parameters. Expected result 2 is obtained.
* 3. Call BSL_SAL_Atoi to transfer normal parameters. Expected result 3 is obtained.
* 4. Call BSL_SAL_Strnlen to transfer normal parameters. Expected result 4 is obtained.
* @expect
* 1. String comparison succeeded.
* 2. Searching for the corresponding character succeeded.
* 3. Succeeded in converting a character string to a number.
* 4. Obtaining the length of the given string succeeded.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_STR_FUNC_TC001(void)
{
#ifndef HITLS_BSL_SAL_STR
SKIP_TEST();
#else
char *str1 = "aaastr1";
char *str2 = "aaastr2";
char *str3 = " aaastr3";
ASSERT_TRUE(BSL_SAL_StrcaseCmp(str1, str1) == 0);
ASSERT_TRUE(BSL_SAL_StrcaseCmp(str1, str2) == -1);
ASSERT_TRUE(BSL_SAL_StrcaseCmp(str2, str1) == 1);
ASSERT_TRUE(BSL_SAL_Memchr(str1, 's', strlen(str1)) != NULL);
ASSERT_TRUE(BSL_SAL_Memchr(str1, '1', 5) == NULL);
ASSERT_TRUE(BSL_SAL_Memchr(str1, '1', strlen(str1)) != NULL);
ASSERT_TRUE(BSL_SAL_Memchr(str1, 'b', strlen(str1)) == NULL);
ASSERT_TRUE(BSL_SAL_Memchr(str3, ' ', strlen(str3)) != NULL);
ASSERT_TRUE(BSL_SAL_Atoi("-100") == -100);
ASSERT_TRUE(BSL_SAL_Atoi("123") == 123);
ASSERT_TRUE(BSL_SAL_Atoi("123.456") == 123);
ASSERT_TRUE(BSL_SAL_Atoi(" 123 ") == 123);
ASSERT_TRUE(BSL_SAL_Atoi("000123") == 123);
ASSERT_TRUE(BSL_SAL_Atoi(" 1 23") == 1);
ASSERT_TRUE(BSL_SAL_Atoi("\n1 23") == 1);
ASSERT_TRUE(BSL_SAL_Atoi("1\n23") == 1);
ASSERT_TRUE(BSL_SAL_Atoi("0\n23") == 0);
ASSERT_TRUE(BSL_SAL_Strnlen(str1, strlen(str1)) == 7);
ASSERT_TRUE(BSL_SAL_Strnlen(str1, 100) == 7);
ASSERT_TRUE(BSL_SAL_Strnlen(str1, 3) == 3);
EXIT:
return;
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_THREAD_DEFAULT_FUNC_TC001
* @title Default Thread Related Functions
* @precon nan
* @brief
* 1. Unregistered thread-related callback and create a thread lock. Expected result 1 is obtained.
* 2. Create two read threads and two write threads, read and write concurrent threads,
* and obtain IDs from the threads. Expected result 2 is obtained.
* 3. Obtain the process ID and compare it with the subthread ID. Expected result 3 is obtained.
* 4. Obtain the subprocess ID and compare it with the current process ID. Expected result 4 is obtained.
* 5. Release the lock. Expected result 5 is obtained.
* @expect
* 1. Thread lock created successfully.
* 2. The read thread and write thread are successfully created.
* 3. The process ID and subthread ID are different.
* 4. The current subprocess ID is the same as the current process ID.
* 5. Lock released successfully.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_THREAD_DEFAULT_FUNC_TC001(void)
{
#ifndef HITLS_BSL_SAL_THREAD
SKIP_TEST();
#else
g_threadDefaultWrite001 = 0;
g_threadDefaultRead001 = 0;
g_threadDefaultId001 = 0;
// 1
BSL_SAL_ThreadLockHandle lock = NULL;
ASSERT_TRUE(BSL_SAL_ThreadLockNew(&lock) == BSL_SUCCESS);
// 2
BSL_SAL_ThreadId pid[TEST_WRITE_PID_CNT];
BSL_SAL_ThreadId pid2[TEST_READ_PID_CNT];
size_t i = 0;
size_t m = 0;
for (i = 0u; i < TEST_WRITE_PID_CNT; i++) {
ASSERT_TRUE(BSL_SAL_ThreadCreate(&pid[i], TEST_Write, (void *)lock) == BSL_SUCCESS);
}
for (m = 0u; m < TEST_READ_PID_CNT; m++) {
ASSERT_TRUE(BSL_SAL_ThreadCreate(&pid2[m], TEST_Read, (void *)lock) == BSL_SUCCESS);
}
for (size_t j = 0; j < i; j++) {
BSL_SAL_ThreadClose(pid[j]);
}
for (size_t n = 0; n < m; n++) {
BSL_SAL_ThreadClose(pid2[n]);
}
ASSERT_EQ(g_threadDefaultWrite001, TEST_READ_PID_CNT * TEST_THREAD_DEFAULT_TC001_WRITE_CNT);
// Concurrent reads. The read result is uncertain and does not determine whether to perform the read operation.
// 3
uint64_t mainId = BSL_SAL_ThreadGetId();
ASSERT_TRUE(mainId != g_threadDefaultId001);
// 4
uint64_t childId = 0;
pid_t pidFork = fork();
if (pidFork == 0) {
// The child process
childId = BSL_SAL_ThreadGetId();
} else {
// The parent process
goto EXIT;
}
// The default implementation uses pthread_self. Therefore, the IDs of the parent and child processes are the same.
ASSERT_EQ(childId, mainId);
EXIT:
// 5
BSL_SAL_ThreadLockFree(lock);
g_threadDefaultWrite001 = 0;
g_threadDefaultRead001 = 0;
g_threadDefaultId001 = 0;
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_CALLBACK_CTRL_FUNC_TC001
* @title test BSL_SAL_CallBack_Ctrl functions
* @precon nan
* @brief
* 1.Call BSL_SAL_CallBack_Ctrl registering file Callback Function, Expected result 1 is obtained.
* 2.Call BSL_SAL_CallBack_Ctrl registering time Callback Function, Expected result 1 is obtained.
* 3.Call BSL_SAL_CallBack_Ctrl registering net Callback Function, Expected result 1 is obtained.
* 4.Call BSL_SAL_CallBack_Ctrl registering invalid Callback Function, Expected result 2 is obtained.
* 5.Call BSL_SAL_SockGetLastSocketError obtaining the last socket error, Expected result 3 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2. BSL_SAL_ERR_NET_IOCTL
* 3. Succeeded in obtaining the last socket error.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_CALLBACK_CTRL_FUNC_TC001(void)
{
#if defined(HITLS_BSL_SAL_FILE) || defined(HITLS_BSL_SAL_TIME) || defined(HITLS_BSL_SAL_NET)
#ifdef HITLS_BSL_SAL_FILE
ASSERT_EQ(BSL_SAL_CallBack_Ctrl(BSL_SAL_FILE_OPEN_CB_FUNC, NULL), BSL_SUCCESS);
#endif
#ifdef HITLS_BSL_SAL_TIME
ASSERT_EQ(BSL_SAL_CallBack_Ctrl(BSL_SAL_TIME_GET_UTC_TIME_CB_FUNC, NULL), BSL_SUCCESS);
#endif
#ifdef HITLS_BSL_SAL_NET
ASSERT_EQ(BSL_SAL_CallBack_Ctrl(BSL_SAL_NET_WRITE_CB_FUNC, NULL), BSL_SUCCESS);
ASSERT_EQ(BSL_SAL_Ioctlsocket(0, 0, NULL), BSL_SAL_ERR_NET_IOCTL);
#endif
EXIT:
return;
#endif
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/bsl/sal/test_suite_sdv_sal.c | C | unknown | 26,808 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <unistd.h>
#include <pthread.h>
#include "bsl_sal.h"
#include "bsl_errno.h"
#include "sal_atomic.h"
#define TEST_THREAD_ATOMICADD_CNT 1000000
#define TEST_ATOMIC_ADD_PID_CNT 3
#define TEST_ATOMIC_SUB_PID_CNT 3
int g_threadStartNum = 0;
static BSL_SAL_ThreadLockHandle g_lock = NULL;
static void *TestAtomicAdd(void *arg)
{
(void)arg;
int ref = 0;
int ret = 0;
for (int i = 0; i < TEST_THREAD_ATOMICADD_CNT; i++) {
ret = BSL_SAL_AtomicAdd(&g_threadStartNum, 1, &ref, g_lock);
if (ret != BSL_SUCCESS) {
return NULL;
}
}
return NULL;
}
static void *TestAtomicSub(void *arg)
{
(void)arg;
int ref = 0;
int ret = 0;
for (int i = 0; i < TEST_THREAD_ATOMICADD_CNT; i++) {
ret = BSL_SAL_AtomicAdd(&g_threadStartNum, -1, &ref, g_lock);
if (ret != BSL_SUCCESS) {
return NULL;
}
}
return NULL;
}
/* END_HEADER */
/**
* @test SDV_BSL_SAL_ATOMIC_ADD_TC001
* @title atomic add test.
* @precon nan
* @brief
* 1. Create thread lock. Expected result 1 is obtained.
* 2. Create 3 threads to perform addition and one thread to perform subtraction. Expected result 2 is obtained.
* 3. Check whether the value after execution is consistent with the expected value. Expected result 3 is obtained.
* 4. Create 2 threads to perform subtraction. Expected result 4 is obtained.
* @expect
* 1. create success
* 2. create success
* 3. The value at the end of the thread is the same as expected.
* 4. The value at the end of the thread is the same as expected.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_ATOMIC_ADD_TC001(void)
{
ASSERT_TRUE(BSL_SAL_ThreadLockNew(&g_lock) == BSL_SUCCESS);
pthread_t pid[TEST_ATOMIC_ADD_PID_CNT];
pthread_t pid2[TEST_ATOMIC_SUB_PID_CNT];
size_t i;
for (i = 0u; i < TEST_ATOMIC_ADD_PID_CNT; i++) {
pthread_create(&pid[i], NULL, TestAtomicAdd, NULL);
}
pthread_create(&pid2[0], NULL, TestAtomicSub, NULL);
for (i = 0u; i < TEST_ATOMIC_ADD_PID_CNT; i++) {
pthread_join(pid[i], NULL);
}
pthread_join(pid2[0], NULL);
ASSERT_EQ(g_threadStartNum, (TEST_ATOMIC_ADD_PID_CNT - 1) * TEST_THREAD_ATOMICADD_CNT);
for (i = 1; i < TEST_ATOMIC_SUB_PID_CNT; i++) {
pthread_create(&pid2[i], NULL, TestAtomicSub, NULL);
}
for (i = 1; i < TEST_ATOMIC_SUB_PID_CNT; i++) {
pthread_join(pid2[i], NULL);
}
ASSERT_EQ(g_threadStartNum, 0);
EXIT:
g_threadStartNum = 0;
BSL_SAL_ThreadLockFree(g_lock);
return;
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/bsl/sal/test_suite_sdv_sal_atomic.c | C | unknown | 3,144 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_errno.h"
#include "sal_dlimpl.h"
/* END_HEADER */
/**
* @test SDV_BSL_SAL_DL_FUNC_TC001
* @title BSL SAL Provider functionality test
* @precon None
* @brief
* 1. Call BSL_SAL_LoadLib with valid inputs. Expected result 1 is obtained.
* 2. Call BSL_SAL_LoadLib with NULL filename. Expected result 2 is obtained.
* 3. Call BSL_SAL_LoadLib with NULL handle pointer. Expected result 3 is obtained.
* 4. Call BSL_SAL_LoadLib with non-existent library. Expected result 4 is obtained.
* 5. Call BSL_SAL_GetFuncAddress with valid inputs. Expected result 5 is obtained.
* 6. Call BSL_SAL_GetFuncAddress with provider lacking init function. Expected result 6 is obtained.
* 7. Call BSL_SAL_GetFuncAddress with NULL handle. Expected result 7 is obtained.
* 8. Call BSL_SAL_GetFuncAddress with NULL function pointer. Expected result 8 is obtained.
* 9. Call BSL_SAL_UnLoadLib with valid inputs. Expected result 9 is obtained.
* 10. Call BSL_SAL_UnLoadLib with NULL handle. Expected result 10 is obtained.
* @expect
* 1. BSL_SUCCESS, handle is not NULL
* 2. BSL_SAL_ERR_BAD_PARAM
* 3. BSL_SAL_ERR_BAD_PARAM
* 4. BSL_SAL_ERR_DL_NOT_FOUND
* 5. BSL_SUCCESS, function pointer is not NULL
* 6. BSL_SAL_ERR_DL_NON_FUNCTION
* 7. BSL_SAL_ERR_BAD_PARAM
* 8. BSL_SAL_ERR_BAD_PARAM
* 9. BSL_SUCCESS
* 10. BSL_SAL_ERR_BAD_PARAM
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_DL_FUNC_TC001(char *test1, char *test2, char *testNoInit, char *funcName)
{
void *handle1 = NULL;
void *handle2 = NULL;
void *handleNoInit = NULL;
void *func = NULL;
void *nonExistentLib = NULL;
int32_t ret;
// Test BSL_SAL_LoadLib with valid input
ret = BSL_SAL_LoadLib(test1, &handle1);
ASSERT_EQ(ret, BSL_SUCCESS);
ASSERT_TRUE(handle1 != NULL);
ret = BSL_SAL_LoadLib(test2, &handle2);
ASSERT_EQ(ret, BSL_SUCCESS);
ASSERT_TRUE(handle2 != NULL);
// Test BSL_SAL_LoadLib with invalid input
ret = BSL_SAL_LoadLib(NULL, &handle1);
ASSERT_EQ(ret, BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_LoadLib(test1, NULL);
ASSERT_EQ(ret, BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_LoadLib("nonExistentLib", &nonExistentLib);
ASSERT_EQ(ret, BSL_SAL_ERR_DL_NOT_FOUND);
// Test BSL_SAL_GetFuncAddress with valid input
ret = BSL_SAL_GetFuncAddress(handle1, funcName, &func);
ASSERT_EQ(ret, BSL_SUCCESS);
ASSERT_TRUE(func != NULL);
// Test BSL_SAL_GetFuncAddress with provider lacking init function
ret = BSL_SAL_LoadLib(testNoInit, &handleNoInit);
ASSERT_EQ(ret, BSL_SUCCESS);
ret = BSL_SAL_GetFuncAddress(handleNoInit, funcName, &func);
ASSERT_EQ(ret, BSL_SAL_ERR_DL_NON_FUNCTION);
// Test BSL_SAL_GetFuncAddress with invalid input
ret = BSL_SAL_GetFuncAddress(NULL, funcName, &func);
ASSERT_EQ(ret, BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_GetFuncAddress(handle1, funcName, NULL);
ASSERT_EQ(ret, BSL_SAL_ERR_BAD_PARAM);
// Test BSL_SAL_UnLoadLib with valid input
ret = BSL_SAL_UnLoadLib(handle1);
ASSERT_EQ(ret, BSL_SUCCESS);
handle1 = NULL;
ret = BSL_SAL_UnLoadLib(handle2);
ASSERT_EQ(ret, BSL_SUCCESS);
handle2 = NULL;
// Test BSL_SAL_UnLoadLib with invalid input
ret = BSL_SAL_UnLoadLib(NULL);
ASSERT_EQ(ret, BSL_SAL_ERR_BAD_PARAM);
EXIT:
if (handle1 != NULL) {
BSL_SAL_UnLoadLib(handle1);
}
if (handle2 != NULL) {
BSL_SAL_UnLoadLib(handle2);
}
if (handleNoInit != NULL) {
BSL_SAL_UnLoadLib(handleNoInit);
}
return;
}
/* END_CASE */
#define INVALID_COMMEND 5
/**
* @test SDV_BSL_SAL_CONVERTER_NAME_FUNC_TC001
* @title BSL SAL ConverterName functionality test
* @precon None
* @brief
* 1. Call BSL_SAL_LibNameFormat with valid inputs. Expected result 1 is obtained.
* 2. Call BSL_SAL_LibNameFormat with insufficient buffer size. Expected result 2 is obtained.
* 3. Call BSL_SAL_LibNameFormat with NULL filename. Expected result 3 is obtained.
* 4. Call BSL_SAL_LibNameFormat with NULL output name pointer. Expected result 4 is obtained.
* 5. Call BSL_SAL_LibNameFormat with invalid command. Expected result 5 is obtained.
* @expect
* 1. BSL_SUCCESS, converted name matches aimResult
* 2. BSL_SAL_ERR_DL_PATH_EXCEED
* 3. BSL_SAL_ERR_BAD_PARAM
* 4. BSL_SAL_ERR_BAD_PARAM
* 5. BSL_SAL_ERR_BAD_PARAM
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_CONVERTER_NAME_TC001(char *name, int cmd, char *aimResult)
{
char *convertedName = NULL;
int32_t ret;
TestMemInit();
ret = BSL_SAL_LibNameFormat(cmd, name, &convertedName);
ASSERT_EQ(ret, BSL_SUCCESS);
ASSERT_TRUE(convertedName != NULL);
ASSERT_TRUE(strcmp(convertedName, aimResult) == 0);
BSL_SAL_FREE(convertedName);
// Test with NULL inputs
ret = BSL_SAL_LibNameFormat(cmd, NULL, &convertedName);
ASSERT_EQ(ret, BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_LibNameFormat(cmd, name, NULL);
ASSERT_EQ(ret, BSL_SAL_ERR_BAD_PARAM);
// Test with invalid command
ret = BSL_SAL_LibNameFormat(INVALID_COMMEND, name, &convertedName);
ASSERT_EQ(ret, BSL_SAL_ERR_BAD_PARAM);
EXIT:
return;
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/bsl/sal/test_suite_sdv_sal_dl.c | C | unknown | 5,894 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <string.h>
#include <stdio.h>
#include "bsl_errno.h"
#include "bsl_sal.h"
#define MAX_PATH_LEN 4096
#define MAX_FILE_LEN 4096
void CreateFile(const char *fileName)
{
FILE *fp = fopen(fileName, "rb");
if (fp == NULL) {
fp = fopen(fileName, "wb");
}
fclose(fp);
}
void RemoveFile(const char *fileName)
{
remove(fileName);
}
/* END_HEADER */
static void *TestFileOpenFunc(void *args)
{
bsl_sal_file_handle stream = NULL;
char mode[] = "rb";
char path[MAX_PATH_LEN];
(void)args;
(void)strcpy(path, "");
int ret;
// 1.If the setting path is empty, the system fails to open the path, and BSL_NULL_INPUT is returned.
ret = BSL_SAL_FileOpen(&stream, path, mode);
ASSERT_EQ(ret, BSL_NULL_INPUT);
// 2.If the build does not exist, the file path fails to be opened and BSL_SAL_ERR_FILE_Open is returned.
(void)strcpy(path, "ret/sd/s.s");
ret = BSL_SAL_FileOpen(&stream, path, mode);
ASSERT_EQ(ret, BSL_SAL_ERR_FILE_OPEN);
// 3.Create a new file and open it. If the operation is successful, BSL_SUCCESS is returned.
(void)strcpy(path, "test.txt");
CreateFile(path);
ret = BSL_SAL_FileOpen(&stream, path, mode);
ASSERT_EQ(ret, BSL_SUCCESS);
BSL_SAL_FileClose(stream);
EXIT:
RemoveFile(path);
return NULL;
}
/**
* @test SDV_BSL_SAL_FILE_OPEN_FUNC_TC001
* @title Test the file opening operation.
* @precon nan
* @brief
* 1. Open the file and leave the path empty. Expected result 1 is obtained.
* 2. Open the file but the file does not exist. Expected result 2 is obtained.
* 3. Create a file and then open the file. The operation is successful. Expected result 3 is obtained.
* @expect
* 1. BSL_NULL_INPUT
* 2. BSL_SAL_ERR_FILE_OPEN
* 3. BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_FILE_OPEN_FUNC_TC001(void)
{
TestFileOpenFunc(NULL);
}
/* END_CASE */
static void *TestFileLengthFunc(void *args)
{
bsl_sal_file_handle stream = NULL;
char path[MAX_PATH_LEN];
char writeBuffer[MAX_FILE_LEN] = "we come from same country!";
char readBuffer[MAX_FILE_LEN];
int ret;
size_t len = 0;
(void)args;
(void)strcpy(path, "test.txt");
CreateFile(path);
ret = BSL_SAL_FileOpen(&stream, path, "wb");
ASSERT_EQ(ret, BSL_SUCCESS);
ret = BSL_SAL_FileWrite(stream, writeBuffer, 1, 10);
ASSERT_EQ(ret, BSL_SUCCESS);
BSL_SAL_FileClose(stream);
ret = BSL_SAL_FileOpen(&stream, path, "rb");
ASSERT_EQ(ret, BSL_SUCCESS);
ret = BSL_SAL_FileRead(stream, readBuffer, 1, 10, &len); // Reads the file content to the buffer.
ASSERT_TRUE(len > 0); // The read length is greater than 0.
ASSERT_EQ(ret, BSL_SUCCESS);
ret = BSL_SAL_FileLength(path, &len);
ASSERT_TRUE(len > 0); // The length of the existing file is greater than 0.
ASSERT_EQ(ret, BSL_SUCCESS);
EXIT:
BSL_SAL_FileClose(stream);
RemoveFile(path);
return NULL;
}
/**
* @test SDV_BSL_SAL_FILE_LENGTH_FUNC_TC001
* @title Write content to a file and obtain the file length.
* @precon nan
* @brief
* 1. Create a file. Expected result 1 is obtained.
* 2. Write data to a file. After the write operation is performed,
* perform the close operation to write the buffer data to the file. Expected result 2 is obtained.
* 3. Open the file again and read the file content. Because the file contains information,
* the read length is greater than 0. Expected result 3 is obtained.
* 4. Obtain the file length, which is greater than 0. Expected result 4 is obtained.
* @expect
* 1. File created successfully.
* 2. BSL_SUCCESS
* 3. BSL_SUCCESS
* 4. BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_FILE_LENGTH_FUNC_TC001(void)
{
TestFileLengthFunc(NULL);
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/bsl/sal/test_suite_sdv_sal_file.c | C | unknown | 4,378 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <stdbool.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/time.h>
#include "bsl_sal.h"
#include "bsl_errno.h"
#define READ_TIME_OUT_SEC 3 // 3s timeout
/* END_HEADER */
/**
* @test SDV_BSL_SAL_SOCKET_FUNC_TC001
* @title Socket-related function test
* @precon nan
* @brief
* 1. Call BSL_SAL_Socket to create a TCP socket. Expected result 1 is displayed.
* 2. Set the TCP timeout period. Expected result 2 is obtained.
* 3. Close tcp socket. Expected result 3 is obtained.
* 4. Call BSL_SAL_Socket to create a UDP socket. Expected result 4 is displayed.
* 5. Set the UDP timeout period. Expected result 5 is obtained.
* 6. Close UDP socket. Expected result 6 is obtained.
* @expect
* 1. Created successfully.
* 2. Setting successfully.
* 3. Closed successfully.
* 4. Created successfully.
* 5. Setting successfully.
* 6. Closed successfully.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_SOCKET_FUNC_TC001(void)
{
int32_t tcp = BSL_SAL_Socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
ASSERT_TRUE(tcp != -1);
struct timeval timeOut = { 0 };
timeOut.tv_sec = READ_TIME_OUT_SEC;
ASSERT_TRUE(BSL_SAL_SetSockopt(tcp, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeOut, sizeof(timeOut)) == 0);
ASSERT_TRUE(BSL_SAL_SockClose(tcp) == 0);
int32_t udp = BSL_SAL_Socket(AF_INET, SOCK_DGRAM, 0);
ASSERT_TRUE(udp != -1);
ASSERT_TRUE(BSL_SAL_SetSockopt(udp, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeOut, sizeof(timeOut)) == 0);
ASSERT_TRUE(BSL_SAL_SockClose(udp) == 0);
EXIT:
return;
}
/* END_CASE */
#ifdef HITLS_BSL_SAL_THREAD
static uint16_t GetPort()
{
uint16_t port = 8888;
char *userPort = getenv("FIXED_PORT");
if (userPort == NULL) {
const uint32_t basePort = 10000;
port = basePort + getpid();
}
return port;
}
static void *TestTcpClient(void *args)
{
(void)args;
struct sockaddr_in remoteAddr;
remoteAddr.sin_family = AF_INET;
remoteAddr.sin_port = htons(GetPort());
remoteAddr.sin_addr.s_addr = htonl(INADDR_ANY);
int32_t socketRemote = BSL_SAL_Socket(AF_INET, SOCK_STREAM, 0);
ASSERT_TRUE(socketRemote != -1);
while(true) {
int32_t ret = BSL_SAL_SockConnect(socketRemote, (BSL_SAL_SockAddr)&remoteAddr, sizeof(remoteAddr));
if (ret == 0) {
char *msg = "Hello,TCP!!";
ASSERT_TRUE(BSL_SAL_SockSend(socketRemote, msg, strlen(msg), 0) >= 0);
goto EXIT;
}
ASSERT_TRUE(BSL_SAL_SockGetLastSocketError() != 0);
}
EXIT:
BSL_SAL_SockClose(socketRemote);
return NULL;
}
static void *TestTcpServer(void *args)
{
(void)args;
uint8_t buff[32] = {0};
int serConn = -1;
struct sockaddr_in localAddr = {0};
struct sockaddr_in cliAddr = {0};
localAddr.sin_family = AF_INET;
localAddr.sin_port = htons(GetPort());
localAddr.sin_addr.s_addr = htonl(INADDR_ANY);
int32_t socketLocal = BSL_SAL_Socket(AF_INET, SOCK_STREAM, 0);
ASSERT_TRUE(socketLocal != -1);
ASSERT_TRUE(BSL_SAL_SockBind(socketLocal, (BSL_SAL_SockAddr)&localAddr, sizeof(localAddr)) == 0);
ASSERT_TRUE(BSL_SAL_SockListen(socketLocal, 5) == 0);
socklen_t len = sizeof(cliAddr);
serConn = accept(socketLocal, (struct sockaddr *)&cliAddr, &len);
ASSERT_TRUE(serConn != -1);
while(true) {
if (BSL_SAL_SockRecv(serConn, buff, 32, 0) > 0) {
goto EXIT;
}
ASSERT_TRUE(BSL_SAL_SockGetLastSocketError() != 0);
}
EXIT:
BSL_SAL_SockClose(socketLocal);
BSL_SAL_SockClose(serConn);
return NULL;
}
#endif
/**
* @test SDV_BSL_SAL_SOCKET_FUNC_TC002
* @title Socket-related function test
* @precon nan
* @brief
* 1. Creating a TCP Server. Expected result 1 is obtained.
* 2. Creating a TCP Client. Expected result 2 is obtained.
* @expect
* 1. Created successfully.
* 2. Created successfully.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_SOCKET_FUNC_TC002(void)
{
#ifndef HITLS_BSL_SAL_THREAD
SKIP_TEST();
#else
BSL_SAL_ThreadId serverThread = NULL;
ASSERT_EQ(BSL_SAL_ThreadCreate(&serverThread, TestTcpServer, NULL), BSL_SUCCESS);
BSL_SAL_ThreadId clientThread = NULL;
ASSERT_EQ(BSL_SAL_ThreadCreate(&clientThread, TestTcpClient, NULL), BSL_SUCCESS);
EXIT:
BSL_SAL_ThreadClose(serverThread);
BSL_SAL_ThreadClose(clientThread);
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_SELECT_FUNC_TC001
* @title Socket-related function test
* @precon nan
* @brief
* 1. Open the /dev/urandom file only. Expected result 1 is obtained.
* 2. Call BSL_SAL_Select to check the number of open read-only descriptors.
Expected result 2 is obtained.
* @expect
* 1. Opened successfully.
* 2. Read-only descriptor open count is greater than 0
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_SELECT_FUNC_TC001(void)
{
const char *path = "/dev/urandom";
int fd = open(path, O_RDONLY);
ASSERT_TRUE(fd != -1);
fd_set fds;
FD_ZERO(&fds);
FD_SET(fd, &fds);
struct timeval tv;
tv.tv_sec = 2;
tv.tv_usec = 0;
ASSERT_TRUE(BSL_SAL_Select(fd + 1, &fds, NULL, NULL, &tv) > 0);
EXIT:
close(fd);
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/bsl/sal/test_suite_sdv_sal_socket.c | C | unknown | 5,950 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <unistd.h>
#include <sys/time.h>
#include <time.h>
#include <sys/times.h>
#include "bsl_sal.h"
#include "sal_time.h"
#include "bsl_errno.h"
static int64_t TestBslSysTimeFunc(void)
{
return (time_t)1;
}
static int64_t TestBslSysTimeFunc1(void)
{
return time(NULL);
}
static void TestBslSysTimeInit(BSL_TIME *dateTime)
{
dateTime->year = 1990;
dateTime->month = 6;
dateTime->day = 12;
dateTime->hour = 10;
dateTime->minute = 3;
dateTime->microSec = 1;
dateTime->millSec = 1;
}
static void TestBslSysTimeAndTmCompare(BSL_TIME *dateTime, struct tm *tempTime)
{
ASSERT_EQ(dateTime->year, tempTime->tm_year + 1900); /* 1900 is base year */
ASSERT_EQ(dateTime->month, tempTime->tm_mon + 1U);
ASSERT_EQ(dateTime->day, tempTime->tm_mday);
ASSERT_EQ(dateTime->hour, tempTime->tm_hour);
ASSERT_EQ(dateTime->minute, tempTime->tm_min);
ASSERT_EQ(dateTime->second, tempTime->tm_sec);
EXIT:
return;
}
/* END_HEADER */
/**
* @test SDV_BSL_TIME_FUNC_GET_DATETIME_TC001
* @title Function test of obtaining the date as a character string.
* @precon
* @brief 1.The input parameter dateTime, timeStr, or len is invalid (less than the storage length).
* 2.Invalid time.
* 3.The time is legal.
* @expect 1.Fail, return BSL_ERR
* 2.Fail, return BSL_ERR
* 3.Success, return BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_TIME_FUNC_GET_DATETIME_TC001(void)
{
BSL_TIME dateTime = {0};
char timeStr[26];
timeStr[0] = '\0';
dateTime.year = BSL_TIME_SYSTEM_EPOCH_YEAR;
dateTime.month = 1;
dateTime.day = 1;
dateTime.hour = 0;
dateTime.minute = 0;
dateTime.second = 0;
/* 1.The input parameter dateaTime or timeStr is invalid. */
ASSERT_EQ(BSL_DateToStrConvert(NULL, timeStr, 26), (uint32_t)BSL_INTERNAL_EXCEPTION);
ASSERT_EQ(BSL_DateToStrConvert(&dateTime, NULL, 26), (uint32_t)BSL_INTERNAL_EXCEPTION);
/* 2.Invalid time. */
dateTime.month = 13;
ASSERT_EQ(BSL_DateToStrConvert(&dateTime, timeStr, 26), (uint32_t)BSL_INTERNAL_EXCEPTION);
dateTime.month = 1;
/* 3.The time is legal. */
ASSERT_EQ(BSL_DateToStrConvert(&dateTime, timeStr, 26), (uint32_t)BSL_SUCCESS);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_TIME_FUNC_REGISTER_TC001
* @title Obtaining the current system time
* @precon
* @brief
* 1. Registering System Time Hooks, obtain the Unix time. Expected result 1 is obtained.
* 2. Unregistered system time hook, Obtain the Unix time. Expected result 2 is obtained.
* 3. Unregister System Time Hook, Obtain the Unix time. Expected result 3 is obtained.
* @expect
* 1. The operation is successful, 0 is returned.
* 2. The operation is successful, 0 is returned. The hook has not changed
* 3. The operation is successful, a non-zero value is returned.
*/
/* BEGIN_CASE */
void SDV_BSL_TIME_FUNC_REGISTER_TC001(void)
{
/* 1.Registering System Time Hooks */
BSL_SAL_SysTimeFuncReg(TestBslSysTimeFunc);
ASSERT_EQ(BSL_SAL_CurrentSysTimeGet(), 1);
/* 2.Unregistered system time hook */
BSL_SAL_SysTimeFuncReg(NULL);
ASSERT_EQ(BSL_SAL_CurrentSysTimeGet(), 1);
BSL_SysTimeFuncUnReg();
ASSERT_NE(BSL_SAL_CurrentSysTimeGet(), 1);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_TIME_CMP_TIME_API_TC001
* @title Time comparison function test
* @precon
* @brief
* 1. The existence time is invalid. Expected result 1 is obtained.
* 2. The two dates are consistent. Expected result 2 is obtained.
* 3. The first date is before the second date. Expected result 3 is obtained.
* 4. The first date is after the second. Expected result 3 is obtained.
* @expect
* 1. Fail, return BSL_TIME_CMP_ERROR
* 2. Success, return BSL_TIME_CMP_EQUAL
* 3. Success, return BSL_TIME_DATE_BEFORE
* 4. Success, return BSL_TIME_DATE_AFTER
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_TIME_CMP_TIME_API_TC001(void)
{
int64_t diffSec;
BSL_TIME dateA = {0};
BSL_TIME dateB = {0};
dateA.year = BSL_TIME_SYSTEM_EPOCH_YEAR;
dateA.month = 1;
dateA.day = 1;
dateB.year = BSL_TIME_SYSTEM_EPOCH_YEAR;
dateB.month = 1;
dateB.day = 1;
/* 1.The existence time is invalid */
ASSERT_EQ(BSL_SAL_DateTimeCompare(NULL, &dateB, &diffSec), BSL_TIME_CMP_ERROR);
/* 2.The two dates are consistent */
ASSERT_EQ(BSL_SAL_DateTimeCompare(&dateA, &dateB, &diffSec), BSL_TIME_CMP_EQUAL);
ASSERT_EQ(diffSec, 0);
/* 3.The first date is before the second date */
dateB.second = 1;
ASSERT_EQ(BSL_SAL_DateTimeCompare(&dateA, &dateB, &diffSec), BSL_TIME_DATE_BEFORE);
ASSERT_EQ(diffSec, -1);
dateB.second = 0;
/* 4.The first date is after the second */
dateA.second = 1;
ASSERT_EQ(BSL_SAL_DateTimeCompare(&dateA, &dateB, &diffSec), BSL_TIME_DATE_AFTER);
ASSERT_EQ(diffSec, 1);
dateA.second = 0;
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_TIME_CMP_TIME_API_TC002
* @title Time comparison function test
* @precon
* @brief
* 1. The existence time is invalid. Expected result 1 is obtained.
* 2. The two dates are consistent. Expected result 2 is obtained.
* 3. The first date is before the second date. Expected result 3 is obtained.
* 4. The first date is after the second. Expected result 3 is obtained.
* @expect
* 1. Fail, return BSL_TIME_CMP_ERROR
* 2. Success, return BSL_TIME_CMP_EQUAL
* 3. Success, return BSL_TIME_DATE_BEFORE
* 4. Success, return BSL_TIME_DATE_AFTER
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_TIME_CMP_TIME_API_TC002(void)
{
BSL_TIME dateA = {0};
BSL_TIME dateB = {0};
dateA.year = BSL_TIME_SYSTEM_EPOCH_YEAR;
dateA.month = 1;
dateA.day = 1;
dateA.millSec = 2;
dateA.microSec = 3;
dateB.year = BSL_TIME_SYSTEM_EPOCH_YEAR;
dateB.month = 1;
dateB.day = 1;
dateB.millSec = 2;
dateB.microSec = 3;
/* 1.The existence time is invalid. */
ASSERT_EQ(BSL_SAL_DateTimeCompareByUs(NULL, &dateB), BSL_TIME_CMP_ERROR);
/* 2.The two dates are consistent. */
ASSERT_EQ(BSL_SAL_DateTimeCompareByUs(&dateA, &dateB), BSL_TIME_CMP_EQUAL);
/* 3.The first date is before the second date. */
dateB.millSec = 1;
ASSERT_EQ(BSL_SAL_DateTimeCompareByUs(&dateA, &dateB), BSL_TIME_DATE_AFTER);
dateB.millSec = 2;
/* 4.The first date is after the second */
dateA.microSec = 1;
ASSERT_EQ(BSL_SAL_DateTimeCompareByUs(&dateA, &dateB), BSL_TIME_DATE_BEFORE);
dateA.microSec = 0;
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_TIME_SYSTIME_API_TC001
* @title Obtaining the System Time
* @precon
* @brief
* 1. Call BSL_SAL_SysTimeGet to transfer the NULL parameter. Expected result 1 is obtained.
* 2. Call BSL_SAL_SysTimeGet to transfer the normal parameter. Expected result 2 is obtained.
* @expect
* 1. Return BSL_SAL_ERR_BAD_PARAM.
* 2. The obtained time is the same as the expected value. Return BSL_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_BSL_TIME_SYSTIME_API_TC001(void)
{
BSL_TIME systime;
uint32_t ret;
/* The time obtaining interface is registered as time. */
BSL_SAL_SysTimeFuncReg(TestBslSysTimeFunc1);
ret = BSL_SAL_SysTimeGet(NULL);
ASSERT_EQ(ret, BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_SysTimeGet(&systime);
ASSERT_TRUE(ret == BSL_SUCCESS);
/* Get the current time. */
int64_t curtime = time(NULL);
int64_t timestamp = 0;
ret = BSL_SAL_DateToUtcTimeConvert(&systime, ×tamp);
ASSERT_LT(abs((int)(curtime - timestamp)), 5);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_TIME_CONVERT_TIME_FUNC_TC001
* @title UTC time conversion
* @precon
* @brief
* 1. Call BSL_SAL_DateToUtcTimeConvert to transfer the NULL parameter. Expected result 1 is obtained.
* 2. Call BSL_SAL_DateToUtcTimeConvert to transfer an exception parameter. Expected result 1 is obtained.
* 3. Call BSL_SAL_DateToUtcTimeConvert to transfer normal parameters. Expected result 2 is obtained.
* @expect
* 1. Fail, return BSL_ERR
* 2. Fail, return BSL_ERR
* 3. Success, return BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_TIME_CONVERT_TIME_FUNC_TC001(void)
{
int64_t utcTime;
BSL_TIME dateTime = {0};
/* 1.The input parameter dateTime or utcTime is empty. */
ASSERT_TRUE(BSL_SAL_DateToUtcTimeConvert(NULL, &utcTime) == BSL_INTERNAL_EXCEPTION);
ASSERT_TRUE(BSL_SAL_DateToUtcTimeConvert(&dateTime, NULL) == BSL_INTERNAL_EXCEPTION);
/* 2.Failed to convert the time. */
ASSERT_TRUE(BSL_SAL_DateToUtcTimeConvert(&dateTime, &utcTime) != BSL_SUCCESS);
/* 3.Time conversion succeeded. */
dateTime.year = BSL_TIME_SYSTEM_EPOCH_YEAR;
dateTime.month = 1;
dateTime.day = 1;
dateTime.hour = 0;
dateTime.minute = 0;
dateTime.second = 0;
ASSERT_TRUE(BSL_SAL_DateToUtcTimeConvert(&dateTime, &utcTime) == (uint32_t)BSL_SUCCESS);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_CONVERT_TIME_API_TC002
* @title Converting BslSysTime to BslUnixTime
* @precon
* @brief
* 1. The value of utcTime is 0. Expected result 1 is obtained.
* 2. The value of utcTime is a negative number. Expected result 2 is obtained.
* 3. The value of utcTime is INT32_MAX - 1. Expected result 3 is obtained.
* 4. The value of utcTime is INT32_MAX. Expected result 4 is obtained.
* 5. The value of utcTime is INT32_MAX + 1. Expected result 5 is obtained.
* 6. The value of utcTime is BSL_UTCTIME_MAX. Expected result 6 is obtained.
* @expect
* 1. Success, return BSL_SUCCESS
* 2. Success, return BSL_SUCCESS
* 3. Success, return BSL_SUCCESS
* 4. Success, return BSL_SUCCESS
* 5. Success, return BSL_SUCCESS
* 6. Success, return BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_CONVERT_TIME_API_TC001(void)
{
int64_t utcTime;
BSL_TIME dateTime = {0};
struct tm tempTime;
utcTime = 0;
ASSERT_TRUE(BSL_SAL_UtcTimeToDateConvert(utcTime, &dateTime) == BSL_SUCCESS);
ASSERT_TRUE(gmtime_r((const time_t *)&utcTime, &tempTime) != NULL);
TestBslSysTimeAndTmCompare(&dateTime, &tempTime);
utcTime = -1;
ASSERT_TRUE(BSL_SAL_UtcTimeToDateConvert(utcTime, &dateTime) == BSL_SUCCESS);
ASSERT_TRUE(gmtime_r((const time_t *)&utcTime, &tempTime) != NULL);
TestBslSysTimeAndTmCompare(&dateTime, &tempTime);
utcTime = INT32_MAX;
ASSERT_TRUE(BSL_SAL_UtcTimeToDateConvert(utcTime, &dateTime) == BSL_SUCCESS);
ASSERT_TRUE(gmtime_r((const time_t *)&utcTime, &tempTime) != NULL);
TestBslSysTimeAndTmCompare(&dateTime, &tempTime);
utcTime = INT32_MAX - 1;
ASSERT_TRUE(BSL_SAL_UtcTimeToDateConvert(utcTime, &dateTime) == BSL_SUCCESS);
ASSERT_TRUE(gmtime_r((const time_t *)&utcTime, &tempTime) != NULL);
TestBslSysTimeAndTmCompare(&dateTime, &tempTime);
utcTime = (int64_t)INT32_MAX + 1;
ASSERT_TRUE(BSL_SAL_UtcTimeToDateConvert(utcTime, &dateTime) == BSL_SUCCESS);
ASSERT_TRUE(gmtime_r((const time_t *)&utcTime, &tempTime) != NULL);
TestBslSysTimeAndTmCompare(&dateTime, &tempTime);
utcTime = BSL_UTCTIME_MAX;
ASSERT_TRUE(BSL_SAL_UtcTimeToDateConvert(utcTime, &dateTime) == BSL_SUCCESS);
ASSERT_TRUE(gmtime_r((const time_t *)&utcTime, &tempTime) != NULL);
TestBslSysTimeAndTmCompare(&dateTime, &tempTime);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_TIME_FUNC_DATETIME_CHECK_TC001
* @title BSL_DateTimeCheck the test of the year
* @precon nan
* @brief
* 1.Year illegal (<1970). Expected result 1 is obtained.
* 2.Year legal (1990). Expected result 2 is obtained.
* @expect
* 1.Return false
* 2.Return true
*/
/* BEGIN_CASE */
void SDV_BSL_TIME_DATETIME_CHECK_FUNC_TC001(void)
{
bool ret;
BSL_TIME dateTime = {0};
TestBslSysTimeInit(&dateTime);
/* 1.Year illegal (<1970) */
dateTime.year = 1969;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 2.Year legal (=1970) */
dateTime.year = 1970;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_TIME_FUNC_DATETIME_CHECK_TC002
* @title BSL_DateTimeCheck the test of the month
* @precon nan
* @brief
* 1.Month illegal (== 0 or > 12). Expected result 1 is obtained.
* 2.Month legal (== 1 or == 12). Expected result 2 is obtained.
* @expect
* 1.Return false
* 2.Return true
*/
/* BEGIN_CASE */
void SDV_BSL_TIME_DATETIME_CHECK_FUNC_TC002(void)
{
bool ret;
BSL_TIME dateTime = {0};
TestBslSysTimeInit(&dateTime);
/* 1.Month illegal (== 0 or > 12) */
dateTime.month = 0;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
dateTime.month = 13;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 2.Month legal (== 1 or == 12) */
dateTime.month = 1;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
dateTime.month = 12;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_TIME_FUNC_DATETIME_CHECK_TC003
* @title BSL_DateTimeCheck the test of the day
* @precon
* @brief
* 1.Day illegal (== 0). Expected result 1 is obtained.
* 2.Day legal (== 1). Expected result 2 is obtained.
* 3.Day illegal (More than 28 days in February). Expected result 3 is obtained.
* 4.Day legal (February equals 28 days). Expected result 4 is obtained.
* 5.Day illegal (More than 31 days in January). Expected result 5 is obtained.
* 6.Day legal (January equals 31 days). Expected result 6 is obtained.
* 7.Day illegal (More than 30 in April). Expected result 7 is obtained.
* 8.Day legal (April equals 30 days). Expected result 8 is obtained.
* 9.Day illegal (Leap year February greater than 29 days). Expected result 9 is obtained.
* 10.Day legal (Leap year February equals 29 days). Expected result 10 is obtained.
* @expect
* 1.Return false
* 2.Return true
* 3.Return false
* 4.Return true
* 5.Return false
* 6.Return true
* 7.Return false
* 8.Return true
* 9.Return false
* 10.Return true
*/
/* BEGIN_CASE */
void SDV_BSL_TIME_DATETIME_CHECK_FUNC_TC003(void)
{
bool ret;
BSL_TIME dateTime = {0};
TestBslSysTimeInit(&dateTime);
/* 1.Day illegal (== 0) */
dateTime.day = 0;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 2.Day legal (== 1) */
dateTime.day = 1;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
/* 3.Day illegal (More than 28 days in February) */
dateTime.month = 2;
dateTime.day = 29;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 4.Day legal (February equals 28 days) */
dateTime.month = 2;
dateTime.day = 28;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
/* 5.Day illegal (More than 31 days in January) */
dateTime.month = 1;
dateTime.day = 32;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 6.Day legal (January equals 31 days) */
dateTime.month = 1;
dateTime.day = 31;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
/* 7.Day illegal (More than 30 days in April) */
dateTime.month = 4;
dateTime.day = 31;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 8.Day legal (April equals 30 days) */
dateTime.month = 4;
dateTime.day = 30;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
/* 9.Day illegal (Leap year February greater than 29) */
dateTime.year = 2020;
dateTime.month = 2;
dateTime.day = 30;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 10.Day legal (Leap year February equals 29) */
dateTime.year = 2020;
dateTime.month = 2;
dateTime.day = 29;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_TIME_FUNC_DATETIME_CHECK_TC004
* @title BSL_DateTimeCheck hour minute second test
* @precon nan
* @brief
* 1. hour is illegal ( > 23). Expected result 1 is obtained.
* 2. hour is legal ( == 23). Expected result 2 is obtained.
* 3. minute is illegal ( > 59). Expected result 3 is obtained.
* 4. minute is legal ( == 59). Expected result 4 is obtained.
* 5. second is illegal( > 59). Expected result 5 is obtained.
* 6. second is legal ( == 59). Expected result 6 is obtained.
* 7. millisecond is illegal ( > 999). Expected result 7 is obtained.
* 8. millisecond is legal ( == 999). Expected result 8 is obtained.
* 9. call BSL_DateToStrConvert to convert legal time. Expected result 9 is obtained.
* @expect
* 1. Return false
* 2. Return true
* 3. Return false
* 4. Return true
* 5. Return false
* 6. Return true
* 7. Return false
* 8. Return true
* 9. Return BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_TIME_DATETIME_CHECK_FUNC_TC004(void)
{
bool ret;
BSL_TIME dateTime = {0};
TestBslSysTimeInit(&dateTime);
/* 1.hour is illegal ( > 23) */
dateTime.hour = 24;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 2.hour is legal ( == 23) */
dateTime.hour = 23;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
/* 3.minute is illegal ( > 59) */
dateTime.minute = 60;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 4.minute is legal ( == 59) */
dateTime.minute = 59;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
/* 5.second is illegal ( > 59) */
dateTime.second = 60;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 6.second is legal ( == 59) */
dateTime.second = 59;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
/* 7.millisecond is illegal ( > 999) */
dateTime.millSec = 1000;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 8.millisecond is legal ( == 999) */
dateTime.millSec = 59;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
char buf[256] = {0};
ASSERT_EQ(BSL_DateToStrConvert(&dateTime, buf, 256), BSL_SUCCESS);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_TIME_FUNC_TICK_TC001
* @title Test of functions related to the number of ticks in the system
* @precon
* @brief
* 1. Call BSL_SAL_Tick to obtain the number of ticks that the system has experienced since startup.
* Expected result 1 is obtained.
* 2. Call BSL_SAL_TicksPerSec to obtain the number of system ticks per second. Expected result 2 is obtained.
* @expect
* 1. Succeeded in obtaining the number of ticks that have been experienced since the system is started.
* 2. Succeeded in obtaining the number of system ticks per second.
*/
/* BEGIN_CASE */
void SDV_BSL_TIME_FUNC_TICK_TC001(void)
{
long res = BSL_SAL_Tick();
ASSERT_TRUE(res != 0);
res = BSL_SAL_TicksPerSec();
ASSERT_EQ(res, sysconf(_SC_CLK_TCK));
BSL_SAL_Sleep(1);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_TIME_ADD_TIME_TC001
* @title Time comparison function test.
* @tprecon
* @brief 1.Adding succeeded.
* 2.The two dates are consistent.
* 3.One of them is empty. Adding failed.
* @texpect 1.Sucessful, return BSL_SUCCESS
* 2.Sucessful, return BSL_TIME_CMP_EQUAL
* 3.Fail, return BSL_ERR
*/
/* BEGIN_CASE */
void SDV_BSL_TIME_ADD_TIME_TC001(void)
{
BSL_TIME dateA = {0};
BSL_TIME dateB = {0};
BSL_TIME dateC = {0};
dateA.year = BSL_TIME_SYSTEM_EPOCH_YEAR;
dateA.month = 1;
dateA.day = 1;
dateA.millSec = 1;
dateB.year = BSL_TIME_SYSTEM_EPOCH_YEAR;
dateB.month = 2;
dateB.day = 1;
dateB.millSec = 2;
dateC.year = BSL_TIME_SYSTEM_EPOCH_YEAR;
dateC.month = 1;
dateC.day = 1;
dateC.millSec = 3;
/* Dates add up */
ASSERT_TRUE(BSL_DateTimeAddUs(&dateA, &dateC, 0) == BSL_SUCCESS);
/* 2.Comparison of two dates */
ASSERT_NE(BSL_SAL_DateTimeCompareByUs(&dateA, &dateB), BSL_TIME_CMP_EQUAL);
ASSERT_EQ(BSL_SAL_DateTimeCompareByUs(&dateA, &dateC), BSL_TIME_CMP_EQUAL);
/* Exceptions */
ASSERT_TRUE(BSL_DateTimeAddUs(&dateA, NULL, 0) == BSL_INTERNAL_EXCEPTION);
EXIT:
return;
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/bsl/sal/test_suite_sdv_sal_time.c | C | unknown | 20,963 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "tlv.h"
#include "bsl_errno.h"
/* END_HEADER */
/**
* @test SDV_BSL_TLV_Find_API_TC001
* @title Find tlv value pos test
* @precon nan
* @brief
* 1. Invoke BSL_TLV_Pack to construct a tlv buffer. Expected result 1 is obtained.
* 2. Invoke BSL_TLV_FindValuePos to find a type which valid. Expected result 2 is obtained.
* 3. Invoke BSL_TLV_FindValuePos to find a type which invalid. Expected result 3 is obtained.
* @expect
* 1. Expected success
* 2. Expected success
* 3. Expected failure
*/
/* BEGIN_CASE */
void SDV_BSL_TLV_Find_API_TC001(void)
{
int ret;
uint32_t type = 0x0101;
uint16_t version = 1;
BSL_Tlv tlv = {0};
tlv.type = type;
tlv.length = sizeof(version);
tlv.value = (uint8_t *)&version;
uint32_t encLen = 0;
uint8_t data[1024] = {0};
ret = BSL_TLV_Pack(&tlv, data, sizeof(data), &encLen);
ASSERT_TRUE(ret == BSL_SUCCESS);
uint32_t offset = 0;
uint32_t length = 0;
ret = BSL_TLV_FindValuePos(type, data, encLen, &offset, &length);
ASSERT_TRUE(ret == BSL_SUCCESS);
uint32_t invalidType = 0x0102;
ret = BSL_TLV_FindValuePos(invalidType, data, encLen, &offset, &length);
ASSERT_TRUE(ret == BSL_TLV_ERR_NO_WANT_TYPE);
EXIT:
return;
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/bsl/tlv/test_suite_sdv_tlv.c | C | unknown | 1,846 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/select.h>
#include <sys/time.h>
#include <linux/ioctl.h>
#include "securec.h"
#include "stub_replace.h"
#include "bsl_sal.h"
#include "sal_net.h"
#include "bsl_errno.h"
#include "bsl_uio.h"
#include "uio_base.h"
#include "sal_atomic.h"
#include "uio_abstraction.h"
/* END_HEADER */
#define MAX_BUF_SIZE 255
#define IP_V4_LEN 4
#define IP_V6_LEN 16
static int32_t g_writeRet;
static uint32_t g_writeLen;
static int32_t STUB_Write(BSL_UIO *uio, const void *buf, uint32_t len, uint32_t *writeLen)
{
(void)uio;
(void)buf;
(void)len;
*writeLen = g_writeLen;
return g_writeRet;
}
static int32_t g_readRet;
static uint32_t g_readLen;
static int32_t STUB_Read(BSL_UIO *uio, void *buf, uint32_t len, uint32_t *readLen)
{
(void)uio;
(void)buf;
(void)len;
*readLen = g_readLen;
return g_readRet;
}
static int32_t g_ctrlRet1;
static int32_t g_ctrlRet2;
static int32_t g_ctrlRet3;
static BSL_UIO_CtrlParameter g_ctrlCmd1;
static BSL_UIO_CtrlParameter g_ctrlCmd2;
static BSL_UIO_CtrlParameter g_ctrlCmd3;
static uint16_t g_shareKeyId;
static uint16_t g_delShareKeyId;
static uint8_t g_isEmpty;
static int32_t STUB_Ctrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *param)
{
(void)larg;
(void)uio;
(void)param;
if (cmd == BSL_UIO_SCTP_ADD_AUTH_SHARED_KEY) {
BSL_UIO_SctpAuthKey *key = (BSL_UIO_SctpAuthKey *)param;
g_shareKeyId = key->shareKeyId;
}
if (cmd == BSL_UIO_SCTP_DEL_PRE_AUTH_SHARED_KEY) {
g_delShareKeyId = *(uint16_t*)param;
}
if (cmd == BSL_UIO_SCTP_SND_BUFF_IS_EMPTY) {
*(uint8_t *)param = g_isEmpty;
}
if ((int32_t)g_ctrlCmd1 == cmd) {
return g_ctrlRet1;
}
if ((int32_t)g_ctrlCmd2 == cmd) {
return g_ctrlRet2;
}
if ((int32_t)g_ctrlCmd3 == cmd) {
return g_ctrlRet3;
}
return BSL_UIO_FAIL;
}
const BSL_UIO_Method * GetUioMethodByType(int uioType)
{
switch (uioType) {
#ifdef HITLS_BSL_UIO_TCP
case BSL_UIO_TCP:
return BSL_UIO_TcpMethod();
#endif
#ifdef HITLS_BSL_UIO_UDP
case BSL_UIO_UDP:
return BSL_UIO_UdpMethod();
#endif
#ifdef HITLS_BSL_UIO_MEM
case BSL_UIO_MEM:
return BSL_UIO_MemMethod();
#endif
case BSL_UIO_BUFFER:
return BSL_UIO_BufferMethod();
default:
return NULL;
}
}
typedef struct {
int32_t len;
uint8_t index;
uint8_t *buff;
} CustomLowCtx;
static int32_t BslUioCreate(BSL_UIO *uio)
{
int32_t len = 20;
int32_t ret;
CustomLowCtx *lowCtx = BSL_SAL_Calloc(1, sizeof(CustomLowCtx));
if (lowCtx == NULL) {
ret = BSL_MALLOC_FAIL;
goto EXIT;
}
lowCtx->buff = BSL_SAL_Malloc(len);
if (lowCtx->buff == NULL) {
ret = BSL_MALLOC_FAIL;
goto EXIT;
}
lowCtx->len = len;
BSL_UIO_SetCtx(uio, (void *)lowCtx);
BSL_UIO_SetInit(uio, 1);
return BSL_SUCCESS;
EXIT:
if(lowCtx != NULL) {
BSL_SAL_FREE(lowCtx->buff);
BSL_SAL_FREE(lowCtx);
}
return ret;
}
static int32_t BslUioDestroy(BSL_UIO *uio)
{
CustomLowCtx *lowCtx = BSL_UIO_GetCtx(uio);
if (lowCtx == NULL) {
return BSL_INVALID_ARG;
}
BSL_SAL_FREE(lowCtx->buff);
BSL_SAL_FREE(lowCtx);
BSL_UIO_SetCtx(uio, NULL);
return BSL_SUCCESS;
}
static int32_t BslUioWrite(BSL_UIO *uio, const void *buf, uint32_t len, uint32_t *writeLen)
{
CustomLowCtx *lowCtx = BSL_UIO_GetCtx(uio);
if (lowCtx == NULL) {
return BSL_INVALID_ARG;
}
uint32_t reslen = lowCtx->len - lowCtx->index;
if (reslen < len) {
return BSL_INVALID_ARG;
}
memcpy_s(lowCtx->buff + lowCtx->index, len, buf, len);
lowCtx->index += len;
*writeLen = len;
return BSL_SUCCESS;
}
static int32_t BslUioRead(BSL_UIO *uio, void *buf, uint32_t len, uint32_t *readLen)
{
CustomLowCtx *lowCtx = BSL_UIO_GetCtx(uio);
if (lowCtx == NULL) {
return BSL_INVALID_ARG;
}
if (lowCtx->index == 0) {
return BSL_INVALID_ARG;
}
int copyLen = (lowCtx->index > len) ? len : lowCtx->index;
(void)memcpy_s(buf, copyLen, lowCtx->buff, copyLen);
*readLen = copyLen;
lowCtx->index -= copyLen;
return BSL_SUCCESS;
}
#define BSL_CUSTOM_UIO_GET_INDEX 0x100
static int32_t BslUioCtrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *parg)
{
(void)larg;
CustomLowCtx *lowCtx = BSL_UIO_GetCtx(uio);
if (lowCtx == NULL) {
return BSL_INVALID_ARG;
}
if (cmd == BSL_CUSTOM_UIO_GET_INDEX) {
*(uint32_t *)parg = lowCtx->index;
return BSL_SUCCESS;
}
return BSL_INVALID_ARG;
}
static int32_t BslUioPuts(BSL_UIO *uio, const char *buf, uint32_t *writeLen)
{
(void) uio;
(void) buf;
(void) writeLen;
return BSL_INVALID_ARG;
}
static int32_t BslUioGets(BSL_UIO *uio, char *buf, uint32_t *readLen)
{
(void) uio;
(void) buf;
(void) readLen;
return BSL_INVALID_ARG;
}
/**
* @test SDV_BSL_UIO_NEW_API_TC001
* @title Input parameter test
* @precon nan
* @brief
* 1. Construct the tcp/sctp/udp method structure, and invoke BSL_UIO_New.
* 2. Invoke the BSL_UIO_GetTransportType interface.
* @expect
* 1. Expected the uio is not NULL, and transport type is the target type
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_NEW_API_TC001(void)
{
#if defined(HITLS_BSL_UIO_TCP) || defined(HITLS_BSL_UIO_UDP)
TestMemInit();
/* Set method to NULL */
BSL_UIO *uio = BSL_UIO_New(NULL);
ASSERT_TRUE(uio == NULL);
#ifdef HITLS_BSL_UIO_TCP
/* Set transportType to tcp and construct the method structure. */
{
const BSL_UIO_Method *ori = BSL_UIO_TcpMethod();
BSL_UIO_Method method = {0};
memcpy(&method, ori, sizeof(method));
method.uioWrite = STUB_Write;
method.uioRead = STUB_Read;
method.uioCtrl = STUB_Ctrl;
uio = BSL_UIO_New(&method);
ASSERT_TRUE(uio != NULL && BSL_UIO_GetTransportType(uio) == BSL_UIO_TCP);
BSL_UIO_Free(uio);
}
#endif
#ifdef HITLS_BSL_UIO_UDP
/* Set transportType to udp and construct the method structure. */
{
const BSL_UIO_Method *ori = BSL_UIO_UdpMethod();
BSL_UIO_Method method = {0};
memcpy(&method, ori, sizeof(method));
method.uioWrite = STUB_Write;
method.uioRead = STUB_Read;
method.uioCtrl = STUB_Ctrl;
uio = BSL_UIO_New(&method);
ASSERT_TRUE(uio != NULL && BSL_UIO_GetTransportType(uio) == BSL_UIO_UDP);
BSL_UIO_Free(uio);
}
#endif
EXIT:
return;
#else
SKIP_TEST();
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_NEW_API_TC002
* @title BSL uio and meth parameter test
* @precon Registering memory-related functions.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_NEW_API_TC002(void)
{
TestMemInit();
BSL_UIO *uio = BSL_UIO_New(NULL);
ASSERT_EQ(uio, NULL);
BSL_UIO_Method *ori = BSL_UIO_NewMethod();
ASSERT_NE(ori, NULL);
int32_t customType = BSL_UIO_EXTEND + 3;
ASSERT_EQ(BSL_UIO_SetMethodType(ori, customType), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_READ_CB, BslUioRead), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_WRITE_CB, BslUioWrite), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_CTRL_CB, BslUioCtrl), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_CREATE_CB, BslUioCreate), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_DESTROY_CB, BslUioDestroy), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_PUTS_CB, BslUioPuts), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_GETS_CB, BslUioGets), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_READ_CB, NULL), BSL_NULL_INPUT);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_GETS_CB + 1, BslUioGets), BSL_INVALID_ARG);
uio = BSL_UIO_New(ori);
ASSERT_NE(uio, NULL);
ASSERT_EQ(BSL_UIO_GetTransportType(uio), customType);
char *test = "test ";
uint32_t len = 0;
ASSERT_EQ(BSL_UIO_Gets(uio, test, &len), BSL_INVALID_ARG);
ASSERT_EQ(BSL_UIO_Puts(uio, test, &len), BSL_INVALID_ARG);
EXIT:
BSL_UIO_Free(uio);
BSL_UIO_FreeMethod(ori);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_NEW_API_TC001
* @title BSL uio and meth functional test
* @precon Registering memory-related functions.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_NEW_FUNC_TC001(void)
{
uint8_t test[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
TestMemInit();
BSL_UIO_Method *ori = BSL_UIO_NewMethod();
ASSERT_NE(ori, NULL);
int32_t customType = BSL_UIO_EXTEND + 3;
ASSERT_EQ(BSL_UIO_SetMethodType(ori, customType), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_READ_CB, BslUioRead), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_WRITE_CB, BslUioWrite), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_CTRL_CB, BslUioCtrl), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_CREATE_CB, BslUioCreate), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_DESTROY_CB, BslUioDestroy), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_PUTS_CB, BslUioPuts), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_GETS_CB, BslUioGets), BSL_SUCCESS);
BSL_UIO *uio = BSL_UIO_New(ori);
ASSERT_NE(uio, NULL);
ASSERT_EQ(BSL_UIO_GetTransportType(uio), customType);
uint32_t len = 0;
ASSERT_EQ(BSL_UIO_Write(uio, test, 3, &len), BSL_SUCCESS);
ASSERT_EQ(len, 3);
ASSERT_EQ(BSL_UIO_Write(uio, &test[3], 7, &len), BSL_SUCCESS);
ASSERT_EQ(len, 7);
uint32_t index = 0;
ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_CUSTOM_UIO_GET_INDEX, sizeof(index), &index), BSL_SUCCESS);
ASSERT_EQ(index, 10);
uint8_t readBuff[20] = {0};
ASSERT_EQ(BSL_UIO_Read(uio, readBuff, 8, &len), BSL_SUCCESS);
ASSERT_EQ(len, 8);
ASSERT_EQ(BSL_UIO_Read(uio, &readBuff[7], 8, &len), BSL_SUCCESS);
ASSERT_EQ(len, 2);
ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_CUSTOM_UIO_GET_INDEX, sizeof(index), &index), BSL_SUCCESS);
ASSERT_EQ(index, 0);
EXIT:
BSL_UIO_Free(uio);
BSL_UIO_FreeMethod(ori);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_INIT_FUNC_TC001
* @title Init status value test: The uio type of the FD can be set.
* @precon nan
* @brief
* 1.BSL_UIO_New,Expected result 1 is obtained.
* 2.BSL_UIO_GET_INIT,Expected result 2 is obtained.
* 3.BSL_UIO_GET_FD,Expected result 3 is obtained.
* 4.BSL_UIO_SET_FD,Expected result 4 is obtained.
* 5.BSL_UIO_GET_INIT,Expected result 5 is obtained.
* 6.BSL_UIO_GET_FD,Expected result 6 is obtained.
* @expect
* 1.Expected success
* 2.The value of init is 0.
* 3.Expected failure, The error code is BSL_UIO_UNINITIALIZED,fd is - 1.
* 4.Expected success
* 5.The value of init is 1.
* 6.Expected success
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_INIT_FUNC_TC001(int uioType)
{
BSL_UIO *uio = NULL;
int32_t fd = 5;
uint8_t init = 0;
int32_t getFd = 0;
const BSL_UIO_Method *ori = NULL;
switch (uioType) {
case BSL_UIO_TCP:
case BSL_UIO_UDP:
ori = GetUioMethodByType(uioType);
break;
default: // The uio of the FD cannot be set.
ASSERT_TRUE(false);
}
ASSERT_TRUE(ori != NULL);
uio = BSL_UIO_New(ori);
ASSERT_TRUE(uio != NULL);
ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_GET_INIT, (int32_t)sizeof(init), &init), BSL_SUCCESS);
ASSERT_EQ(init, 0);
ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_SET_FD, (int32_t)sizeof(fd), &fd), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_GET_INIT, (int32_t)sizeof(init), &init), BSL_SUCCESS);
ASSERT_EQ(init, 1);
ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_GET_FD, (int32_t)sizeof(fd), &getFd), BSL_SUCCESS);
ASSERT_EQ(getFd, fd);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_INIT_FUNC_TC002
* @title Init status value test: Test the UIO type whose init is set to 1 during create.
* @precon nan
* @brief
* 1.Call BSL_UIO_New. Expected result 1 is obtained.
* 2.Call BSL_UIO_GET_INIT. Expected result 1 is obtained.
* @expect
* 1.Success
* 2.init is 1
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_INIT_FUNC_TC002(int uioType)
{
BSL_UIO *uio = NULL;
uint8_t init = 0;
const BSL_UIO_Method *ori = NULL;
switch (uioType) {
case BSL_UIO_BUFFER:
case BSL_UIO_MEM:
ori = GetUioMethodByType(uioType);
break;
default:
ASSERT_TRUE(false);
}
ASSERT_TRUE(ori != NULL);
uio = BSL_UIO_New(ori);
ASSERT_TRUE(uio != NULL);
ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_GET_INIT, (int32_t)sizeof(init), &init), BSL_SUCCESS);
ASSERT_EQ(init, 1);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/**
* @test UT_BSL_UIO_FREE_API_TC001
* @title Input parameter test
* @precon nan
* @brief
* 1. Set UIO to null and invoke BSL_UIO_Free. Expected result 1 is obtained.
* @expect
* 1. It is expected that the program does not dump code. No memory leakage occurs.
*/
/* BEGIN_CASE */
void UT_BSL_UIO_FREE_API_TC001(void)
{
/* The test UIO is empty. */
BSL_UIO_Free(NULL);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_SETUSERDATA_API_TC001
* @title Input parameter test
* @precon nan
* @brief
* 1.The specified uio is empty, Invoke BSL_UIO_SetUserData,Expected result 1 is obtained.
* 2.Construct the uio object, the user data is empty, invoke the BSL_UIO_SetUserData interface.
Expected result 2 is obtained.
* 3.Invoke BSL_UIO_SetUserData to specify that data1 is not null, Expected result 3 is obtained.
* 4.User data2 is not empty, call BSL_UIO_SetUserData again, Expected result 4 is obtained.
* 5.Releasing a UIO Object, Expected result 5 is obtained.
* @expect
* 1.Expected return failure
* 2.Expected success
* 3.Expected success
* 4.Expected success
* 5.It is expected that the program does not have code dump and no memory leakage occurs.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_SETUSERDATA_API_TC001(void)
{
BSL_UIO *uio = NULL;
void *userData1 = (void *)STUB_Write;
void *userData2 = (void *)STUB_Read;
/* The test UIO is empty. */
int32_t ret = BSL_UIO_SetUserData(NULL, userData1);
ASSERT_TRUE(ret == BSL_NULL_INPUT);
uio = BSL_UIO_New(BSL_UIO_TcpMethod());
ASSERT_TRUE(uio != NULL);
ret = BSL_UIO_SetUserData(uio, NULL);
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_UIO_SetUserData(uio, userData1);
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_UIO_SetUserData(uio, userData2);
ASSERT_TRUE(ret == BSL_SUCCESS);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_GETUSERDATA_API_TC001
* @title Input parameter test
* @precon nan
* @brief
* 1.The specified uio is empty., invoke BSL_UIO_GetUserData. Expected result 1 is obtained.
* 2.Construct the uio object, invoke BSL_UIO_GetUserData. Expected result 2 is obtained.
* 3.Construct user data, invoke BSL_UIO_SetUserData. Expected result 3 is obtained.
* 4.Invoke BSL_UIO_GetUserData. Expected result 4 is obtained.
* 5.Invoke BSL_UIO_Free. Expected result 5 is obtained.
* @expect
* 1.Expected return NULL
* 2.Expected return NULL
* 3.Expected success
* 4.The expected return value is the same as the data pointer.
* 5.It is expected that the program does not have code dump and no memory leakage occurs.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_GETUSERDATA_API_TC001(void)
{
BSL_UIO *uio = NULL;
void *userData = (void *)STUB_Write;
/* The test UIO is empty. */
void *data = BSL_UIO_GetUserData(NULL);
ASSERT_TRUE(data == NULL);
uio = BSL_UIO_New(BSL_UIO_TcpMethod());
ASSERT_TRUE(uio != NULL);
int32_t ret = BSL_UIO_SetUserData(uio, userData);
ASSERT_TRUE(ret == BSL_SUCCESS);
data = BSL_UIO_GetUserData(uio);
ASSERT_TRUE(data == userData);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_FLAGS_FUNC_TC001
* @title UIO Setting the Status Test
* @precon nan
* @brief
* 1.BSL_UIO_New. Expected result 1 is obtained.
* 2.BSL_UIO_SetFlags. Expected result 2 is obtained.
* @expect
* 1.Expected success
* 2.If the flags are invalid, BSL_INVALID_ARG is returned. If the flags are valid, BSL_SUCCESS is returned.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_FLAGS_FUNC_TC001(int uioType)
{
BSL_UIO *uio = NULL;
const BSL_UIO_Method *ori = GetUioMethodByType(uioType);
ASSERT_TRUE(ori != NULL);
uio = BSL_UIO_New(ori);
ASSERT_TRUE(uio != NULL);
// 0000 0001
ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_READ), BSL_SUCCESS);
// 0000 0010
ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_WRITE), BSL_SUCCESS);
// 0000 0100
ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_IO_SPECIAL), BSL_SUCCESS);
// 0000 0111
ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_RWS), BSL_SUCCESS);
// 0000 1000
ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_SHOULD_RETRY), BSL_SUCCESS);
// 0001 0000
ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_MEM_READ_ONLY), BSL_INVALID_ARG);
// 0010 0000
ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_BASE64_NO_NEWLINE), BSL_SUCCESS);
// 0100 0000
ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_BASE64_PEM), BSL_SUCCESS);
// 0111 1111
ASSERT_EQ(BSL_UIO_SetFlags(uio, 0b01111111), BSL_INVALID_ARG);
// 0110 1111
ASSERT_EQ(BSL_UIO_SetFlags(uio, 0b01101111), BSL_SUCCESS);
// 1110 1111
ASSERT_EQ(BSL_UIO_SetFlags(uio, 0b11101111), BSL_INVALID_ARG);
ASSERT_EQ(BSL_UIO_SetFlags(uio, -1), BSL_INVALID_ARG);
ASSERT_EQ(BSL_UIO_SetFlags(uio, INT_MAX), BSL_INVALID_ARG);
ASSERT_EQ(BSL_UIO_SetFlags(uio, 0), BSL_INVALID_ARG);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_FLAGS_FUNC_TC002
* @title UIO flags interface test
* @precon
* @brief
* 1. uio new. Expected result 1 is obtained.
* 2. Set two flags A and B. Expected result 2 is obtained.
* 3. Detection mark A. Expected result 3 is obtained.
* 4. Clear mark A. Expected result 4 is obtained.
* 5. Detection mark A. Expected result 5 is obtained.
* 6. Detection mark B. Expected result 6 is obtained.
* @expect
* 1. The success is not null.
* 2. Success
* 3. Successful and flag A detected
* 4. Success
* 5. Succeeded and Flag A Not Detected
* 6. Successful and Mark B detected
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_FLAGS_FUNC_TC002(void)
{
BSL_UIO *uio = BSL_UIO_New(BSL_UIO_TcpMethod());
ASSERT_TRUE(uio != NULL);
ASSERT_TRUE(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_WRITE | BSL_UIO_FLAGS_SHOULD_RETRY) == BSL_SUCCESS);
uint32_t out = 0;
ASSERT_TRUE(BSL_UIO_TestFlags(uio, BSL_UIO_FLAGS_WRITE, &out) == BSL_SUCCESS);
ASSERT_TRUE(out == BSL_UIO_FLAGS_WRITE);
ASSERT_TRUE(BSL_UIO_ClearFlags(uio, BSL_UIO_FLAGS_WRITE) == BSL_SUCCESS);
ASSERT_TRUE(BSL_UIO_TestFlags(uio, BSL_UIO_FLAGS_WRITE, &out) == BSL_SUCCESS);
ASSERT_TRUE(out == 0);
ASSERT_TRUE(BSL_UIO_TestFlags(uio, BSL_UIO_FLAGS_SHOULD_RETRY, &out) == BSL_SUCCESS);
ASSERT_TRUE(out == BSL_UIO_FLAGS_SHOULD_RETRY);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_UPREF_API_TC001
* @title Input Parameter test
* @precon nan
* @brief
* 1.The specified uio is empty, invoke UIO_UpRef. Expected result 1 is obtained.
* 2.Construct the uio object(BSL_UIO_New), invoke UIO_UpRef. Expected result 2 is obtained.
* 3.BSL_UIO_Free is invoked twice. Expected result 3 is obtained.
* @expect
* 1.Expected return failure
* 2.Expected success
* 3.It is expected that the program does not have code dump and no memory leakage occurs.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_UPREF_API_TC001(void)
{
#ifndef HITLS_BSL_UIO_SCTP
SKIP_TEST();
#else
BSL_UIO *uio = NULL;
/* The test UIO is empty. */
int32_t ret = BSL_UIO_UpRef(NULL);
ASSERT_TRUE(ret == BSL_INTERNAL_EXCEPTION);
uio = BSL_UIO_New(BSL_UIO_SctpMethod());
ASSERT_TRUE(uio != NULL);
ret = BSL_UIO_UpRef(uio);
ASSERT_TRUE(ret == BSL_SUCCESS);
EXIT:
BSL_UIO_Free(uio);
BSL_UIO_Free(uio);
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_WRITE_API_TC001
* @title Input parameter test
* @precon nan
* @brief
* 1. Call BSL_UIO_TcpMethod to create a tcp method. Expected result 1 is obtained.
* 2. The value of the input parameter UIO is NULL when BSL_UIO_Write is invoked. Expected result 2 is obtained.
* 3. The value of the input parameter data is NULL when BSL_UIO_Write is invoked. Expected result 2 is obtained.
* 4. The value of the input parameter data len is 0 when BSL_UIO_Write is invoked. Expected result 2 is obtained.
* 5. The value of the input parameter write len is NULL when BSL_UIO_Write is invoked. Expected result 2 is obtained.
* @expect
* 1. The TCP method is successfully created.
* 2. Return HITLS_INTERNAL_EXCEPTION
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_WRITE_API_TC001(void)
{
#ifdef HITLS_BSL_UIO_TCP
BSL_UIO *uio = NULL;
uint8_t data[MAX_BUF_SIZE] = {0};
const uint32_t len = 1;
uint32_t writeLen;
const BSL_UIO_Method *ori = BSL_UIO_TcpMethod();
BSL_UIO_Method method = {0};
memcpy(&method, ori, sizeof(method));
method.uioWrite = STUB_Write;
method.uioRead = STUB_Read;
/* The test UIO is empty. */
int32_t ret = BSL_UIO_Write(NULL, data, len, &writeLen);
ASSERT_TRUE(ret == BSL_INTERNAL_EXCEPTION);
uio = BSL_UIO_New(&method);
ASSERT_TRUE(uio != NULL);
/* The test data is null. */
ret = BSL_UIO_Write(uio, NULL, len, &writeLen);
ASSERT_TRUE(ret == BSL_INTERNAL_EXCEPTION);
/* Test the case when the write length is 0. */
ret = BSL_UIO_Write(uio, data, 0, &writeLen);
ASSERT_TRUE(ret == BSL_INTERNAL_EXCEPTION);
/* Test that writeLen is NULL. */
ret = BSL_UIO_Write(uio, data, len, NULL);
ASSERT_TRUE(ret == BSL_INTERNAL_EXCEPTION);
EXIT:
BSL_UIO_Free(uio);
#else
SKIP_TEST();
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_READ_API_TC001
* @title Input parameter test
* @precon nan
* @brief
* 1. Call BSL_UIO_TcpMethod to create a tcp method. Expected result 1 is obtained.
* 2. The value of the input parameter UIO is NULL when BSL_UIO_Read is invoked. Expected result 2 is obtained.
* 3. The value of the input parameter data is NULL when BSL_UIO_Read is invoked. Expected result 3 is obtained.
* 4. The value of the input parameter data len is 0 when BSL_UIO_Read is invoked. Expected result 4 is obtained.
* 5. The value of the input parameter write len is NULL when BSL_UIO_Read is invoked. Expected result 4 is obtained.
* @expect
* 1. The TCP method is successfully created.
* 2. Return BSL_INTERNAL_EXCEPTION
* 3. Return BSL_INTERNAL_EXCEPTION
* 4. Return BSL_INTERNAL_EXCEPTION
* 5. Return BSL_INTERNAL_EXCEPTION
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_READ_API_TC001(void)
{
#ifdef HITLS_BSL_UIO_TCP
BSL_UIO *uio = NULL;
uint8_t data[MAX_BUF_SIZE] = {0};
const uint32_t len = 1;
uint32_t readLen;
const BSL_UIO_Method *ori = BSL_UIO_TcpMethod();
BSL_UIO_Method method = {0};
memcpy(&method, ori, sizeof(method));
method.uioWrite = STUB_Write;
method.uioRead = STUB_Read;
/* The test UIO is empty. */
int32_t ret = BSL_UIO_Read(NULL, data, len, &readLen);
ASSERT_TRUE(ret == BSL_INTERNAL_EXCEPTION);
uio = BSL_UIO_New(&method);
ASSERT_TRUE(uio != NULL);
/* The test data is null. */
ret = BSL_UIO_Read(uio, NULL, len, &readLen);
ASSERT_TRUE(ret == BSL_INTERNAL_EXCEPTION);
/* Test the case when the write length is 0. */
ret = BSL_UIO_Read(uio, data, 0, &readLen);
ASSERT_TRUE(ret == BSL_INTERNAL_EXCEPTION);
/* Test that writeLen is NULL. */
ret = BSL_UIO_Read(uio, data, len, NULL);
ASSERT_TRUE(ret == BSL_INTERNAL_EXCEPTION);
EXIT:
BSL_UIO_Free(uio);
#else
SKIP_TEST();
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_SET_USERDATA_FREE_TC001
* @title Set userData free test
* @precon nan
* @brief
* 1. Call BSL_UIO_New to create a tcp uio. Expected result 1 is obtained.
* 2. Apply for space for userData. Expected result 2 is obtained.
* 3. Call BSL_UIO_SetUserData to set userData for UIO. Expected result 3 is obtained.
* 4. Call BSL_UIO_SetUserDataFreeFunc when uio is NULL. Expected result 4 is obtained.
* 5. Call BSL_UIO_SetUserDataFreeFunc when uio is not null. Expected result 5 is obtained.
* @expect
* 1. The TCP UIO is successfully created.
* 2. The value of userData is not empty.
* 3. Return BSL_SUCCESS and the userdata of the UIO is not empty.
* 4. Return BSL_NULL_INPUT
* 5. Return BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_SET_USERDATA_FREE_TC001(void)
{
BSL_UIO *uio = BSL_UIO_New(BSL_UIO_TcpMethod());
ASSERT_TRUE(uio != NULL);
void *userData = BSL_SAL_Malloc(MAX_BUF_SIZE);
ASSERT_TRUE(userData != NULL);
int32_t ret = BSL_UIO_SetUserData(uio, userData);
ASSERT_TRUE(ret == BSL_SUCCESS);
ASSERT_TRUE(uio->userData != NULL);
ret = BSL_UIO_SetUserDataFreeFunc(NULL, BSL_SAL_Free);
ASSERT_TRUE(ret == BSL_NULL_INPUT);
ret = BSL_UIO_SetUserDataFreeFunc(uio, BSL_SAL_Free);
ASSERT_TRUE(ret == BSL_SUCCESS);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_GET_METHOD_TC001
* @title Get uio method test
* @precon nan
* @brief
* 1. Call BSL_UIO_New to create a tcp uio. Expected result 1 is obtained.
* 2. Call BSL_UIO_TcpMethod to create a tcp method. Call BSL_UIO_GetMethod to obtain the method of TCP_UIO.
* Compare the two methods. Expected result 2 is obtained.
* @expect
* 1. The TCP UIO is successfully created.
* 2. The two methods are equal.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_GET_METHOD_TC001(void)
{
#ifdef HITLS_BSL_UIO_TCP
const BSL_UIO_Method *ori = BSL_UIO_TcpMethod();
BSL_UIO *uio = BSL_UIO_New(ori);
ASSERT_TRUE(uio != NULL);
const BSL_UIO_Method *method = BSL_UIO_GetMethod(uio);
int ret = memcmp(method, ori, sizeof(BSL_UIO_Method));
ASSERT_TRUE(ret == 0);
EXIT:
BSL_UIO_Free(uio);
#else
SKIP_TEST();
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_GET_READANDWRITE_NUM_TC001
* @title Get read and written num test
* @precon nan
* @brief
* 1. Call BSL_UIO_TcpMethod to create a tcp method. Expected result 1 is obtained.
* 2. Call BSL_UIO_New to create a tcp uio. Expected result 2 is obtained.
* 3. Call BSL_UIO_Ctrl and transfer the BSL_UIO_GET_WRITE_NUM parameter to obtain the number of written
* bytes. Expected result 3 is obtained.
* 4. Call BSL_UIO_Ctrl and transfer the BSL_UIO_GET_READ_NUM parameter to obtain the number of read bytes.
* Expected result 4 is obtained.
* @expect
* 1. The TCP METHOD is successfully created.
* 2. The TCP UIO is successfully created.
* 3. The value of writeNum is the same as the number of written bytes.
* 4. The value of readNum is the same as the number of read bytes.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_GET_READANDWRITE_NUM_TC001(void)
{
#ifdef HITLS_BSL_UIO_TCP
BSL_UIO *uio = NULL;
uint8_t data[10] = {'0', '1', '2', '3', '4'};
uint8_t readBuf[10] = {0};
const uint32_t dataLen = 5;
uint32_t writeLen = 0;
uint32_t readLen = 0;
int64_t writeNum = 0;
int64_t readNum = 0;
const BSL_UIO_Method *ori = BSL_UIO_TcpMethod();
BSL_UIO_Method method = {0};
memcpy(&method, ori, sizeof(method));
method.uioWrite = STUB_Write;
method.uioRead = STUB_Read;
uio = BSL_UIO_New(&method);
ASSERT_TRUE(uio != NULL);
BSL_UIO_SetInit(uio, 1);
ASSERT_TRUE(BSL_UIO_Write(uio, data, dataLen, &writeLen) == BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_GET_WRITE_NUM, (int32_t)sizeof(writeNum), &writeNum), BSL_SUCCESS);
ASSERT_EQ(writeNum, writeLen);
ASSERT_TRUE(BSL_UIO_Read(uio, readBuf, dataLen, &readLen) == BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_GET_READ_NUM, (int32_t)sizeof(readNum), &readNum), BSL_SUCCESS);
ASSERT_EQ(readNum, readLen);
EXIT:
BSL_UIO_Free(uio);
#else
SKIP_TEST();
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_SET_FD_TC001
* @title Set fd test
* @precon nan
* @brief
* 1. Call BSL_UIO_New to create a tcp uio. Expected result 1 is obtained.
* 2. Call BSL_UIO_SetFD to set fd to uio. Call BSL_UIO_Ctrl and transfer the BSL_UIO_GET_FD parameter to obtain
* the fd1 of uio. Compare the two fds. Expected result 2 is obtained.
* @expect
* 1. The TCP UIO is successfully created.
* 2. The two fds are equal.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_SET_FD_TC001(void)
{
char *filename = "fd_test_file.txt";
int fd = open(filename, O_RDWR | O_CREAT, 0060);
const char *data = "012345678\nabcdef";
write(fd, data, strlen(data));
BSL_UIO *uio = BSL_UIO_New(BSL_UIO_TcpMethod());
ASSERT_TRUE(uio != NULL);
BSL_UIO_SetIsUnderlyingClosedByUio(uio, true);
BSL_UIO_SetFD(uio, fd);
int32_t fd1 = -1;
ASSERT_TRUE(BSL_UIO_Ctrl(uio, BSL_UIO_GET_FD, (int32_t)sizeof(fd1), &fd1) == BSL_SUCCESS);
ASSERT_TRUE(fd == fd1);
EXIT:
BSL_UIO_Free(uio);
remove(filename);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_NEXT_TC001
* @title Uio next test
* @precon nan
* @brief
* 1. Call BSL_UIO_New to create a tcp uio named tcp1. Expected result 1 is obtained.
* 2. Call BSL_UIO_New to create a tcp uio named tcp2. Expected result 2 is obtained.
* 3. Append tcp2 to tcp1. Expected result 3 is obtained.
* 4. Check the next uio of tcp1 and the next uio of tcp2. Expected result 4 is obtained.
* @expect
* 1. The tcp1 is successfully created.
* 2. The tcp2 is successfully created.
* 3. Return BSL_SUCCESS.
* 4. The next uio of tcp1 is tcp2 and the next uio of tcp2 is NULL.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_NEXT_TC001(void)
{
BSL_UIO *tcp1 = BSL_UIO_New(BSL_UIO_TcpMethod());
ASSERT_TRUE(tcp1 != NULL);
BSL_UIO *tcp2 = BSL_UIO_New(BSL_UIO_TcpMethod());
ASSERT_TRUE(tcp2 != NULL);
ASSERT_TRUE(BSL_UIO_Append(tcp1, tcp2) == BSL_SUCCESS);
ASSERT_TRUE(BSL_UIO_Next(tcp1) == tcp2);
ASSERT_TRUE(BSL_UIO_Next(tcp2) == NULL);
EXIT:
BSL_UIO_Free(tcp1);
BSL_UIO_Free(tcp2);
}
/* END_CASE */
typedef union {
struct sockaddr addr;
struct sockaddr_in6 addrIn6;
struct sockaddr_in addrIn;
struct sockaddr_un addrUn;
} UIO_Addr;
/**
* @test SDV_BSL_UIO_UDP_API_TC001
* @title UDP ctrl test
* @precon nan
* @brief
* 1. Call BSL_UIO_UdpMethod to create a UDP method. Expected result 1 is obtained.
* 2. The input cmd is BSL_UIO_SET_PEER_IP_ADDR when BSL_UIO_Ctrl is invoked. Expected result 2 is obtained.
* 3. The input cmd is BSL_UIO_GET_PEER_IP_ADDR when BSL_UIO_Ctrl is invoked. Expected result 3 is obtained.
* 4. The input cmd is BSL_UIO_UDP_SET_CONNECTED when BSL_UIO_Ctrl is invoked. Expected result 3 is obtained.
* @expect
* 1. The UDP method is successfully created.
* 2. Return BSL_SUCCESS
* 3. Return BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_UDP_API_TC001(void)
{
BSL_UIO *uio = NULL;
int ret;
UIO_Addr peerAddr = { 0 };
uint8_t ipv4[IP_V4_LEN] = {0x11, 0x22, 0x33, 0x44};
peerAddr.addr.sa_family = AF_INET;
ASSERT_TRUE(memcpy_s(peerAddr.addr.sa_data, sizeof(UIO_Addr), ipv4, IP_V4_LEN) == EOK);
const BSL_UIO_Method *ori = BSL_UIO_UdpMethod();
BSL_UIO_Method method = {0};
memcpy_s(&method, sizeof(method), ori, sizeof(method));
method.uioWrite = STUB_Write;
method.uioRead = STUB_Read;
uio = BSL_UIO_New(&method);
ASSERT_TRUE(uio != NULL);
ret = BSL_UIO_Ctrl(uio, BSL_UIO_SET_PEER_IP_ADDR, sizeof(peerAddr), &peerAddr);
ASSERT_TRUE(ret == BSL_SUCCESS);
UIO_Addr getAddr = { 0 };
ret = BSL_UIO_Ctrl(uio, BSL_UIO_GET_PEER_IP_ADDR, sizeof(getAddr), &getAddr);
ASSERT_TRUE(ret == BSL_SUCCESS);
ASSERT_TRUE(memcmp(getAddr.addr.sa_data, peerAddr.addr.sa_data, IP_V4_LEN) == 0);
ret = BSL_UIO_Ctrl(uio, BSL_UIO_UDP_SET_CONNECTED, sizeof(peerAddr.addr), &peerAddr);
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_UIO_Ctrl(uio, BSL_UIO_UDP_SET_CONNECTED, 0, NULL);
ASSERT_TRUE(ret == BSL_SUCCESS);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_SCTP_API_TC001
* @title SCTP ctrl test
* @precon nan
* @brief
* 1. Call BSL_UIO_SctpMethod to create a SCTP method. Expected result 1 is obtained.
* 2. The input cmd is BSL_UIO_SET_PEER_IP_ADDR when BSL_UIO_Ctrl is invoked. Expected result 2 is obtained.
* 3. The input cmd is BSL_UIO_GET_PEER_IP_ADDR when BSL_UIO_Ctrl is invoked. Expected result 3 is obtained.
* 4. The input cmd is BSL_UIO_SCTP_SET_APP_STREAM_ID when BSL_UIO_Ctrl is invoked. Expected result 4 is obtained.
* @expect
* 1. The SCTP method is successfully created.
* 2. Return BSL_SUCCESS
* 3. Return BSL_SUCCESS
* 4. Return BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_SCTP_API_TC001(void)
{
#ifndef HITLS_BSL_UIO_SCTP
SKIP_TEST();
#else
BSL_UIO *uio = NULL;
int ret;
uint8_t ipAddr[256] = {0};
BSL_UIO_CtrlGetPeerIpAddrParam param = {ipAddr, sizeof(ipAddr)};
uint8_t data[IP_ADDR_V4_LEN] = {0};
uint16_t sendAppStreamId = 1;
const BSL_UIO_Method *ori = BSL_UIO_SctpMethod();
BSL_UIO_Method method = {0};
memcpy(&method, ori, sizeof(method));
method.uioWrite = STUB_Write;
method.uioRead = STUB_Read;
uio = BSL_UIO_New(&method);
ASSERT_TRUE(uio != NULL);
ret = BSL_UIO_Ctrl(uio, BSL_UIO_SET_PEER_IP_ADDR, sizeof(data), data);
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_UIO_Ctrl(uio, BSL_UIO_GET_PEER_IP_ADDR, sizeof(param), ¶m);
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_UIO_Ctrl(uio, BSL_UIO_SCTP_SET_APP_STREAM_ID, sizeof(uint16_t), &sendAppStreamId);
ASSERT_TRUE(ret == BSL_SUCCESS);
EXIT:
BSL_UIO_Free(uio);
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_BUFFER_RESET_TC001
* @title Buffer reset test
* @precon nan
* @brief
* 1. Call BSL_UIO_New to create a buffer uio named buffer. Expected result 1 is obtained.
* 2. Call BSL_UIO_New to create a tcp uio named tcp. Expected result 2 is obtained.
* 3. Append tcp to buffer. Expected result 3 is obtained.
* 4. Write 2048-length data to the buffer uio. Expected result 4 is obtained.
* 5. Call BSL_UIO_Ctrl and transfer the BSL_UIO_RESET parameter to reset the buffer uio. Expected result 5 is
* obtained.
* @expect
* 1. The buffer is successfully created.
* 2. The tcp is successfully created.
* 3. Return BSL_SUCCESS and the next uio of buffer is tcp.
* 4. Return BSL_SUCCESS and writeLen is 2048.
* 5. Return BSL_UIO_FAIL.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_BUFFER_RESET_TC001(void)
{
BSL_UIO *buffer = BSL_UIO_New(BSL_UIO_BufferMethod());
ASSERT_TRUE(buffer != NULL);
BSL_UIO *tcp = BSL_UIO_New(BSL_UIO_TcpMethod());
ASSERT_TRUE(tcp != NULL);
int32_t ret = BSL_UIO_Append(buffer, tcp);
ASSERT_TRUE(ret == BSL_SUCCESS);
ASSERT_TRUE(BSL_UIO_Next(buffer) == tcp);
ASSERT_TRUE(BSL_UIO_Next(tcp) == NULL);
uint8_t buf[8192];
uint32_t writeLen = 0;
ret = BSL_UIO_Write(buffer, buf, 2048, &writeLen);
ASSERT_TRUE(ret == BSL_SUCCESS);
ASSERT_TRUE(writeLen == 2048);
ret = BSL_UIO_Ctrl(buffer, BSL_UIO_RESET, 0, NULL);
ASSERT_TRUE(ret = BSL_UIO_FAIL);
EXIT:
BSL_UIO_Free(buffer);
BSL_UIO_Free(tcp);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_UIO_MEM_BASIC_TC001(void)
{
TestMemInit();
// Create memory UIO
BSL_UIO *uio = BSL_UIO_New(BSL_UIO_MemMethod());
ASSERT_TRUE(uio != NULL);
// Test write operation
const char testData[] = "Hello World";
uint32_t writeLen = 0;
int32_t ret = BSL_UIO_Write(uio, testData, strlen(testData), &writeLen);
ASSERT_TRUE(ret == BSL_SUCCESS);
ASSERT_TRUE(writeLen == strlen(testData));
// Test read operation
char readBuf[20] = {0};
uint32_t readLen = 0;
ret = BSL_UIO_Read(uio, readBuf, sizeof(readBuf), &readLen);
ASSERT_TRUE(ret == BSL_SUCCESS);
ASSERT_TRUE(readLen == strlen(testData));
ASSERT_TRUE(memcmp(readBuf, testData, readLen) == 0);
// Test pending data length
uint64_t pendingLen = 0;
ret = BSL_UIO_Ctrl(uio, BSL_UIO_PENDING, sizeof(uint64_t), &pendingLen);
ASSERT_TRUE(ret == BSL_SUCCESS);
ASSERT_TRUE(pendingLen == 0); // All data has been read
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_UIO_MEM_NEW_BUF_TC001(void)
{
TestMemInit();
BSL_UIO *uio = BSL_UIO_New(BSL_UIO_MemMethod());
ASSERT_TRUE(uio != NULL);
// Test MemNewBuf with invalid parameters
int32_t ret = BSL_UIO_Ctrl(uio, BSL_UIO_MEM_NEW_BUF, -1, NULL);
ASSERT_TRUE(ret == BSL_NULL_INPUT);
// Test MemNewBuf with valid parameters
char testBuf[] = "Test Buffer";
ret = BSL_UIO_Ctrl(uio, BSL_UIO_MEM_NEW_BUF, strlen(testBuf), testBuf);
ASSERT_TRUE(ret == BSL_SUCCESS);
// Verify buffer is in read-only mode
uint32_t writeLen = 0;
ret = BSL_UIO_Write(uio, "data", 4, &writeLen);
ASSERT_TRUE(ret == BSL_UIO_WRITE_NOT_ALLOWED);
// Test reading from new buffer
char readBuf[20] = {0};
uint32_t readLen = 0;
ret = BSL_UIO_Read(uio, readBuf, sizeof(readBuf), &readLen);
ASSERT_TRUE(ret == BSL_SUCCESS);
ASSERT_TRUE(readLen == strlen(testBuf));
ASSERT_TRUE(memcmp(readBuf, testBuf, readLen) == 0);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_UIO_MEM_EOF_TC001(void)
{
TestMemInit();
BSL_UIO *uio = BSL_UIO_New(BSL_UIO_MemMethod());
ASSERT_TRUE(uio != NULL);
// Test setting EOF behavior
int32_t eofValue = 1;
int32_t ret = BSL_UIO_Ctrl(uio, BSL_UIO_MEM_SET_EOF, sizeof(int32_t), &eofValue);
ASSERT_TRUE(ret == BSL_SUCCESS);
// Verify EOF value
int32_t readEof = 0;
ret = BSL_UIO_Ctrl(uio, BSL_UIO_MEM_GET_EOF, sizeof(int32_t), &readEof);
ASSERT_TRUE(ret == BSL_SUCCESS);
ASSERT_TRUE(readEof == eofValue);
// Test read behavior with EOF set
char readBuf[10];
uint32_t readLen = 0;
ret = BSL_UIO_Read(uio, readBuf, sizeof(readBuf), &readLen);
ASSERT_TRUE(ret == BSL_SUCCESS);
ASSERT_TRUE(readLen == 0);
// Verify retry flag is set due to EOF
uint32_t flags = 0;
BSL_UIO_TestFlags(uio, BSL_UIO_FLAGS_SHOULD_RETRY, &flags);
ASSERT_TRUE((flags & BSL_UIO_FLAGS_SHOULD_RETRY) != 0);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_UIO_MEM_PUTS_TC001(void)
{
char buf[MAX_BUF_SIZE] = {0};
uint32_t len = 0;
const char *str = "Hello World";
bool init = 0;
BSL_UIO *uio = BSL_UIO_New(BSL_UIO_MemMethod());
ASSERT_TRUE(uio != NULL);
ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_GET_INIT, (int32_t)sizeof(init), &init), BSL_SUCCESS);
ASSERT_EQ(init, true);
BSL_UIO_SetInit(uio, false);
ASSERT_EQ(BSL_UIO_Puts(uio, str, &len), BSL_UIO_UNINITIALIZED);
ASSERT_EQ(BSL_UIO_Read(uio, buf, sizeof(buf), &len), BSL_UIO_UNINITIALIZED);
BSL_UIO_SetInit(uio, true);
ASSERT_EQ(BSL_UIO_Puts(uio, str, &len), BSL_SUCCESS);
ASSERT_EQ(len, strlen(str));
len = 0;
ASSERT_EQ(BSL_UIO_Read(uio, buf, sizeof(buf), &len), BSL_SUCCESS);
ASSERT_EQ(len, strlen(str));
buf[len] = '\0';
ASSERT_EQ(strcmp(buf, str), 0);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_UIO_MEM_GETS_TC001(void)
{
char buf[MAX_BUF_SIZE] = {0};
uint32_t len = 0;
const char *data = "-----BEGIN PUBLIC KEY-----\nMCowBQYDK9zf3ZM1EP9N\n-----END PUBLIC KEY-----";
uint32_t dataLen = strlen(data);
BSL_UIO *uio = BSL_UIO_New(BSL_UIO_MemMethod());
ASSERT_TRUE(uio != NULL);
BSL_UIO_SetInit(uio, false);
ASSERT_EQ(BSL_UIO_Write(uio, data, dataLen, &len), BSL_UIO_UNINITIALIZED);
ASSERT_EQ(BSL_UIO_Gets(uio, buf, &len), BSL_UIO_UNINITIALIZED);
BSL_UIO_SetInit(uio, true);
ASSERT_EQ(BSL_UIO_Write(uio, data, dataLen, &len), BSL_SUCCESS);
ASSERT_EQ(len, dataLen);
len = MAX_BUF_SIZE;
ASSERT_EQ(BSL_UIO_Gets(uio, buf, &len), BSL_SUCCESS);
const char *str = "-----BEGIN PUBLIC KEY-----\n";
ASSERT_EQ(len, strlen(str));
ASSERT_EQ(strcmp(buf, str), 0);
len = MAX_BUF_SIZE;
ASSERT_EQ(BSL_UIO_Gets(uio, buf, &len), BSL_SUCCESS);
const char *str1 = "MCowBQYDK9zf3ZM1EP9N\n";
ASSERT_EQ(len, strlen(str1));
ASSERT_EQ(strcmp(buf, str1), 0);
len = MAX_BUF_SIZE;
ASSERT_EQ(BSL_UIO_Gets(uio, buf, &len), BSL_SUCCESS);
const char *str2 = "-----END PUBLIC KEY-----";
ASSERT_EQ(len, strlen(str2));
ASSERT_EQ(strcmp(buf, str2), 0);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/bsl/uio/test_suite_sdv_uio.c | C | unknown | 41,731 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
/* BEGIN_HEADER */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <sys/stat.h>
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "cmvp_common.h"
#include "crypt_cmvp.h"
#include "stub_replace.h"
#include "crypt_util_rand.h"
#include "crypt_cmvp_selftest.h"
#include "crypt_eal_cipher.h"
#include "crypt_eal_kdf.h"
#include "crypt_eal_mac.h"
#include "crypt_eal_md.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_rand.h"
#include "crypt_entropy.h"
#include "securec.h"
#include "bsl_errno.h"
#include "crypt_params_key.h"
#include "crypt_hmac.h"
/* END_HEADER */
#define MAX_OUTPUT 200
extern const char *GetIntegrityKey(void);
static void *StdMalloc(uint32_t len)
{
return malloc((size_t)len);
}
static void RegNormalMem(void)
{
BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_MALLOC, StdMalloc);
BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_FREE, free);
}
static void *STUB_Malloc(uint32_t size)
{
(void)size;
return NULL;
}
static char *Bin2Hex(const uint8_t *input, int length)
{
const int perHexLen = 2;
int rLen = length * perHexLen + 1;
char *result = malloc(rLen);
if (result == NULL) {
return NULL;
}
(void)memset_s(result, rLen, 0, rLen);
for (int i = 0; i < length; i++) {
if (sprintf_s(result + perHexLen * i, rLen, "%02x", input[i]) <= 0) {
free(result);
return NULL;
}
}
result[rLen - 1] = 0;
return result;
}
#define HMAC_SHA256_SIZE 32
static int32_t CmvpHmacTest(const char *key, uint32_t id, uint8_t *buf, uint32_t bufLen, uint8_t *mac, uint32_t *macLen)
{
CRYPT_HMAC_Ctx *hmacCtx = CRYPT_HMAC_NewCtx(id);
if (hmacCtx == NULL) {
return -1;
}
int32_t ret = CRYPT_HMAC_Init(hmacCtx, (uint8_t *)(uintptr_t)key, strlen(key), NULL);
if (ret != CRYPT_SUCCESS) {
CRYPT_HMAC_FreeCtx(hmacCtx);
return ret;
}
ret = CRYPT_HMAC_Update(hmacCtx, buf, bufLen);
if (ret != CRYPT_SUCCESS) {
CRYPT_HMAC_FreeCtx(hmacCtx);
return ret;
}
ret = CRYPT_HMAC_Final(hmacCtx, mac, macLen);
CRYPT_HMAC_FreeCtx(hmacCtx);
return ret;
}
static void CreatIntegrityFile(void)
{
uint32_t bufLen;
char *out = NULL;
FILE *fp = NULL;
uint8_t *buf = (uint8_t *)CMVP_ReadFile("test_suite_sdv_cmvp", "rb", &bufLen);
ASSERT_TRUE(buf != NULL);
uint32_t id;
uint8_t mac[HMAC_SHA256_SIZE];
uint32_t macLen = sizeof(mac);
id = CRYPT_MAC_HMAC_SHA256;
ASSERT_TRUE(CmvpHmacTest(GetIntegrityKey(), id, buf, bufLen, mac, &macLen) == CRYPT_SUCCESS);
out = Bin2Hex(mac, HMAC_SHA256_SIZE);
ASSERT_TRUE(out != NULL);
fp = fopen("test_suite_sdv_cmvp.hmac", "w");
ASSERT_TRUE(fp != NULL);
ASSERT_TRUE(fprintf(fp, "%s%s\n", "HMAC-SHA256(test_suite_sdv_cmvp)= ", out) > 0);
(void)fclose(fp);
EXIT:
free(buf);
free(out);
}
static int CreateFakeIntegrityFile(const char *key, uint32_t id)
{
int ret = 1;
uint32_t bufLen;
char *out = NULL;
FILE *fp = NULL;
uint8_t *buf = (uint8_t *)CMVP_ReadFile("test_suite_sdv_cmvp", "rb", &bufLen);
ASSERT_TRUE(buf != NULL);
uint8_t mac[HMAC_SHA256_SIZE];
uint32_t macLen = sizeof(mac);
ASSERT_TRUE(CmvpHmacTest(key, id, buf, bufLen, mac, &macLen) == CRYPT_SUCCESS);
out = Bin2Hex(mac, HMAC_SHA256_SIZE);
ASSERT_TRUE(out != NULL);
fp = fopen("test_suite_sdv_cmvp.hmac", "w");
ASSERT_TRUE(fp != NULL);
ASSERT_TRUE(fprintf(fp, "%s%s\n", "HMAC-SHA256(test_suite_sdv_cmvp)= ", out) > 0);
(void)fclose(fp);
ret = CRYPT_SUCCESS;
EXIT:
free(buf);
free(out);
return ret;
}
static int FalsifyFile(const char *path)
{
FILE *fp;
char ch;
int ret = 1;
fp = fopen(path, "r+");
ASSERT_TRUE(fp != NULL);
ASSERT_TRUE(fseek(fp, -2, SEEK_END) == 0);
ASSERT_TRUE(fread(&ch, 1, 1, fp) != 0);
ch++;
ASSERT_TRUE(fseek(fp, -2, SEEK_END) == 0);
ASSERT_TRUE(fwrite(&ch, 1, 1, fp) != 0); // 将文件最后一个字节修改
(void)fclose(fp);
ret = CRYPT_SUCCESS;
EXIT:
return ret;
}
static int RecoverFile(const char *path)
{
FILE *fp;
char ch;
int ret = 1;
fp = fopen(path, "r+");
ASSERT_TRUE(fp != NULL);
ASSERT_TRUE(fseek(fp, -2, SEEK_END) == 0);
ASSERT_TRUE(fread(&ch, 1, 1, fp) != 0);
ch--;
ASSERT_TRUE(fseek(fp, -2, SEEK_END) == 0);
ASSERT_TRUE(fwrite(&ch, 1, 1, fp) != 0); // 将文件最后一个字节修改
(void)fclose(fp);
ret = CRYPT_SUCCESS;
EXIT:
return ret;
}
static int CopyFile(const char *src_path)
{
FILE *src_file, *dst_file;
int ret = 1;
char *dst_path = "copy";
char buffer[1024];
size_t bytes_read;
src_file = fopen(src_path, "rb");
if (src_file == NULL) {
return ret;
}
dst_file = fopen(dst_path, "wb");
if (dst_file == NULL) {
fclose(src_file);
return ret;
}
while ((bytes_read = fread(buffer, 1, sizeof(buffer), src_file)) > 0) {
fwrite(buffer, 1, bytes_read, dst_file);
}
fclose(src_file);
fclose(dst_file);
ret = CRYPT_SUCCESS;
return ret;
}
static void ResetStatus(void)
{
CreatIntegrityFile(); // Generating an Integrity Verification File
CRYPT_EAL_RegEventReport(NULL);
}
static void StartTest(void)
{
RegNormalMem();
}
static void ResetStatusAndStartTest(void)
{
ResetStatus();
StartTest();
}
static void EndTest(void)
{
return;
}
/* @
* @test SDV_CRYPTO_CMVP_INTEGRITY_TC002
* @spec -
* @title Integrity verification file error_Integrity verification file missing
* @precon Prepare the test environment.
* @brief
1.CRYPT_CMVP_StatusGet Obtain the error code. Expected result 1 is obtained.
2.Create an asymmetric context. Expected result 2 is obtained.
* @expect
1.return CRYPT_CMVP_ERR_INTEGRITY
2.return NULL
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_INTEGRITY_TC002(void)
{
ResetStatus();
ASSERT_TRUE(remove("test_suite_sdv_cmvp.hmac") == 0);
StartTest();
ASSERT_TRUE(CMVP_CheckIntegrity(NULL, NULL, CRYPT_MAC_HMAC_SHA256) == CRYPT_CMVP_ERR_INTEGRITY);
EXIT:
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_INTEGRITY_TC003
* @spec -
* @title Integrity verification file error_Integrity verification file is falsified.
* @precon Prepare the test environment.
* @brief
1.CRYPT_CMVP_StatusGet Obtain the error code. Expected result 1 is obtained.
2.Create an asymmetric context. Expected result 2 is obtained.
* @expect
1.return CRYPT_CMVP_ERR_INTEGRITY
2.return NULL
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_INTEGRITY_TC003(void)
{
ResetStatus();
ASSERT_TRUE(FalsifyFile("test_suite_sdv_cmvp.hmac") == 0);
StartTest();
ASSERT_TRUE(CMVP_CheckIntegrity(NULL, NULL, CRYPT_MAC_HMAC_SHA256) == CRYPT_CMVP_ERR_INTEGRITY);
EXIT:
RecoverFile("test_suite_sdv_cmvp.hmac");
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_INTEGRITY_TC004
* @spec -
* @title Integrity verification file error_Integrity verification file is generated with incorrect Mac key
* @precon Prepare the test environment.
* @brief
1.CRYPT_CMVP_StatusGet Obtain the error code. Expected result 1 is obtained.
2.Create an asymmetric context. Expected result 2 is obtained.
* @expect
1.return CRYPT_CMVP_ERR_INTEGRITY
2.return NULL
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_INTEGRITY_TC004(void)
{
const char fake_key[] = "a8fc4931453af3285f0f";
ResetStatus();
ASSERT_TRUE(CreateFakeIntegrityFile(fake_key, CRYPT_MAC_HMAC_SHA256) == 0);
StartTest();
ASSERT_TRUE(CMVP_CheckIntegrity(NULL, NULL, CRYPT_MAC_HMAC_SHA256) == CRYPT_CMVP_ERR_INTEGRITY);
EXIT:
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_INTEGRITY_TC005
* @spec -
* @title Integrity verification file error_Integrity verification file is generated using an incorrect algorithm
* @precon Prepare the test environment.
* @brief
1.CRYPT_CMVP_StatusGet Obtain the error code. Expected result 1 is obtained.
2.Create an asymmetric context. Expected result 2 is obtained.
* @expect
1.return CRYPT_CMVP_ERR_INTEGRITY
2.return NULL
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_INTEGRITY_TC005(void)
{
const char key[] = "b8fc4931453af3285f0f";
ResetStatus();
ASSERT_TRUE(CreateFakeIntegrityFile(key, CRYPT_MAC_HMAC_SHA3_256) == 0);
StartTest();
ASSERT_TRUE(CMVP_CheckIntegrity(NULL, NULL, CRYPT_MAC_HMAC_SHA256) == CRYPT_CMVP_ERR_INTEGRITY);
EXIT:
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_INTEGRITY_TC006
* @spec -
* @title Integrity verification file error_"test_suite_sdv_cmvp" file missing
* @precon Prepare the test environment.
* @brief
1.CRYPT_CMVP_StatusGet Obtain the error code. Expected result 1 is obtained.
2.Create an asymmetric context. Expected result 2 is obtained.
* @expect
1.return CRYPT_CMVP_ERR_INTEGRITY
2.return NULL
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_INTEGRITY_TC006(void)
{
ResetStatus();
ASSERT_TRUE(CopyFile("test_suite_sdv_cmvp") == 0);
ASSERT_TRUE(remove("test_suite_sdv_cmvp") == 0);
StartTest();
ASSERT_TRUE(CMVP_CheckIntegrity(NULL, NULL, CRYPT_MAC_HMAC_SHA256) == CRYPT_CMVP_ERR_INTEGRITY);
EXIT:
ASSERT_TRUE(rename("copy", "test_suite_sdv_cmvp") == 0);
ASSERT_TRUE(chmod("test_suite_sdv_cmvp", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) == 0);
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_INTEGRITY_TC001
* @spec -
* @title Integrity verification file is correct_Integrity verification file
* @precon nan
* @brief
1.CRYPT_CMVP_StatusGet Obtain the error code. Expected result 1 is obtained.
2.Create an asymmetric context. Expected result 2 is obtained.
* @expect
1.return CRYPT_SUCCESS
2.return no NULL
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_INTEGRITY_TC001(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CMVP_CheckIntegrity(NULL, NULL, CRYPT_MAC_HMAC_SHA256) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC001
* @spec -
* @title MAC Algorithm self-check, Algorithm id
* @precon nan
* @brief
1.Register Memory Management
2.Transfer CRYPT_MAC_HMAC_SHA1 to perform algorithm self-check. Expected result 2 is obtained.
3.Transfer CRYPT_MAC_HMAC_SHA224 to perform algorithm self-check. Expected result 3 is obtained.
4.Transfer CRYPT_MAC_HMAC_SHA256 to perform algorithm self-check. Expected result 4 is obtained.
5.Transfer CRYPT_MAC_HMAC_SHA384 to perform algorithm self-check. Expected result 5 is obtained.
6.Transfer CRYPT_MAC_HMAC_SHA512 to perform algorithm self-check. Expected result 6 is obtained.
7.Transfer CRYPT_MAC_MAX to perform algorithm self-check. Expected result 7 is obtained.
8.Transfer -1 to perform algorithm self-check. Expected result 8 is obtained.
* @expect
1.none 2.return true 3.return true
4.return true 5.return true 6.return true
7.return true 8.return true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC001(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_HMAC_SM3) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_CMAC_AES128) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_CMAC_AES192) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_CMAC_AES256) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_HMAC_SHA1) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_HMAC_SHA224) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_HMAC_SHA256) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_HMAC_SHA384) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_HMAC_SHA512) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_GMAC_AES128) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_GMAC_AES192) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_GMAC_AES256) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_MAX) == false);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(-1) == false);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC010
* @spec -
* @title MD Algorithm self-check. Indicates whether the ID is valid.
* @precon nan
* @brief
1.Register the memory management callback function. Expected result 1 is obtained.
3.Transfer CRYPT_MD_MD5 to perform algorithm self-check. Expected result 2 is obtained.
3.Transfer CRYPT_MD_SHA1 to perform algorithm self-check. Expected result 3 is obtained.
4.Transfer CRYPT_MD_SHA224 to perform algorithm self-check. Expected result 4 is obtained.
5.Transfer CRYPT_MD_SHA256 to perform algorithm self-check. Expected result 5 is obtained.
6.Transfer CRYPT_MD_SHA384 to perform algorithm self-check. Expected result 6 is obtained.
7.Transfer CRYPT_MD_SHA512 to perform algorithm self-check. Expected result 7 is obtained.
8.Transfer CRYPT_MD_SHA3_224 to perform algorithm self-check. Expected result 8 is obtained.
9.Transfer CRYPT_MD_SHA3_256 to perform algorithm self-check. Expected result 9 is obtained.
10.Transfer CRYPT_MD_SHA3_384 to perform algorithm self-check. Expected result 10 is obtained.
11.Transfer CRYPT_MD_SHA3_512 to perform algorithm self-check. Expected result 111 is obtained.
12.Transfer CRYPT_MD_SM3 to perform algorithm self-check. Expected result 12 is obtained.
13.Transfer CRYPT_MD_MAX to perform algorithm self-check. Expected result 13 is obtained.
14.Transfer -1 to perform algorithm self-check. Expected result 14 is obtained.
* @expect
1.none 2.return false 3.return true
4.return true 5.return true 6.return true
7.return true 8.return true 9.return true
10.return true 11.return true 12.return false
13.return false 14.return false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC010(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SM3) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_MD5) == false);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHA1) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHA224) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHA256) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHA384) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHA512) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHA3_224) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHA3_256) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHA3_384) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHA3_512) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHAKE128) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHAKE256) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_MAX) == false);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(-1) == false);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC019
* @spec -
* @title DRBG Algorithm self-check. Indicates whether the ID is valid.
* @precon Prepare the test environment.
* @brief
1.Register the memory management callback function. Expected result 1 is obtained.
2.Transfer CRYPT_RAND_AES128_CTR_DF to perform algorithm self-check. Expected result 2 is obtained.
3.Transfer CRYPT_RAND_AES192_CTR_DF to perform algorithm self-check. Expected result 3 is obtained.
4.Transfer CRYPT_RAND_AES256_CTR_DF to perform algorithm self-check. Expected result 4 is obtained.
5.Transfer CRYPT_RAND_AES128_CTR to perform algorithm self-check. Expected result 5 is obtained.
6.Transfer CRYPT_RAND_AES192_CTR to perform algorithm self-check. Expected result 6 is obtained.
7.Transfer CRYPT_RAND_AES256_CTR to perform algorithm self-check. Expected result 7 is obtained.
8.Transfer CRYPT_RAND_HMAC_SHA1 to perform algorithm self-check. Expected result 8 is obtained.
9.Transfer CRYPT_RAND_HMAC_SHA224 to perform algorithm self-check. Expected result 9 is obtained.
10.Transfer CRYPT_RAND_HMAC_SHA256 to perform algorithm self-check. Expected result 10 is obtained.
11.Transfer CRYPT_RAND_HMAC_SHA384 to perform algorithm self-check. Expected result 11 is obtained.
12.Transfer CRYPT_RAND_HMAC_SHA512 to perform algorithm self-check. Expected result 12 is obtained.
13.Transfer CRYPT_RAND_SHA1 to perform algorithm self-check. Expected result 13 is obtained.
14.Transfer CRYPT_RAND_SHA224 to perform algorithm self-check. Expected result 14 is obtained.
15.Transfer CRYPT_RAND_SHA256 to perform algorithm self-check. Expected result 15 is obtained.
16.Transfer CRYPT_RAND_SHA384 to perform algorithm self-check. Expected result 16 is obtained.
17.Transfer CRYPT_RAND_SHA512 to perform algorithm self-check. Expected result 17 is obtained.
18.Transfer CRYPT_RAND_ALGID_MAX to perform algorithm self-check. Expected result 18 is obtained.
19.Transfer -1 to perform algorithm self-check. Expected result 19 is obtained.
* @expect
1.none
2.return true 3.return true 4.return true 5.return true
6.return true 7.return true 8.return true 9.return true
10.return true 11.return true 12.return true 13.return true
14.return true 15.return true 16.return true 17.return true
18.return false 19.return false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC019(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_AES128_CTR_DF) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_AES192_CTR_DF) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_AES256_CTR_DF) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_SM4_CTR_DF) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_AES128_CTR) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_AES192_CTR) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_AES256_CTR) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_HMAC_SHA1) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_HMAC_SHA224) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_HMAC_SHA256) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_HMAC_SHA384) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_HMAC_SHA512) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_SHA1) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_SHA224) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_SHA256) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_SHA384) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_SHA512) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_SM3) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_ALGID_MAX) == false);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(-1) == false);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC035
* @spec -
* @title SM2 Algorithm self-check.
* @precon nan
* @brief
1.Register the memory management callback function. Expected result 1 is obtained.
2.Perform SM2 algorithm self-check. Expected result 2 is obtained.
* @expect
1.none
2.return true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC035(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestSM2() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC036
* @spec -
* @title RSA Algorithm self-check.
* @precon nan
* @brief
1.Register the memory management callback function. Expected result 1 is obtained.
2.Perform RSA algorithm self-check. Expected result 2 is obtained.
* @expect
1.none
2.return true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC036(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestRsa() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC037
* @spec -
* @title 内存管理已注册_内存管理是否注册_20220523171150526
* @precon nan
* @brief 1.注册内存管理回调,有预期结果1
2.执行算法自检,有预期结果2
* @expect 1.返回BSL_SUCCESS
2.返回true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC037(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_SM4_CBC) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_SM4_XTS) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_SM4_ECB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_SM4_CTR) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_SM4_GCM) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_SM4_CFB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_SM4_OFB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES128_CBC) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES192_CBC) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES256_CBC) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES128_CTR) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES192_CTR) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES256_CTR) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES128_ECB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES192_ECB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES256_ECB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES128_XTS) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES256_XTS) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES128_CCM) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES192_CCM) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES256_CCM) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES128_GCM) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES192_GCM) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES256_GCM) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES128_CFB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES192_CFB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES256_CFB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES128_OFB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES192_OFB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES256_OFB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_CHACHA20_POLY1305) == false);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_MAX) == false);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(-1) == false);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC038
* @spec -
* @title 内存管理已注册_内存管理是否注册_20220523171311299
* @precon nan
* @brief 1.注册内存管理回调,有预期结果1
2.执行算法自检,有预期结果2
* @expect 1.返回BSL_SUCCESS
2.返回true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC038(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestChacha20poly1305() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC039
* @spec -
* @title 内存管理已注册_内存管理是否注册_20220523171322795
* @precon 准备好测试环境
* @brief 1.注册内存管理回调,有预期结果1
2.执行算法自检,有预期结果2
* @expect 1.返回BSL_SUCCESS
2.返回true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC039(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestDh() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC040
* @spec -
* @title 内存管理已注册_内存管理是否注册_20220523171331230
* @precon nan
* @brief 1.注册内存管理回调,有预期结果1
2.执行算法自检,有预期结果2
* @expect 1.返回BSL_SUCCESS
2.返回true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC040(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestDsa() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC041
* @spec -
* @title 内存管理已注册_内存管理是否注册_20220523171347201
* @precon 准备好测试环境
* @brief 1.注册内存管理回调,有预期结果1
2.执行算法自检,有预期结果2
* @expect 1.返回BSL_SUCCESS
2.返回true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC041(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestEd25519() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC042
* @spec -
* @title 内存管理已注册_内存管理是否注册_20220523171421887
* @precon nan
* @brief 1.注册内存管理回调,有预期结果1
* 2.执行Hkdf算法自检,有预期结果2
* 3.执行Pbkdf2算法自检,有预期结果3
* 4.执行Scrypt算法自检,有预期结果4
* @expect 1.返回BSL_SUCCESS
2.返回true 3.返回true 4.返回true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC042(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestHkdf() == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestPbkdf2(CRYPT_MAC_HMAC_SHA1) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestScrypt() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC043
* @spec -
* @title 内存管理已注册_内存管理是否注册_20220523171421887
* @precon nan
* @brief 1.注册内存管理回调,有预期结果1
* 2.执行KdfTls12算法自检,有预期结果2
* @expect 1.无
2.返回true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC043(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestKdfTls12() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC045
* @spec -
* @title X25519算法自检
* @precon nan
* @brief 1.注册内存管理回调,有预期结果1
2.执行算法自检,有预期结果2
* @expect 1.返回BSL_SUCCESS
2.返回true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC045(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestX25519() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC046
* @spec -
* @title 内存管理未注册_内存是否注册_20220523171100467
* @precon nan
* @brief 1.传入CRYPT_RAND_AES256_CTR_DF执行算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC046(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_AES256_CTR_DF) == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC047
* @spec -
* @title 内存管理未注册_内存管理回调是否注册_20220523171144681
* @precon 准备好测试环境
* @brief 1.传入CRYPT_MD_SHA256执行算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC047(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHA256) == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC048
* @spec -
* @title 内存管理未注册_内存管理是否已注册_20220523171355210
* @precon nan
* @brief 1.执行算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC048(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestRsa() == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC049
* @spec -
* @title 内存管理未注册_内存管理是否注册_20220523171153018
* @precon nan
* @brief 1.执行算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC049(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES128_CBC) == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC050
* @spec -
* @title 内存管理未注册_内存管理是否注册_20220523171318396
* @precon nan
* @brief 1.执行算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC050(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestChacha20poly1305() == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC051
* @spec -
* @title 内存管理未注册_内存管理是否注册_20220523171325201
* @precon nan
* @brief 1.执行算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC051(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestDh() == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC052
* @spec -
* @title 内存管理未注册_内存管理是否注册_20220523171333044
* @precon nan
* @brief 1.执行算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC052(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestDsa() == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC053
* @spec -
* @title 内存管理未注册_内存管理是否注册_20220523171349655
* @precon nan
* @brief 1.执行算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC053(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestEd25519() == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC054
* @spec -
* @title 内存管理未注册_内存管理是否注册_20220523171358066
* @precon 准备好测试环境
* @brief 1.执行Hkdf算法自检,有预期结果1
* 2.执行Pbkdf2算法自检,有预期结果2
* 3.执行Scrypt算法自检,有预期结果3
* @expect 1.返回false 2.返回false 3.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC054(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestHkdf() == false);
ASSERT_TRUE(CRYPT_CMVP_SelftestPbkdf2(CRYPT_MAC_HMAC_SHA1) == false);
ASSERT_TRUE(CRYPT_CMVP_SelftestScrypt() == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC057
* @spec -
* @title 内存管理未注册_内存管理是否注册_20220523171435826
* @precon nan
* @brief 1.执行算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC057(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestX25519() == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC058(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_HMAC_SHA256) == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC059
* @spec -
* @title ECDSA算法自检
* @precon nan
* @brief 1.执行算法自检,有预期结果1
* @expect 1.返回true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC059(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestEcdsa() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC060
* @spec -
* @title ECDH算法自检
* @precon nan
* @brief 1.执行算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC060(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestEcdh() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC062
* @spec -
* @title 内存管理未注册_内存管理是否注册
* @precon nan
* @brief 1.执行TDES算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC062(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES128_CBC) == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC063
* @spec -
* @title CMVP test for MLDSA
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC063(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestMldsaSignVerify() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC064
* @spec -
* @title CMVP test for MLKEM
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC064(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestMlkemEncapsDecaps() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC065
* @spec -
* @title CMVP test for SLHDSA
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC065(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestSlhdsaSignVerify() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
#endif
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/cmvp/test_suite_sdv_cmvp.c | C | unknown | 39,979 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_list.h"
#include "bsl_err_internal.h"
#include "sal_file.h"
#include "crypt_errno.h"
#include "crypt_eal_provider.h"
#include "crypt_eal_implprovider.h"
#include "crypt_provider.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_codecs.h"
#include "bsl_types.h"
#include "crypt_types.h"
#include "crypt_utils.h"
#include "decode_local.h"
#include "test.h"
#include "stub_replace.h"
/* END_HEADER */
void *malloc_fail(uint32_t size)
{
(void)size;
return NULL;
}
/**
* @test SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC001
* @brief Test CRYPT_DECODE_ProviderNewCtx API
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC001(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
TestMemInit();
CRYPT_DECODER_Ctx *ctx = NULL;
ctx = CRYPT_DECODE_ProviderNewCtx(NULL, BSL_CID_DECODE_UNKNOWN, "provider=default, inFormat=PEM, outFormat=ASN1");
ASSERT_TRUE(ctx != NULL);
CRYPT_DECODE_Free(ctx);
ctx = NULL;
CRYPT_DECODE_Free(NULL);
/* Test with NULL libCtx */
ctx = CRYPT_DECODE_ProviderNewCtx(NULL, CRYPT_PKEY_RSA, NULL);
ASSERT_TRUE(ctx != NULL);
CRYPT_DECODE_Free(ctx);
ctx = NULL;
/* Test with invalid key type */
ctx = CRYPT_DECODE_ProviderNewCtx(NULL, -1, NULL);
ASSERT_TRUE(ctx == NULL);
/* Test with valid parameters */
ctx = CRYPT_DECODE_ProviderNewCtx(NULL, BSL_CID_DECODE_UNKNOWN, "provider=default, inFormat=PEM, outFormat=ASN1");
ASSERT_TRUE(ctx != NULL);
CRYPT_DECODE_Free(ctx);
ctx = NULL;
ctx = CRYPT_DECODE_ProviderNewCtx(NULL, BSL_CID_DECODE_UNKNOWN, "provider?default, inFormat?PEM");
ASSERT_TRUE(ctx != NULL);
CRYPT_DECODE_Free(ctx);
ctx = NULL;
ctx = CRYPT_DECODE_ProviderNewCtx(NULL, CRYPT_PKEY_RSA, "provider=default, inFormat=PEM, outFormat=ASN1");
ASSERT_TRUE(ctx == NULL);
ctx = CRYPT_DECODE_ProviderNewCtx(NULL, CRYPT_PKEY_RSA, "provider=default, inFormat=ASN1, inType=PRIKEY_RSA");
ASSERT_TRUE(ctx != NULL);
CRYPT_DECODE_Free(ctx);
ctx = NULL;
EXIT:
CRYPT_DECODE_Free(ctx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC002
* @brief When no provider is loaded, CRYPT_DECODE_ProviderNewCtx should return NULL
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC002(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
CRYPT_DECODER_Ctx *ctx = NULL;
CRYPT_EAL_LibCtx *libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
ctx = CRYPT_DECODE_ProviderNewCtx(libCtx, CRYPT_PKEY_RSA, "provider=default, inFormat=ASN1, inType=PRIKEY_RSA");
ASSERT_TRUE(ctx == NULL);
EXIT:
CRYPT_EAL_LibCtxFree(libCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC002
* @brief When user provider no decoder implement, CRYPT_DECODE_ProviderNewCtx should return NULL
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC003(char *providerPath, char *providerName, int cmd, int keyType)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)providerPath;
(void)providerName;
(void)cmd;
(void)keyType;
SKIP_TEST();
#else
CRYPT_DECODER_Ctx *ctx = NULL;
CRYPT_EAL_LibCtx *libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, providerPath), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, providerName, NULL, NULL), CRYPT_SUCCESS);
ctx = CRYPT_DECODE_ProviderNewCtx(libCtx, keyType, NULL);
ASSERT_TRUE(ctx == NULL);
EXIT:
CRYPT_EAL_LibCtxFree(libCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_SET_PARAM_API_TC001
* @brief Test CRYPT_DECODE_SetParam API
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_SET_PARAM_API_TC001(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
CRYPT_DECODER_Ctx *ctx = NULL;
/* Test with NULL ctx */
BSL_Param param = {0};
ASSERT_EQ(CRYPT_DECODE_SetParam(NULL, ¶m), CRYPT_NULL_INPUT);
ctx = CRYPT_DECODE_ProviderNewCtx(NULL, CRYPT_PKEY_RSA, "provider=default, inFormat=ASN1, inType=PRIKEY_RSA");
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_DECODE_SetParam(ctx, NULL), CRYPT_NULL_INPUT);
ctx->method->setParam = NULL;
ASSERT_EQ(CRYPT_DECODE_SetParam(ctx, ¶m), CRYPT_NOT_SUPPORT);
EXIT:
CRYPT_DECODE_Free(ctx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_GET_PARAM_API_TC001
* @brief Test CRYPT_DECODE_GetParam API
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_GET_PARAM_API_TC001(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
CRYPT_DECODER_Ctx *ctx = CRYPT_DECODE_ProviderNewCtx(NULL, CRYPT_PKEY_RSA, "provider=default, inFormat=ASN1, inType=PRIKEY_RSA");
ASSERT_TRUE(ctx != NULL);
/* Test with NULL ctx */
BSL_Param param = {0};
int32_t ret = CRYPT_DECODE_GetParam(NULL, ¶m);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
ret = CRYPT_DECODE_GetParam(ctx, NULL);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
ctx->method->getParam = NULL;
ret = CRYPT_DECODE_GetParam(ctx, ¶m);
ASSERT_EQ(ret, CRYPT_NOT_SUPPORT);
EXIT:
CRYPT_DECODE_Free(ctx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_DECODE_API_TC001
* @title Test CRYPT_DECODE_Decode API
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_DECODE_API_TC001(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
CRYPT_DECODER_Ctx *ctx = CRYPT_DECODE_ProviderNewCtx(NULL, BSL_CID_DECODE_UNKNOWN, "provider=default, inFormat=PEM, outFormat=ASN1");
ASSERT_TRUE(ctx != NULL);
/* Test with NULL ctx */
BSL_Param inParam[2] = {0};
BSL_Param *outParam = NULL;
int32_t ret = CRYPT_DECODE_Decode(NULL, inParam, &outParam);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
/* Test with NULL inParam */
ret = CRYPT_DECODE_Decode(ctx, NULL, &outParam);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
/* Test with NULL outParam */
ret = CRYPT_DECODE_Decode(ctx, inParam, NULL);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
/* Test with NULL decode function */
ctx->method->decode = NULL;
ret = CRYPT_DECODE_Decode(ctx, inParam, &outParam);
ASSERT_EQ(ret, CRYPT_NOT_SUPPORT);
EXIT:
CRYPT_DECODE_Free(ctx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_DECODE_API_TC002
* @title Test CRYPT_DECODE_Decode API with valid parameters,
* Test with valid PEM to ASN1 conversion
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_DECODE_API_TC002(char *pemPath, char *asn1Path)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)pemPath;
(void)asn1Path;
SKIP_TEST();
#else
CRYPT_DECODER_Ctx *ctx = CRYPT_DECODE_ProviderNewCtx(NULL, BSL_CID_DECODE_UNKNOWN, "provider=default, inFormat=PEM, outFormat=ASN1");
ASSERT_TRUE(ctx != NULL);
/* Test with valid PEM to ASN1 conversion */
uint8_t *pemData = NULL;
uint32_t pemDataLen = 0;
uint8_t *asn1Data = NULL;
uint32_t asn1DataLen = 0;
ASSERT_EQ(BSL_SAL_ReadFile(pemPath, &pemData, &pemDataLen), BSL_SUCCESS);
BSL_Param inParam[2] = {
{CRYPT_PARAM_DECODE_BUFFER_DATA, BSL_PARAM_TYPE_OCTETS, pemData, pemDataLen, 0},
BSL_PARAM_END
};
BSL_Param *outParam = NULL;
ASSERT_EQ(CRYPT_DECODE_Decode(ctx, inParam, &outParam), CRYPT_SUCCESS);
ASSERT_TRUE(outParam != NULL);
ASSERT_TRUE(outParam->value != NULL);
ASSERT_TRUE(outParam->valueLen > 0);
ASSERT_EQ(BSL_SAL_ReadFile(asn1Path, &asn1Data, &asn1DataLen), BSL_SUCCESS);
ASSERT_EQ(outParam->valueLen, asn1DataLen);
ASSERT_EQ(memcmp(outParam->value, asn1Data, asn1DataLen), 0);
EXIT:
BSL_SAL_Free(pemData);
BSL_SAL_Free(asn1Data);
if (outParam != NULL) {
CRYPT_DECODE_FreeOutData(ctx, outParam);
}
CRYPT_DECODE_Free(ctx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_FREE_OUT_DATA_API_TC001
* @title Test CRYPT_DECODE_FreeOutData API
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_FREE_OUT_DATA_API_TC001(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
/* Test with NULL ctx */
BSL_Param outData = {0};
CRYPT_DECODE_FreeOutData(NULL, &outData);
/* Test with NULL outData */
CRYPT_DECODER_Ctx *ctx = CRYPT_DECODE_ProviderNewCtx(NULL, BSL_CID_DECODE_UNKNOWN, "provider=default, inFormat=PEM, outFormat=ASN1");
ASSERT_TRUE(ctx != NULL);
CRYPT_DECODE_FreeOutData(ctx, NULL);
ctx->method->freeOutData = NULL;
CRYPT_DECODE_FreeOutData(ctx, &outData);
EXIT:
CRYPT_DECODE_Free(ctx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_POOL_NEW_CTX_API_TC001
* @title Test CRYPT_DECODE_PoolNewCtx API
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_POOL_NEW_CTX_API_TC001(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
FuncStubInfo tmpRpInfo = {0};
CRYPT_DECODER_PoolCtx *poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
ASSERT_TRUE(poolCtx != NULL);
CRYPT_DECODE_PoolFreeCtx(poolCtx);
poolCtx = NULL;
CRYPT_DECODE_PoolFreeCtx(NULL);
/* Test with malloc failed */
STUB_Init();
ASSERT_TRUE(STUB_Replace(&tmpRpInfo, BSL_SAL_Malloc, malloc_fail) == 0);
TestMemInit();
poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
ASSERT_TRUE(poolCtx == NULL);
EXIT:
STUB_Reset(&tmpRpInfo);
CRYPT_DECODE_PoolFreeCtx(poolCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_POOL_DECODE_API_TC001
* @title Test CRYPT_DECODE_PoolDecode API with invalid parameters
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_POOL_DECODE_API_TC001(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
CRYPT_DECODER_PoolCtx *poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
ASSERT_TRUE(poolCtx != NULL);
/* Test with NULL poolCtx */
BSL_Param inParam[2] = {0};
BSL_Param *outParam = NULL;
ASSERT_EQ(CRYPT_DECODE_PoolDecode(NULL, inParam, &outParam), CRYPT_NULL_INPUT);
/* Test with NULL inParam */
ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, NULL, &outParam), CRYPT_NULL_INPUT);
/* Test with NULL outParam */
ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, inParam, NULL), CRYPT_NULL_INPUT);
/* Test with invalid outParam */
outParam = inParam;
ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, inParam, &outParam), CRYPT_INVALID_ARG);
/* Test with invalid input data */
uint8_t invalidData[] = "Invalid PEM data";
inParam[0].valueType = BSL_PARAM_TYPE_OCTETS;
inParam[0].value = invalidData;
inParam[0].valueLen = sizeof(invalidData);
ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, inParam, &outParam), CRYPT_DECODE_ERR_NO_USABLE_DECODER);
EXIT:
CRYPT_DECODE_PoolFreeCtx(poolCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_POOL_DECODE_API_TC002
* @title Test CRYPT_DECODE_PoolDecode API with valid parameters
* @precon None
* @brief
* 1. Test with valid parameters
* 2. Test with valid PEM to ASN1 conversion
* @expect
* 1. Return CRYPT_SUCCESS
* 2. Return CRYPT_SUCCESS and output data matches expected
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_POOL_DECODE_API_TC002(char *inputFormat, char *inputType, char *path, char *targetFormat,
char *targetType, char *targetPath)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)inputFormat;
(void)inputType;
(void)path;
(void)targetFormat;
(void)targetType;
(void)targetPath;
SKIP_TEST();
#else
if (strcmp(inputFormat, "NULL") == 0) {
inputFormat = NULL;
}
if (strcmp(inputType, "NULL") == 0) {
inputType = NULL;
}
CRYPT_DECODER_PoolCtx *poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, BSL_CID_DECODE_UNKNOWN, inputFormat, inputType);
ASSERT_TRUE(poolCtx != NULL);
/* Test with valid PEM to ASN1 conversion */
uint8_t *inputData = NULL;
uint32_t inputDataLen = 0;
uint8_t *outputData = NULL;
uint32_t outputDataLen = 0;
bool isFreeOutData = true;
ASSERT_EQ(BSL_SAL_ReadFile(path, &inputData, &inputDataLen), BSL_SUCCESS);
BSL_Param inParam[2] = {
{CRYPT_PARAM_DECODE_BUFFER_DATA, BSL_PARAM_TYPE_OCTETS, inputData, inputDataLen, 0},
BSL_PARAM_END
};
BSL_Param *outParam = NULL;
/* Set target format and type */
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_FORMAT, targetFormat,
strlen(targetFormat)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_TYPE, targetType,
strlen(targetType)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, inParam, &outParam), CRYPT_SUCCESS);
ASSERT_TRUE(outParam != NULL);
ASSERT_TRUE(outParam->value != NULL);
ASSERT_TRUE(outParam->valueLen > 0);
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA, &isFreeOutData,
sizeof(bool)), CRYPT_SUCCESS);
if (outParam->key == CRYPT_PARAM_DECODE_BUFFER_DATA) {
ASSERT_EQ(BSL_SAL_ReadFile(targetPath, &outputData, &outputDataLen), BSL_SUCCESS);
ASSERT_EQ(outParam->valueLen, outputDataLen);
ASSERT_EQ(memcmp(outParam->value, outputData, outputDataLen), 0);
} else if (outParam->key == CRYPT_PARAM_DECODE_OBJECT_DATA) {
ASSERT_NE(outParam->value, NULL);
}
EXIT:
BSL_SAL_Free(inputData);
BSL_SAL_Free(outputData);
CRYPT_DECODE_PoolFreeCtx(poolCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_POOL_CTRL_API_TC001
* @title Test CRYPT_DECODE_PoolCtrl API with valid parameters and boundary conditions
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_POOL_CTRL_API_TC001(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
CRYPT_DECODER_PoolCtx *poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
ASSERT_TRUE(poolCtx != NULL);
/* Test setting target format */
const char *targetFormat = "ASN1";
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_FORMAT, (void *)targetFormat,
strlen(targetFormat)), CRYPT_SUCCESS);
ASSERT_EQ(poolCtx->targetFormat, targetFormat);
/* Test setting target type */
const char *targetType = "PRIKEY_RSA";
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_TYPE, (void *)targetType,
strlen(targetType)), CRYPT_SUCCESS);
ASSERT_EQ(poolCtx->targetType, targetType);
/* Test setting free output data flag */
bool isFreeOutData = true;
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA, &isFreeOutData,
sizeof(bool)), CRYPT_SUCCESS);
/* Test with invalid format length */
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_FORMAT, (void *)targetFormat,
MAX_CRYPT_DECODE_FORMAT_TYPE_SIZE + 1), CRYPT_INVALID_ARG);
/* Test with invalid type length */
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_TYPE, (void *)targetType,
MAX_CRYPT_DECODE_FORMAT_TYPE_SIZE + 1), CRYPT_INVALID_ARG);
/* Test with invalid flag size */
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA, &isFreeOutData,
sizeof(bool) + 1), CRYPT_INVALID_ARG);
/* Test with invalid command */
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, 0xFFFFFFFF, &isFreeOutData, sizeof(bool)), CRYPT_INVALID_ARG);
EXIT:
CRYPT_DECODE_PoolFreeCtx(poolCtx);
#endif
}
/* END_CASE */
#ifdef HITLS_CRYPTO_PROVIDER
static void FreeDecoderNode(CRYPT_DECODER_Node *decoderNode)
{
if (decoderNode == NULL) {
return;
}
CRYPT_DECODE_FreeOutData(decoderNode->decoderCtx, decoderNode->outData.data);
BSL_SAL_Free(decoderNode);
}
#endif
/**
* @test SDV_CRYPT_DECODE_POOL_CTRL_API_TC002
* @title Test CRYPT_DECODE_PoolCtrl CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA with valid parameters and boundary
* conditions
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_POOL_CTRL_API_TC002(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
BSL_Param *outParam = NULL;
bool isFreeOutData = true;
uint8_t *inputData = NULL;
uint32_t inputDataLen = 0;
CRYPT_DECODER_PoolCtx *poolCtx = NULL;
ASSERT_EQ(BSL_SAL_ReadFile("../testdata/cert/asn1/rsa2048key_pkcs1.pem", &inputData, &inputDataLen), BSL_SUCCESS);
BSL_Param inParam[2] = {
{CRYPT_PARAM_DECODE_BUFFER_DATA, BSL_PARAM_TYPE_OCTETS, inputData, inputDataLen, 0},
BSL_PARAM_END
};
poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
ASSERT_TRUE(poolCtx != NULL);
/* Manually clear the decoder path to simulate no nodes condition */
if (poolCtx->decoderPath != NULL) {
BSL_LIST_FREE(poolCtx->decoderPath, (BSL_LIST_PFUNC_FREE)FreeDecoderNode);
}
/* Now test the control operation with empty decoder path */
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA,
&isFreeOutData, sizeof(bool)), CRYPT_INVALID_ARG);
CRYPT_DECODE_PoolFreeCtx(poolCtx);
poolCtx = NULL;
/* Test when decoderPath has only one node (input equals output) */
poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
ASSERT_TRUE(poolCtx != NULL);
const char *targetFormat = "PEM";
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_FORMAT, (void *)targetFormat,
strlen(targetFormat)), CRYPT_SUCCESS);
ASSERT_EQ(poolCtx->targetFormat, targetFormat);
const char *targetType = "PRIKEY_RSA";
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_TYPE, (void *)targetType,
strlen(targetType)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, inParam, &outParam), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA,
&isFreeOutData, sizeof(bool)), CRYPT_SUCCESS);
CRYPT_DECODE_PoolFreeCtx(poolCtx);
poolCtx = NULL;
outParam = NULL;
/* Test isFreeOutData is false */
poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
ASSERT_TRUE(poolCtx != NULL);
targetFormat = "ASN1";
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_FORMAT, (void *)targetFormat,
strlen(targetFormat)), CRYPT_SUCCESS);
targetType = "PRIKEY_RSA";
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_TYPE, (void *)targetType,
strlen(targetType)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, inParam, &outParam), CRYPT_SUCCESS);
isFreeOutData = false;
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA,
&isFreeOutData, sizeof(bool)), CRYPT_SUCCESS);
BSL_SAL_FREE(outParam->value);
BSL_SAL_FREE(outParam);
EXIT:
BSL_SAL_Free(inputData);
CRYPT_DECODE_PoolFreeCtx(poolCtx);
#endif
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/codecs/decode/test_suite_sdv_decode.c | C | unknown | 19,766 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <pthread.h>
#include "crypt_errno.h"
#include "crypt_eal_cipher.h"
#include "eal_cipher_local.h"
#include "modes_local.h"
#include "bsl_sal.h"
#include "securec.h"
#define MAX_OUTPUT 5000
#define MCT_INNER_LOOP 1000
#define AES_BLOCKSIZE 16
#define MAX_DATA_LEN 1024
#define AES_TAG_LEN 16
static void Test_CipherOverLap(int algId, Hex *key, Hex *iv, Hex *in, Hex *out, int enc, uint32_t inOffset, uint32_t outOffset)
{
TestMemInit();
int32_t ret;
uint8_t outTmp[MAX_OUTPUT] = {0};
uint32_t len = MAX_OUTPUT;
uint32_t totalLen = 0;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
memcpy_s(outTmp + inOffset, sizeof(outTmp) - inOffset, in->x, in->len);
ret = CRYPT_EAL_CipherUpdate(ctx, outTmp + inOffset, in->len, outTmp + outOffset, &len);
if (outOffset > 0 && outOffset < in->len) {
ASSERT_TRUE(ret == CRYPT_EAL_ERR_PART_OVERLAP);
} else {
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
len = MAX_OUTPUT - len;
ret = CRYPT_EAL_CipherFinal(ctx, outTmp + totalLen + outOffset, &len);
totalLen += len;
ASSERT_TRUE(totalLen == out->len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(outTmp + outOffset, out->x, out->len) == 0);
}
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
void reportLog(CRYPT_EVENT_TYPE oper, CRYPT_ALGO_TYPE type, int32_t id, int32_t err)
{
#ifdef PRINT_TO_TERMINAL
printf("CRYPT_EVENT_TYPE=%d, CRYPT_ALGO_TYPE=%d, algId=%d, errorCode=%d\n", oper, type, id, err);
#else
(void)oper;
(void)type;
(void)id;
(void)err;
#endif
}
/* END_HEADER */
/**
* @test SDV_CRYPTO_AES_NEW_CTX_API_TC001
* @title Impact of the invalid algorithm ID on the New interface
* @brief
* 1.Create the context ctx with the input parameter CRYPT_CIPHER_MAX. Expected result 1 is obtained.
* @expect
* 1.Failed. NULL is returned.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_NEW_CTX_API_TC001(void)
{
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_MAX);
ASSERT_TRUE(ctx == NULL);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_INIT_API_TC001
* @title Impact of Input Parameters on the CRYPT_EAL_CipherInit Interface
* @precon Registering memory-related functions.
* @brief
* 1.Call the New interface with param CRYPT_CIPHER_AES192_CBC. Expected result 1 is obtained.
* 2.Call the Init interface, ctx is not NULL, key is not NULL, keyLen is not 0,
* iv is not NULL, and ivLen is not 0. Expected result 2 is obtained.
* 3.Call the Init interface, ctx is NULL, key is not NULL, keyLen is not 0,
* iv is not NULL, and ivLen is not 0. Expected result 3 is obtained.
* 4.Call the Init interface, ctx is not NULL, key is NULL, keyLen is not 0,
* iv is not NULL, and ivLen is not 0. Expected result 4 is obtained.
* 5.Call the Init interface, ctx is not NULL, key is not NULL, keyLen is 0,
* iv is not NULL, and ivLen is not 0. Expected result 5 is obtained.
* 6.Call the Init interface, ctx is not NULL, key is not NULL, keyLen is not 0,
* iv is NULL, and ivLen is not 0. Expected result 6 is obtained.
* 7.Call the Init interface, ctx is not NULL, key is not NULL, keyLen is not 0,
* iv is not NULL, and ivLen is 0. Expected result 7 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.Init succeeded.
* 3.Init failed.
* 4.Init failed.
* 5.Init failed.
* 6.Init failed.
* 7.Init failed.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_INIT_API_TC001(Hex *key, Hex *iv)
{
TestMemInit();
int32_t ret;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherInit(NULL, key->x, key->len, iv->x, iv->len, true);
ASSERT_EQ_LOG("1", ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherInit(ctx, NULL, key->len, iv->x, iv->len, true);
ASSERT_EQ_LOG("2", ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherInit(ctx, key->x, 0, iv->x, iv->len, true);
ASSERT_EQ_LOG("3", ret, CRYPT_AES_ERR_KEYLEN);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, NULL, iv->len, true);
ASSERT_EQ_LOG("4", ret, CRYPT_INVALID_ARG);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, 0, true);
ASSERT_EQ_LOG("5", ret, CRYPT_MODES_IVLEN_ERROR);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_DEINIT_API_TC001
* @title Impact of Input Parameters on the CRYPT_EAL_CipherDeinit Interface
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Deinit interface, ctx is not NULL. Expected result 2 is obtained.
* 3.Call the Deinit interface, ctx is NULL. Expected result 3 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The function is executed successfully.
* 3.The function is executed successfully.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_DEINIT_API_TC001(void)
{
TestMemInit();
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherDeinit(NULL);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_REINIT_API_TC001
* @title CRYPT_EAL_CipherReinit Interface Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the Reinit interface, ctx is not NULL, iv is not NULL, and ivLen is not 0. Expected result 3 is obtained.
* 4.Call the Reinit interface, ctx is NULL, iv is not NULL, and ivLen is not 0. Expected result 4 is obtained.
* 5.Call the Reinit interface, ctx is not NULL, iv is NULL, and ivLen is not 0. Expected result 5 is obtained.
* 6.Call the Reinit interface, ctx is not NULL, iv is not NULL, and ivLen is 0. Expected result 6 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Success. Return CRYPT_SUCCESS.
* 4.Failed. Return CRYPT_NULL_INPUT.
* 5.Failed. Return CRYPT_NULL_INPUT.
* 6.Failed. Return CRYPT_NULL_INPUT.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_REINIT_API_TC001(Hex *key, Hex *iv)
{
TestMemInit();
int32_t ret;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherReinit(ctx, iv->x, iv->len);
ASSERT_TRUE(ret == CRYPT_EAL_ERR_STATE);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherReinit(NULL, iv->x, iv->len);
ASSERT_TRUE(ret == CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherReinit(ctx, NULL, iv->len);
ASSERT_TRUE(ret == CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherReinit(ctx, iv->x, 0);
ASSERT_TRUE(ret == CRYPT_MODES_IVLEN_ERROR);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_UPDATE_API_TC001
* @title Impact of Input Parameters on the CRYPT_EAL_CipherUpdate Interface
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the Update interface, ctx is NULL, in is not NULL, and in len is not 0, out is not NULL, and out len is not NULL. Expected result 3 is obtained.
* 4.Call the Update interface, ctx is not NULL, in is NULL, and in len is not 0, out is not NULL, and out len is not NULL. Expected result 4 is obtained.
* 5.Call the Update interface, ctx is not NULL, in is not NULL, and in len is 0, out is not NULL, and out len is not NULL. Expected result 5 is obtained.
* 6.Call the Update interface, ctx is not NULL, in is not NULL, and in len is not 0, out is NULL, and out len is not NULL. Expected result 6 is obtained.
* 7.Call the Update interface, ctx is not NULL, in is not NULL, and in len is not 0, out is not NULL, and out len is NULL. Expected result 7 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Failed. Return CRYPT_NULL_INPUT.
* 4.Failed. Return CRYPT_NULL_INPUT.
* 5.Success. Return CRYPT_SUCCESS.
* 6.Failed. Return CRYPT_NULL_INPUT.
* 7.Failed. Return CRYPT_NULL_INPUT.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_UPDATE_API_TC001(Hex *key, Hex *iv, Hex *in)
{
TestMemInit();
int32_t ret;
uint8_t out[AES_BLOCKSIZE] = {0};
uint32_t len = AES_BLOCKSIZE;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true);
ASSERT_EQ_LOG("1", ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, out, &len);
ASSERT_EQ_LOG("2", ret, CRYPT_SUCCESS);
ASSERT_EQ_LOG("3", len, AES_BLOCKSIZE);
ret = CRYPT_EAL_CipherUpdate(NULL, in->x, in->len, out, &len);
ASSERT_EQ_LOG("4", ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherUpdate(ctx, NULL, in->len, out, &len);
ASSERT_EQ_LOG("5", ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, 0, out, &len);
ASSERT_EQ_LOG("6", ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, NULL, &len);
ASSERT_EQ_LOG("7", ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, out, NULL);
ASSERT_EQ_LOG("8", ret, CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_FINAL_API_TC001
* @title Impact of Input Parameters on the CRYPT_EAL_CipherFinal Interface
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the Update interface. Expected result 3 is obtained.
* 4.Call the Final interface, ctx is NULL, out is not NULL, and out len is not 0. Expected result 4 is obtained.
* 5.Call the Final interface, ctx is not NULL, out is NULL, and out len is not 0. Expected result 5 is obtained.
* 6.Call the Final interface, ctx is not NULL, out is not NULL, and out len is 0. Expected result 6 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.The update is successful and return CRYPT_SUCCESS.
* 4.Failed. Return CRYPT_NULL_INPUT.
* 5.Failed. Return CRYPT_NULL_INPUT.
* 6.Failed. Return CRYPT_NULL_INPUT.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_FINAL_API_TC001(Hex *key, Hex *iv, Hex *in)
{
TestMemInit();
int32_t ret;
uint8_t out[AES_BLOCKSIZE] = {0};
uint32_t len = AES_BLOCKSIZE;
uint32_t finLen = AES_BLOCKSIZE;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, out, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherFinal(ctx, out, &finLen);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherFinal(NULL, out, &finLen);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherFinal(ctx, NULL, &finLen);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherFinal(ctx, out, NULL);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_CTRL_API_TC001
* @title Impact of Input Parameters on the CRYPT_EAL_CipherCtrl Interface
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the Ctrl interface, ctx is not NULL, and type is get iv, iv is not NULL, and iv len is not 0. Expected result 3 is obtained.
* 4.Call the Ctrl interface, ctx is not NULL, and type is get blocksize, data is not NULL, and len is not 0. Expected result 4 is obtained.
* 5.Call the Ctrl interface, ctx is not NULL, and type is get iv, iv is NULL, and iv len is not 0. Expected result 5 is obtained.
* 6.Call the Ctrl interface, ctx is not NULL, and type is get iv, iv is not NULL, and iv len is 0. Expected result 6 is obtained.
* 7.Call the Ctrl interface, ctx is not NULL, and type is get blocksize, data is not NULL, and len is 0. Expected result 7 is obtained.
* 8.Call the Ctrl interface, ctx is not NULL, and type is invalid. Expected result 8 is obtained.
* 9.Call the Ctrl interface, ctx is not NULL, and type is get blocksize, data is NULL, and len is not 0. Expected result 9 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Success. Return CRYPT_SUCCESS.
* 4.Success. Return CRYPT_SUCCESS.
* 5.Failed. Return CRYPT_NULL_INPUT.
* 6.Failed. Return CRYPT_MODE_ERR_INPUT_LEN.
* 7.Failed. Return CRYPT_MODE_ERR_INPUT_LEN.
* 8.Failed. Return CRYPT_MODES_METHODS_NOT_SUPPORT.
* 9.Failed. Return CRYPT_MODE_ERR_INPUT_LEN.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_CTRL_API_TC001(int id, Hex *key, Hex *iv)
{
TestMemInit();
int32_t ret;
uint8_t *ivGet[AES_BLOCKSIZE] = {0};
const uint32_t len = AES_BLOCKSIZE;
uint32_t blockSizeGet = 0;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(id);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_IV, ivGet, len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_BLOCKSIZE, (uint8_t *)&blockSizeGet, sizeof(uint32_t));
if (id == CRYPT_CIPHER_AES128_CBC) {
ASSERT_EQ(blockSizeGet, AES_BLOCKSIZE);
} else {
ASSERT_TRUE(blockSizeGet == 1);
}
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_IV, NULL, len);
ASSERT_TRUE(ret == CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_IV, ivGet, 0);
ASSERT_TRUE(ret == CRYPT_MODE_ERR_INPUT_LEN);
ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_BLOCKSIZE, (uint8_t *)&blockSizeGet, 0);
ASSERT_TRUE(ret == CRYPT_MODE_ERR_INPUT_LEN);
ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_MAX, iv->x, iv->len);
ASSERT_EQ(ret, CRYPT_MODES_CTRL_TYPE_ERROR);
ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_BLOCKSIZE, NULL, sizeof(uint32_t));
ASSERT_TRUE(ret == CRYPT_MODE_ERR_INPUT_LEN);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_SET_PADDING_API_TC001
* @title Impact of Input Parameters on the CRYPT_EAL_CipherSetPadding Interface
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the CRYPT_EAL_CipherSetPadding interface with ctx is NULL, and type set to a normal value. Expected result 3 is obtained.
* 4.Call the CRYPT_EAL_CipherSetPadding interface with ctx is not NULL, and type set to a invalid value. Expected result 4 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Failed. Return CRYPT_NULL_INPUT.
* 4.Failed. Return CRYPT_MODES_METHODS_NOT_SUPPORT.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_SET_PADDING_API_TC001(Hex *key, Hex *iv)
{
TestMemInit();
int32_t ret;
CRYPT_EAL_CipherCtx *ctxCBC = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
CRYPT_EAL_CipherCtx *ctxCCM = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CCM);
CRYPT_EAL_CipherCtx *ctxCTR = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CTR);
ASSERT_TRUE(ctxCBC != NULL);
ASSERT_TRUE(ctxCCM != NULL);
ASSERT_TRUE(ctxCTR != NULL);
ret = CRYPT_EAL_CipherInit(ctxCBC, key->x, key->len, iv->x, iv->len, true);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherSetPadding(ctxCBC, CRYPT_PADDING_ZEROS);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherSetPadding(NULL, CRYPT_PADDING_ZEROS);
ASSERT_TRUE(ret == CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherSetPadding(ctxCBC, CRYPT_PADDING_MAX_COUNT);
ASSERT_EQ(ret, CRYPT_MODES_PADDING_NOT_SUPPORT);
ret = CRYPT_EAL_CipherSetPadding(ctxCCM, CRYPT_PADDING_ZEROS);
ASSERT_EQ(ret, CRYPT_MODES_CTRL_TYPE_ERROR);
ret = CRYPT_EAL_CipherSetPadding(ctxCTR, CRYPT_PADDING_ZEROS);
ASSERT_EQ(ret, CRYPT_MODES_CTRL_TYPE_ERROR);
EXIT:
CRYPT_EAL_CipherDeinit(ctxCBC);
CRYPT_EAL_CipherFreeCtx(ctxCBC);
CRYPT_EAL_CipherFreeCtx(ctxCCM);
CRYPT_EAL_CipherFreeCtx(ctxCTR);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_GET_PADDING_API_TC001
* @title Impact of Input Parameters on the CRYPT_EAL_CipherGetPadding Interface
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the CRYPT_EAL_CipherGetPadding interface with ctx is NULL. Expected result 3 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Failed. Return CRYPT_NULL_INPUT.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_GET_PADDING_API_TC001(Hex *key, Hex *iv)
{
TestMemInit();
int32_t ret;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherSetPadding(ctx, CRYPT_PADDING_ZEROS);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherGetPadding(ctx);
ASSERT_TRUE(ret == CRYPT_PADDING_ZEROS);
ret = CRYPT_EAL_CipherGetPadding(NULL);
ASSERT_TRUE(ret == CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_ENCRYPT_FUNC_TC001
* @title Impact of multiple blocks on AES calculation_KAT, MMT Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the SetPadding interface to set the padding mode CRYPT_PADDING_NONE. Expected result 2 is obtained.
* 3.Call the Init interface. Expected result 3 is obtained.
* 4.Call the Update interface. Expected result 4 is obtained.
* 5.Call the Final interface. Expected result 5 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The setting is successful, return CRYPT_SUCCESS.
* 3.The init is successful, return CRYPT_SUCCESS.
* 4.The update is successful, return CRYPT_SUCCESS.
* 5.The final is successful, return CRYPT_SUCCESS. The calculation result is consistent with the vector value.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC001(int isProvider, int algId, Hex *key, Hex *iv, Hex *in, Hex *out, int enc)
{
if (IsAesAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
int32_t ret;
uint8_t outTmp[MAX_OUTPUT] = {0};
uint32_t len = MAX_OUTPUT;
uint32_t totalLen = 0;
CRYPT_EAL_CipherCtx *ctx = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len);
ASSERT_EQ(ret, CRYPT_SUCCESS);
totalLen += len;
len = MAX_OUTPUT - len;
ret = CRYPT_EAL_CipherFinal(ctx, outTmp + totalLen, &len);
totalLen += len;
ASSERT_EQ(totalLen, out->len);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_EQ(memcmp(outTmp, out->x, out->len), 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_ENCRYPT_FUNC_TC002
* @title Multiple update_MCT tests
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the SetPadding interface to set the padding mode. Expected result 2 is obtained.
* 3.Call the Init interface. Expected result 3 is obtained.
* 4.Call the Update interface for multiple times. Expected result 4 is obtained.
* 5.Call the Final interface. Expected result 5 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The setting is successful, return CRYPT_SUCCESS.
* 3.The init is successful, return CRYPT_SUCCESS.
* 4.The update is successful, return CRYPT_SUCCESS.
* 5.The final is successful, return CRYPT_SUCCESS. The calculation result is consistent with the vector value.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC002(int algId, Hex *key, Hex *iv, Hex *in, Hex *out, int enc)
{
if (IsAesAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
int32_t ret;
uint32_t len = AES_BLOCKSIZE;
uint8_t mctResult[MCT_INNER_LOOP][AES_BLOCKSIZE] = {0};
uint8_t *inputTmp = in->x;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
for (uint32_t i = 0; i < MCT_INNER_LOOP; i++) {
ret = CRYPT_EAL_CipherUpdate(ctx, inputTmp, AES_BLOCKSIZE, mctResult[i], &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
if (i == 0) {
inputTmp = iv->x;
} else {
inputTmp = mctResult[i - 1];
}
}
ASSERT_TRUE(memcmp(mctResult[MCT_INNER_LOOP - 1], out->x, out->len) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_ENCRYPT_FUNC_TC003
* @title After reinit, re-encrypt and decrypt data Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the SetPadding interface to set the padding mode. Expected result 2 is obtained.
* 3.Call the Init interface. Expected result 3 is obtained.
* 4.Call the Update interface. Expected result 4 is obtained.
* 5.Call the Final interface. Expected result 5 is obtained.
* 6.Call the Reinit interface. Expected result 6 is obtained.
* 7.Call the Update interface. Expected result 7 is obtained.
* 8.Call the Final interface. Expected result 8 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The setting is successful, return CRYPT_SUCCESS.
* 3.The init is successful, return CRYPT_SUCCESS.
* 4.The update is successful, return CRYPT_SUCCESS.
* 5.The final is successful, return CRYPT_SUCCESS. The calculation result is consistent with the vector value.
* 6.The reinit is successful, return CRYPT_SUCCESS.
* 7.The update is successful, return CRYPT_SUCCESS.
* 8.The final is successful, return CRYPT_SUCCESS. The calculation result is consistent with the vector value.
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC003(int isProvider, int algId, Hex *key, Hex *iv, Hex *in, Hex *out, int enc)
{
if (IsAesAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
int32_t ret;
uint8_t outTmp[MAX_OUTPUT] = {0};
uint32_t len = MAX_OUTPUT;
uint32_t finLen;
CRYPT_EAL_CipherCtx *ctx = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
finLen = MAX_OUTPUT - len;
ret = CRYPT_EAL_CipherFinal(ctx, outTmp + len, &finLen);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
(void)memset_s(outTmp, MAX_OUTPUT, 0, MAX_OUTPUT);
len = MAX_OUTPUT;
ret = CRYPT_EAL_CipherReinit(ctx, iv->x, iv->len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
finLen = MAX_OUTPUT - len;
ret = CRYPT_EAL_CipherFinal(ctx, outTmp + len, &finLen);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_STATE_CHANGE_API_TC001
* @title New, init, update, and final state transition Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx twice. Expected result 1 is obtained.
* 2.Call the Free interface twice. Expected result 2 is obtained.
* 3.Create the context ctx. Expected result 3 is obtained.
* 4.Call the Init interface twice. Expected result 4 is obtained.
* 5.Call the Update interface twice. Expected result 5 is obtained.
* 6.Call the Final interface twice. Expected result 6 is obtained.
* 7.Call the Update interface. Expected result 7 is obtained.
* 8.Call the Deinit interface twice and call Free interface. Expected result 8 is obtained.
* 9.Create the context ctx. Expected result 9 is obtained.
* 10.Call the Update interface. Expected result 10 is obtained.
* 11.Call the Free interface and create the context ctx. Expected result 11 is obtained.
* 12.Call the Final interface. Expected result 12 is obtained.
* 13.Call the Free interface and create the context ctx. Expected result 13 is obtained.
* 14.Call the Init interface. Expected result 14 is obtained.
* 15.Call the Update interface. Expected result 15 is obtained.
* 16.Call the Init interface. Expected result 16 is obtained.
* 17.Call the Free interface and create the context ctx. Expected result 17 is obtained.
* 18.Call the Reinit interface. Expected result 18 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The free function is successfully executed.
* 3.The creation is successful and the ctx is not empty.
* 4.The init is successful, return CRYPT_SUCCESS.
* 5.The update is successful, return CRYPT_SUCCESS.
* 6.The first final is successful, the second final is failed, return CRYPT_EAL_ERR_STATE.
* 7.Failed. return CRYPT_EAL_ERR_STATE.
* 8.The deinit adn free function is successfully executed.
* 9.The creation is successful and the ctx is not empty.
* 10.Failed. return CRYPT_EAL_ERR_STATE.
* 11.The creation is successful and the ctx is not empty.
* 12.Failed. return CRYPT_EAL_ERR_STATE.
* 13.The creation is successful and the ctx is not empty.
* 14.The init is successful, return CRYPT_SUCCESS.
* 15.The update is successful, return CRYPT_SUCCESS.
* 16.The init is successful, return CRYPT_SUCCESS.
* 17.The creation is successful and the ctx is not empty.
* 18.Failed. return CRYPT_EAL_ERR_STATE.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_STATE_CHANGE_API_TC001(Hex *key, Hex *iv, Hex *in, int enc)
{
TestMemInit();
uint8_t outTmp[MAX_OUTPUT] = {0};
uint32_t len = MAX_OUTPUT;
// multi new
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
CRYPT_EAL_CipherCtx *ctx1 = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(ctx1 != NULL);
CRYPT_EAL_CipherFreeCtx(ctx);
CRYPT_EAL_CipherFreeCtx(ctx1);
ctx = NULL;
ctx1 = NULL;
ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
// multi init
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc) == CRYPT_SUCCESS);
// multi update
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len) == CRYPT_SUCCESS);
// multi final
ASSERT_TRUE(CRYPT_EAL_CipherFinal(ctx, outTmp, &len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherFinal(ctx, outTmp, &len) == CRYPT_EAL_ERR_STATE);
// update after final
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len) == CRYPT_EAL_ERR_STATE);
// multi deinit
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
// update after new
ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len) == CRYPT_EAL_ERR_STATE);
CRYPT_EAL_CipherFreeCtx(ctx);
// final after new
ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherFinal(ctx, outTmp, &len) == CRYPT_EAL_ERR_STATE);
CRYPT_EAL_CipherFreeCtx(ctx);
// init after new
len = MAX_OUTPUT;
ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len) == CRYPT_SUCCESS);
// init after update
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc) == CRYPT_SUCCESS);
CRYPT_EAL_CipherFreeCtx(ctx);
ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, iv->x, iv->len) == CRYPT_EAL_ERR_STATE);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_ENCRYPT_FUNC_TC004
* @title Encryption and decryption in different padding modes Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call SetPadding interface setting padding mode to CRYPT_PADDING_ISO7816, CRYPT_PADDING_ZEROS,
* CRYPT_PADDING_X923, CRYPT_PADDING_PKCS5, CRYPT_PADDING_PKCS7. Expected result 2 is obtained.
* 3.Call the Init interface. Expected result 3 is obtained.
* 4.Call the Update interface. Expected result 4 is obtained.
* 5.Call the Final interface. Expected result 5 is obtained.
* 6.Call the init, update, and final interfaces to decrypt and verifiy the result.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The setting is successful, return CRYPT_SUCCESS.
* 3.The init is successful, return CRYPT_SUCCESS.
* 4.The update is successful, return CRYPT_SUCCESS.
* 5.The final is successful, return CRYPT_SUCCESS.
* 6.The verification is successful, return CRYPT_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC004(int algId, Hex *key, Hex *iv, Hex *in, int padding)
{
if (IsAesAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
int32_t ret;
uint8_t outTmp[MAX_OUTPUT] = {0};
uint8_t result[MAX_OUTPUT] = {0};
uint32_t totalLen = 0;
uint32_t leftLen = MAX_OUTPUT;
uint32_t len = MAX_OUTPUT;
CRYPT_EAL_CipherCtx *ctxEnc = NULL;
CRYPT_EAL_CipherCtx *ctxDec = NULL;
ctxEnc = CRYPT_EAL_CipherNewCtx(algId);
ASSERT_TRUE(ctxEnc != NULL);
ret = CRYPT_EAL_CipherSetPadding(ctxEnc, padding);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherInit(ctxEnc, key->x, key->len, iv->x, iv->len, true);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherSetPadding(ctxEnc, padding);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctxEnc, in->x, in->len, outTmp, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
leftLen = leftLen - len;
ret = CRYPT_EAL_CipherFinal(ctxEnc, outTmp + len, &leftLen);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += leftLen;
len = MAX_OUTPUT;
leftLen = MAX_OUTPUT;
ctxDec = CRYPT_EAL_CipherNewCtx(algId);
ASSERT_TRUE(ctxDec != NULL);
ret = CRYPT_EAL_CipherInit(ctxDec, key->x, key->len, iv->x, iv->len, false);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherSetPadding(ctxDec, padding);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctxDec, outTmp, totalLen, result, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
leftLen -= len;
ret = CRYPT_EAL_CipherFinal(ctxDec, result + len, &leftLen);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(in->x, result, in->len) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctxEnc);
CRYPT_EAL_CipherFreeCtx(ctxEnc);
CRYPT_EAL_CipherDeinit(ctxDec);
CRYPT_EAL_CipherFreeCtx(ctxDec);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_ENCRYPT_FUNC_TC005
* @title Multiple update calculation encryption and decryption Test
* @precon Registering memory-related functions.
* @brief
* 1.Call the Init interface. Expected result 1 is obtained.
* 2.Call the update interface to update the first message. Expected result 2 is obtained.
* 3.Call the update interface to update the second message. Expected result 3 is obtained.
* 4.Call the update interface to update the third message. Expected result 4 is obtained.
* 5.Call the final interface. Expected result 5 is obtained.
* 6.Check whether the result is consistent with the test vector. Expected result 6 is obtained.
* @expect
* 1.The init is successful, return CRYPT_SUCCESS.
* 2.The update is successful, return CRYPT_SUCCESS.
* 3.The update is successful, return CRYPT_SUCCESS.
* 4.The update is successful, return CRYPT_SUCCESS.
* 5.The final is successful, return CRYPT_SUCCESS.
* 6.The verification is successful.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC005(int isProvider, int algId, Hex *key, Hex *iv, Hex *in1, Hex *in2,
Hex *in3, Hex *out, int enc)
{
TestMemInit();
int32_t ret;
uint8_t outTmp[MAX_OUTPUT] = {0};
uint32_t len = MAX_OUTPUT;
uint32_t totalLen = 0;
CRYPT_EAL_CipherCtx *ctx = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in1->x, in1->len, outTmp, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
len = MAX_OUTPUT - totalLen;
ret = CRYPT_EAL_CipherUpdate(ctx, in2->x, in2->len, outTmp + totalLen, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
len = MAX_OUTPUT - totalLen;
ret = CRYPT_EAL_CipherUpdate(ctx, in3->x, in3->len, outTmp + totalLen, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
len = MAX_OUTPUT - totalLen;
ret = CRYPT_EAL_CipherFinal(ctx, outTmp + totalLen, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_ENCRYPT_FUNC_TC006
* @title Encryption and decryption for multiple updates in CFB mode
* @precon Registering memory-related functions.
* @brief
* 1.Call the Init interface. Expected result 1 is obtained.
* 2.Call the Ctrl interface to set feedback.
* 3.Call the Ctrl interface to get feedback. Expected result 2 is obtained.
* 4.Call the update interface to update the first message. Expected result 3 is obtained.
* 5.Call the update interface to update the second message. Expected result 4 is obtained.
* 6.Call the update interface to update the third message. Expected result 5 is obtained.
* 7.Call the final interface. Expected result 6 is obtained.
* 8.Check whether the result is consistent with the test vector. Expected result 7 is obtained.
* @expect
* 1.The init is successful, return CRYPT_SUCCESS.
* 2.The get is successful, and getting FeedBack is equal to setting.
* 3.The update is successful, return CRYPT_SUCCESS.
* 4.The update is successful, return CRYPT_SUCCESS.
* 5.The update is successful, return CRYPT_SUCCESS.
* 6.The final is successful, return CRYPT_SUCCESS.
* 7.The verification is successful.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC006(int isProvider, int algId, int feed, Hex *key, Hex *iv, Hex *in1, Hex *in2,
Hex *in3, Hex *out, int enc)
{
if (IsAesAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
int32_t ret;
uint8_t outTmp[MAX_OUTPUT] = {0};
uint32_t len = MAX_OUTPUT;
uint32_t totalLen = 0;
CRYPT_EAL_CipherCtx *ctx = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
uint32_t feedBack = feed;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_FEEDBACKSIZE, (uint32_t *)&feedBack, sizeof(uint32_t)) == CRYPT_SUCCESS);
uint32_t tmpFeedBack = 0;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_FEEDBACKSIZE, (uint32_t *)&tmpFeedBack, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(tmpFeedBack == (uint32_t)feed);
ret = CRYPT_EAL_CipherUpdate(ctx, in1->x, in1->len, outTmp, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
len = MAX_OUTPUT - totalLen;
ret = CRYPT_EAL_CipherUpdate(ctx, in2->x, in2->len, outTmp + totalLen, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
len = MAX_OUTPUT - totalLen;
ret = CRYPT_EAL_CipherUpdate(ctx, in3->x, in3->len, outTmp + totalLen, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
len = MAX_OUTPUT - totalLen;
ret = CRYPT_EAL_CipherFinal(ctx, outTmp + totalLen, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_ENCRYPT_FUNC_TC007
* @title The input and output use the same buffer Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the Update interface. Expected result 3 is obtained.
* 4.Call the Final interface. Expected result 4 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful, return CRYPT_SUCCESS.
* 3.The update is successful, return CRYPT_SUCCESS.
* 4.The final is successful, return CRYPT_SUCCESS. The result is consistent with the test vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC007(int algId, Hex *key, Hex *iv, Hex *in, Hex *out, int enc)
{
TestMemInit();
int32_t ret;
uint32_t len = in->len;
uint32_t totalLen = 0;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, in->x, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen = totalLen + len;
len = in->len - totalLen;
ret = CRYPT_EAL_CipherFinal(ctx, in->x + totalLen, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(in->x, out->x, out->len) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
typedef struct {
int algId;
uint8_t *key;
uint32_t keyLen;
uint8_t *iv;
uint32_t ivLen;
uint8_t *in;
uint32_t inLen;
uint8_t *out;
uint32_t outLen;
int enc;
} TestVector;
void AES_MultiThreadTest(void *arg)
{
TestVector *pTestVector = (TestVector *)arg;
int32_t ret;
uint8_t outTmp[MAX_OUTPUT] = {0};
uint32_t len = MAX_OUTPUT;
uint32_t totalLen = 0;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(pTestVector->algId);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, pTestVector->key, pTestVector->keyLen, pTestVector->iv,
pTestVector->ivLen, pTestVector->enc);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, pTestVector->in, pTestVector->inLen, outTmp, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen = totalLen + len;
len = MAX_OUTPUT - totalLen;
ret = CRYPT_EAL_CipherFinal(ctx, outTmp + totalLen, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(outTmp, pTestVector->out, pTestVector->outLen) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/**
* @test SDV_CRYPTO_AES_MULTI_THREAD_FUNC_TC001
* @title Multi-thread Test
* @precon Registering memory-related functions.
* @brief
* 1.Create three threads for synchronous encryption and decryption. Expected result 1 is obtained.
* 2.Create the context ctx. Expected result 2 is obtained.
* 3.Call the Init interface. Expected result 3 is obtained.
* 4.Call the Update interface. Expected result 4 is obtained.
* 5.Call the Final interface. Expected result 5 is obtained.
* 6.Waiting for the thread to exit normally. Expected result 6 is obtained.
* @expect
* 1.The thread is created successfully.
* 2.The creation is successful and the ctx is not empty.
* 3.The init is successful, return CRYPT_SUCCESS.
* 4.The update is successful, return CRYPT_SUCCESS.
* 5.The final is successful, return CRYPT_SUCCESS. The result is consistent with the test vector.
* 6.The thread exits successfully.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_MULTI_THREAD_FUNC_TC001(int algId, Hex *key, Hex *iv, Hex *in, Hex *out, int enc)
{
#define THREAD_NUM 3
TestMemInit();
int32_t ret;
pthread_t thrd[THREAD_NUM];
TestVector testVt = {.algId = algId,
.key = key->x,
.keyLen = key->len,
.iv = iv->x,
.ivLen = iv->len,
.in = in->x,
.inLen = in->len,
.out = out->x,
.outLen = out->len,
.enc = enc};
for (uint32_t i = 0; i < THREAD_NUM; i++) {
ret = pthread_create(&thrd[i], NULL, (void *)AES_MultiThreadTest, &testVt);
ASSERT_TRUE(ret == 0);
}
for (uint32_t i = 0; i < THREAD_NUM; i++) {
pthread_join(thrd[i], NULL);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_OVERLAP_FUNC_TC001
* @title The in and out memory partially overlaps during update
* @precon Registering memory-related functions.
* @brief
* 1.The in and out buff are partially overlaps. If out > in, Expected result 1 is obtained.
* 2.The in and out buff are partially overlaps. If in > out, Expected result 2 is obtained.
* @expect
* 1.Failed. Return RYPT_EAL_ERR_PART_OVERLAP
* 2.The operation is normal.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_OVERLAP_FUNC_TC001(int algId, Hex *key, Hex *iv, Hex *in, Hex *out, int enc)
{
for (uint32_t i = 0; i <= in->len + EAL_MAX_BLOCK_LENGTH; i++) {
Test_CipherOverLap(algId, key, iv, in, out, enc, i, 0);
}
for (uint32_t i = 0; i < in->len + EAL_MAX_BLOCK_LENGTH + EAL_MAX_BLOCK_LENGTH; i++) {
Test_CipherOverLap(algId, key, iv, in, out, enc, 0, i);
}
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_ENCRYPT_FUNC_TC008
* @title Encryption in different padding modes Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call SetPadding interface setting padding mode to CRYPT_PADDING_ISO7816,
* CRYPT_PADDING_X923, CRYPT_PADDING_PKCS7. Expected result 3 is obtained.
* 4.Call the Update interface. Expected result 4 is obtained.
* 5.Call the Final interface. Expected result 5 is obtained.
* 6.Call the init, update, and final interfaces to decrypt and verifiy the result.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful, return CRYPT_SUCCESS.
* 3.The setting is successful, return CRYPT_SUCCESS.
* 4.The update is successful, return CRYPT_SUCCESS.
* 5.The final is successful, return CRYPT_SUCCESS.
* 6.The verification is successful, return CRYPT_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC008(int isProvider, int algId, Hex *key, Hex *iv, Hex *in, Hex *out, int padding)
{
TestMemInit();
int32_t ret;
uint8_t outTmp[MAX_OUTPUT] = {0};
uint32_t totalLen = 0;
uint32_t leftLen = MAX_OUTPUT;
uint32_t len = MAX_OUTPUT;
CRYPT_EAL_CipherCtx *ctxEnc = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
ASSERT_TRUE(ctxEnc != NULL);
ret = CRYPT_EAL_CipherInit(ctxEnc, key->x, key->len, iv->x, iv->len, true);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherSetPadding(ctxEnc, padding);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctxEnc, in->x, in->len, outTmp, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
leftLen = leftLen - len;
ret = CRYPT_EAL_CipherFinal(ctxEnc, outTmp + len, &leftLen);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += leftLen;
ASSERT_TRUE(totalLen == out->len);
ASSERT_TRUE(memcmp(out->x, outTmp, out->len) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctxEnc);
CRYPT_EAL_CipherFreeCtx(ctxEnc);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_ENCRYPT_FUNC_TC009
* @title Decryption in different padding modes Test
* @precon Registering memory-related functions and report-log functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call SetPadding interface setting padding mode to CRYPT_PADDING_ISO7816,
* CRYPT_PADDING_X923, CRYPT_PADDING_PKCS7. Expected result 3 is obtained.
* 4.Call the Update interface. Expected result 4 is obtained.
* 5.Call the Final interface. Expected result 5 is obtained.
* 6.Call the init, update, and final interfaces to decrypt and verifiy the result.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful, return CRYPT_SUCCESS.
* 3.The setting is successful, return CRYPT_SUCCESS.
* 4.The update is successful, return CRYPT_SUCCESS.
* 5.The final is successful, return CRYPT_SUCCESS.
* 6.The verification is successful, return CRYPT_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC009(int isProvider, int algId, Hex *key, Hex *iv, Hex *in, Hex *out,
int padding)
{
TestMemInit();
CRYPT_EAL_RegEventReport(reportLog);
int32_t ret;
uint8_t result[MAX_OUTPUT] = {0};
uint32_t totalLen = 0;
uint32_t leftLen = MAX_OUTPUT;
uint32_t len = MAX_OUTPUT;
CRYPT_EAL_CipherCtx *ctxDec = NULL;
len = MAX_OUTPUT;
leftLen = MAX_OUTPUT;
ctxDec = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
ASSERT_TRUE(ctxDec != NULL);
ret = CRYPT_EAL_CipherInit(ctxDec, key->x, key->len, iv->x, iv->len, false);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherSetPadding(ctxDec, padding);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctxDec, in->x, in->len, result, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
leftLen = leftLen - len;
ret = CRYPT_EAL_CipherFinal(ctxDec, result + len, &leftLen);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += leftLen;
ASSERT_TRUE(totalLen == out->len);
ASSERT_TRUE(memcmp(out->x, result, out->len) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctxDec);
CRYPT_EAL_CipherFreeCtx(ctxDec);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_EAL_AES_XTS_GET_IV_TC001
* @title AES-XTS: obtaining IV in different states.
* @brief
* 1. Get iv after init iv, and compare the getted iv with original iv, expected result 1
* 2. Get iv after update, and compare the getted iv with original iv, expected result 2
* 3. Get iv after final, expected result 3
* @expect
* 1. The IV is obtained successfully and the two IVs are the same.
* 2. The IV is obtained successfully and the two IVs are the same.
* 3. CRYPT_EAL_ERR_STATE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_AES_XTS_GET_IV_TC001(int id, Hex *key, Hex *iv, Hex *plainText, Hex *cipherText)
{
uint8_t outIv[AES_BLOCKSIZE] = {0};
uint8_t out[MAX_OUTPUT] = {0};
uint32_t totalOutLen = 0;
uint32_t outLen = MAX_OUTPUT;
TestMemInit();
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(id);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_IV, outIv, iv->len), CRYPT_SUCCESS);
ASSERT_COMPARE("Get iv after init", outIv, iv->len, iv->x, iv->len);
ASSERT_EQ(CRYPT_EAL_CipherUpdate(ctx, plainText->x, plainText->len, out, &outLen), CRYPT_SUCCESS);
(void)memset_s(outIv, AES_BLOCKSIZE, 0, AES_BLOCKSIZE);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_IV, outIv, iv->len), CRYPT_SUCCESS);
ASSERT_COMPARE("Get iv after encrypt", outIv, iv->len, iv->x, iv->len);
totalOutLen += outLen;
outLen = MAX_OUTPUT - totalOutLen;
ASSERT_EQ(CRYPT_EAL_CipherFinal(ctx, out + totalOutLen, &outLen), CRYPT_SUCCESS);
totalOutLen += outLen;
ASSERT_COMPARE("Check encrypt result", out, totalOutLen, cipherText->x, cipherText->len);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_IV, outIv, iv->len), CRYPT_EAL_ERR_STATE);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_EAL_AES_FUNC_TC001
* @spec -
* @title CBC,ECB,CTR,XTS: the influence of All-zero and All-F Data Keys on AES Calculation_KAT
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_AES_FUNC_TC001(int isProvider, int algId, Hex *key, Hex *iv, Hex *in, Hex *out, int enc)
{
if (IsAesAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
int32_t ret;
uint8_t outTmp[MAX_OUTPUT] = {0};
uint32_t len = MAX_OUTPUT;
uint32_t totalLen = 0;
CRYPT_EAL_CipherCtx *ctx = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
len = MAX_OUTPUT - len;
ret = CRYPT_EAL_CipherFinal(ctx, outTmp + totalLen, &len);
totalLen += len;
ASSERT_TRUE(totalLen == out->len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_EAL_AES_FUNC_TC005
* @spec -
* @title CBC,ECB,CTR,XTS: after reinit, re-encrypt and decrypt data_reinit function test
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_AES_FUNC_TC005(int isProvider, int algId, Hex *key, Hex *iv, Hex *in, Hex *out, int enc)
{
if (IsAesAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
int32_t ret;
uint8_t outTmp[MAX_OUTPUT] = {0};
uint32_t len = MAX_OUTPUT;
uint32_t finLen;
CRYPT_EAL_CipherCtx *ctx = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
finLen = MAX_OUTPUT - len;
ret = CRYPT_EAL_CipherFinal(ctx, outTmp + len, &finLen);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
(void)memset_s(outTmp, MAX_OUTPUT, 0, MAX_OUTPUT);
len = MAX_OUTPUT;
ret = CRYPT_EAL_CipherReinit(ctx, iv->x, iv->len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
finLen = MAX_OUTPUT - len;
ret = CRYPT_EAL_CipherFinal(ctx, outTmp + len, &finLen);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/aes/test_suite_sdv_eal_aes.c | C | unknown | 54,113 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <pthread.h>
#include "hitls_build.h"
#include "crypt_errno.h"
#include "crypt_eal_cipher.h"
#include "bsl_sal.h"
#include "securec.h"
typedef struct {
uint8_t *key;
uint8_t *iv;
uint8_t *aad;
uint8_t *pt;
uint8_t *ct;
uint8_t *tag;
uint32_t keyLen;
uint32_t ivLen;
uint32_t aadLen;
uint32_t ptLen;
uint32_t ctLen;
uint32_t tagLen;
int algId;
int isProvider;
} ThreadParameter;
void MultiThreadTest(void *arg)
{
ThreadParameter *threadParameter = (ThreadParameter *)arg;
uint32_t outLen = threadParameter->ctLen;
uint64_t msgLen = threadParameter->ctLen;
uint32_t tagLen = threadParameter->tagLen;
uint8_t out[threadParameter->ctLen];
uint8_t tag[threadParameter->tagLen];
CRYPT_EAL_CipherCtx *ctx = TestCipherNewCtx(NULL, threadParameter->algId, "provider=default",
threadParameter->isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, threadParameter->key, threadParameter->keyLen, threadParameter->iv,
threadParameter->ivLen, true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &msgLen, sizeof(msgLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, threadParameter->aad, threadParameter->aadLen) ==
CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, threadParameter->pt, threadParameter->ptLen, (uint8_t *)out, &outLen) ==
CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)tag, tagLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("Compare Ct", out, threadParameter->ctLen, threadParameter->ct, threadParameter->ctLen);
ASSERT_COMPARE("Compare Enc Tag", tag, tagLen, threadParameter->tag, threadParameter->tagLen);
CRYPT_EAL_CipherDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, threadParameter->key, threadParameter->keyLen, threadParameter->iv,
threadParameter->ivLen, false) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &msgLen, sizeof(msgLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, threadParameter->aad, threadParameter->aadLen) ==
CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, threadParameter->ct, threadParameter->ctLen, (uint8_t *)out, &outLen) ==
CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)tag, tagLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("Compare Pt", out, threadParameter->ptLen, threadParameter->pt, threadParameter->ptLen);
ASSERT_COMPARE("Compare Dec Tag", tag, tagLen, threadParameter->tag, threadParameter->tagLen);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_HEADER */
/**
* @test SDV_CRYPTO_AES_CCM_REINIT_API_TC001
* @title CRYPT_EAL_CipherReinit different iv length Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the Reinit interface, ctx is not NULL, iv is not NULL, and ivLen is 6. Expected result 3 is obtained.
* 4.Call the Reinit interface, ctx is not NULL, iv is not NULL, and ivLen is 7. Expected result 4 is obtained.
* 5.Call the Reinit interface, ctx is not NULL, iv is not NULL, and ivLen is 13. Expected result 5 is obtained.
* 6.Call the Reinit interface, ctx is not NULL, iv is not NULL, and ivLen is 14. Expected result 6 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Failed. Return CRYPT_MODES_IVLEN_ERROR.
* 4.Success. Return CRYPT_SUCCESS.
* 5.Success. Return CRYPT_SUCCESS.
* 6.Failed. Return CRYPT_MODES_IVLEN_ERROR.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_CCM_REINIT_API_TC001(int id, int keyLen)
{
TestMemInit();
uint8_t key[32] = { 0 };
uint8_t iv[14] = { 0 };
uint32_t ivLen = 0;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(id);
ASSERT_TRUE(ctx != NULL);
ivLen = 13;
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, (uint8_t *)key, keyLen, (uint8_t *)iv, ivLen, true) == CRYPT_SUCCESS);
ivLen = 6;
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, (uint8_t *)iv, ivLen) == CRYPT_MODES_IVLEN_ERROR);
ivLen = 7;
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, (uint8_t *)iv, ivLen) == CRYPT_SUCCESS);
ivLen = 13;
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, (uint8_t *)iv, ivLen) == CRYPT_SUCCESS);
ivLen = 14;
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, (uint8_t *)iv, ivLen) == CRYPT_MODES_IVLEN_ERROR);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_CCM_CTRL_API_TC001
* @title Relationship between CRYPT_CTRL_SET_MSGLEN and ivlen of the CRYPT_EAL_CipherCtrl interface Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the Ctrl interface, ctx is not NULL, and msg len is 0. Expected result 3 is obtained.
* 4.Call the Update interface, ctx is not NULL, and plain len is 0. Expected result 4 is obtained.
* 5.Call the Reinit interface, ctx is not NULL, iv is not NULL, and ivLen is 13. Expected result 5 is obtained.
* 6.Call the Ctrl interface, ctx is not NULL, and msg len is 0. Expected result 6 is obtained.
* 7.Call the Update interface, ctx is not NULL, and plain len is 1. Expected result 7 is obtained.
* 8.Call the Reinit interface, ctx is not NULL, iv is not NULL, and ivLen is 8. Expected result 8 is obtained.
* 9.Call the Ctrl interface, ctx is not NULL, and msg len is 1 << ((15 - 8) * 8)) - 1. Expected result 9 is obtained.
* 10.Call the Ctrl interface, ctx is not NULL, and msg len is 1 << ((15 - 8) * 8)). Expected result 10 is obtained.
* 11.Call the Reinit interface, ctx is not NULL, iv is not NULL, and ivLen is 12. Expected result 11 is obtained.
* 12.Call the Ctrl interface, ctx is not NULL, and msg len is 1 << ((15 - 12) * 8)) - 1. Expected result 12 is obtained.
* 13.Call the Ctrl interface, ctx is not NULL, and msg len is 1 << ((15 - 12) * 8)). Expected result 13 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Success. Return CRYPT_SUCCESS.
* 4.Success. Return CRYPT_SUCCESS.
* 5.Success. Return CRYPT_SUCCESS.
* 6.Success. Return CRYPT_SUCCESS.
* 7.Success. Return CRYPT_SUCCESS.
* 8.Success. Return CRYPT_SUCCESS.
* 9.Success. Return CRYPT_SUCCESS.
* 10.Failed. Return CRYPT_MODES_CTRL_MSGLEN_ERROR.
* 11.Success. Return CRYPT_SUCCESS.
* 12.Success. Return CRYPT_SUCCESS.
* 13.Failed. CRYPT_MODES_CTRL_MSGLEN_ERROR.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_CCM_CTRL_API_TC001(int id, int keyLen)
{
TestMemInit();
uint8_t key[32] = { 0 };
uint8_t iv[13] = { 0 };
uint32_t ivLen = sizeof(iv);
uint8_t data[16] = { 0 };
uint8_t out[16] = { 0 };
uint32_t outLen = sizeof(out);
uint64_t count = 0;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(id);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data, 0, out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, iv, ivLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)) == CRYPT_SUCCESS);
outLen = sizeof(out);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data, 1, out, &outLen) == CRYPT_MODES_MSGLEN_OVERFLOW);
ivLen = 8;
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, iv, ivLen) == CRYPT_SUCCESS);
count = ((uint64_t)1 << ((15 - 8) * 8)) - 1;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)) == CRYPT_SUCCESS);
count = (uint64_t)1 << ((15 - 8) * 8);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)) ==
CRYPT_MODES_CTRL_MSGLEN_ERROR);
ivLen = 12;
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, iv, ivLen) == CRYPT_SUCCESS);
count = ((uint64_t)1 << ((15 - 12) * 8)) - 1;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)) == CRYPT_SUCCESS);
count = (uint64_t)1 << ((15 - 12) * 8);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)) ==
CRYPT_MODES_CTRL_MSGLEN_ERROR);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_CCM_UPDATE_API_TC001
* @title Relationship between the CRYPT_CTRL_SET_MSGLEN and the update length of the CRYPT_EAL_CipherCtrl interface Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the Ctrl interface, ctx is not NULL, and msg len is 10. Expected result 3 is obtained.
* 4.Call the Ctrl interface, ctx is not NULL, and msg len is 20. Expected result 4 is obtained.
* 5.Call the Update interface, ctx is not NULL, and plain len is 20. Expected result 5 is obtained.
* 6.Call the Update interface, ctx is not NULL, and plain len is 0. Expected result 6 is obtained.
* 7.Call the Update interface, ctx is not NULL, and plain len is 10. Expected result 7 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Success. Return CRYPT_SUCCESS.
* 4.Success. Return CRYPT_SUCCESS.
* 5.Success. Return CRYPT_SUCCESS.
* 6.Success. Return CRYPT_SUCCESS.
* 7.Failed. Return CRYPT_MODES_MSGLEN_OVERFLOW.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_CCM_UPDATE_API_TC001(int id, int keyLen)
{
TestMemInit();
uint8_t key[32] = { 0 };
uint8_t iv[13] = { 0 };
uint32_t ivLen = sizeof(iv);
uint8_t data[20] = { 0 };
uint32_t dataLen = 0;
uint8_t out[20] = { 0 };
uint32_t outLen = sizeof(out);
uint64_t count = 0;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(id);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true) == CRYPT_SUCCESS);
count = 10;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)) == CRYPT_SUCCESS);
count = 20;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)) == CRYPT_SUCCESS);
dataLen = 20;
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data, dataLen, out, &outLen) == CRYPT_SUCCESS);
outLen = sizeof(out);
dataLen = 0;
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data, dataLen, out, &outLen) == CRYPT_SUCCESS);
outLen = sizeof(out);
dataLen = 10;
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data, dataLen, out, &outLen) == CRYPT_MODES_MSGLEN_OVERFLOW);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_CCM_UPDATE_API_TC001
* @title Test after AAD is set for the CRYPT_EAL_CipherCtrl interface, msglen cannot be set.
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the Ctrl interface, ctx is not NULL, and set aad. Expected result 3 is obtained.
* 4.Call the Ctrl interface, ctx is not NULL, and set msglen. Expected result 4 is obtained.
* 5.Call the Reinit interface, ctx is not NULL, iv is not NULL, and ivLen is 13. Expected result 5 is obtained.
* 6.Call the Ctrl interface, ctx is not NULL, and set msglen. Expected result 6 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Success. Return CRYPT_SUCCESS.
* 4.Failed. Return CRYPT_EAL_ERR_STATE.
* 5.Success. Return CRYPT_SUCCESS.
* 6.Success. Return CRYPT_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_CCM_CTRL_API_TC002(int id, int keyLen)
{
TestMemInit();
uint8_t key[32] = { 0 };
uint8_t iv[13] = { 0 };
uint32_t ivLen = sizeof(iv);
uint8_t aad[16] = { 0 };
uint64_t count = 0;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(id);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_CipherReinit(ctx, iv, ivLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_CCM_CTRL_API_TC003
* @title CRYPT_EAL_CipherCtrl interface set aad Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the Ctrl interface, ctx is not NULL, and set aad. Expected result 3 is obtained.
* 4.Call the Ctrl interface, ctx is not NULL, and set aad. Expected result 4 is obtained.
* 5.Call the Reinit interface, ctx is not NULL, iv is not NULL, and ivLen is 13. Expected result 5 is obtained.
* 6.Call the Ctrl interface, ctx is not NULL, and set aad. Expected result 6 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Success. Return CRYPT_SUCCESS.
* 4.Failed. Return CRYPT_EAL_ERR_STATE.
* 5.Success. Return CRYPT_SUCCESS.
* 6.Success. Return CRYPT_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_CCM_CTRL_API_TC003(int id, int keyLen)
{
TestMemInit();
uint8_t key[32] = { 0 };
uint8_t iv[13] = { 0 };
uint32_t ivLen = sizeof(iv);
uint8_t aad[16] = { 0 };
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(id);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)), CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, iv, ivLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_CCM_CTRL_API_TC004
* @title CRYPT_EAL_CipherCtrl interface set tag len Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the Ctrl interface, ctx is not NULL, and tag len is 4. Expected result 3 is obtained.
* 4.Call the Ctrl interface, ctx is not NULL, and tag len is 6. Expected result 4 is obtained.
* 5.Call the Ctrl interface, ctx is not NULL, and tag len is 8. Expected result 5 is obtained.
* 6.Call the Ctrl interface, ctx is not NULL, and tag len is 10. Expected result 6 is obtained.
* 7.Call the Ctrl interface, ctx is not NULL, and tag len is 12. Expected result 7 is obtained.
* 8.Call the Ctrl interface, ctx is not NULL, and tag len is 14. Expected result 8 is obtained.
* 9.Call the Ctrl interface, ctx is not NULL, and tag len is 16. Expected result 9 is obtained.
* 10.Call the Reinit interface, ctx is not NULL, iv is not NULL, and ivLen is 1. Expected result 10 is obtained.
* 11.Call the Ctrl interface, ctx is not NULL, and tag len is 2. Expected result 11 is obtained.
* 12.Call the Ctrl interface, ctx is not NULL, and tag len is 18. Expected result 12 is obtained.
* 13.Call the Ctrl interface, ctx is not NULL, and tag len is 0. Expected result 13 is obtained.
* 14.Call the Ctrl interface, ctx is not NULL, and tag len is 5. Expected result 14 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Success. Return CRYPT_SUCCESS.
* 4.Success. Return CRYPT_SUCCESS.
* 5.Success. Return CRYPT_SUCCESS.
* 6.Success. Return CRYPT_SUCCESS.
* 7.Success. Return CRYPT_SUCCESS.
* 8.Success. Return CRYPT_SUCCESS.
* 9.Success. Return CRYPT_SUCCESS.
* 10.Success. Return CRYPT_SUCCESS.
* 11.Failed. Return CRYPT_MODES_CTRL_TAGLEN_ERROR.
* 12.Failed. Return CRYPT_MODES_CTRL_TAGLEN_ERROR.
* 13.Failed. Return CRYPT_MODES_CTRL_TAGLEN_ERROR.
* 14.Failed. Return CRYPT_MODES_CTRL_TAGLEN_ERROR.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_CCM_CTRL_API_TC004(int id, int keyLen)
{
TestMemInit();
uint8_t key[32] = { 0 };
uint8_t iv[13] = { 0 };
uint32_t ivLen = sizeof(iv);
uint32_t tagLen;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(id);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true) == CRYPT_SUCCESS);
tagLen = 4;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
tagLen = 6;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
tagLen = 8;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
tagLen = 10;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
tagLen = 12;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
tagLen = 14;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
tagLen = 16;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, iv, ivLen) == CRYPT_SUCCESS);
tagLen = 2;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) ==
CRYPT_MODES_CTRL_TAGLEN_ERROR);
tagLen = 18;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) ==
CRYPT_MODES_CTRL_TAGLEN_ERROR);
tagLen = 0;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) ==
CRYPT_MODES_CTRL_TAGLEN_ERROR);
tagLen = 5;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) ==
CRYPT_MODES_CTRL_TAGLEN_ERROR);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_CCM_CTRL_API_TC005
* @title CRYPT_EAL_CipherCtrl interface get tag Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the Ctrl interface, ctx is not NULL, and tag len is 8. Expected result 3 is obtained.
* 4.Call the Ctrl interface, ctx is not NULL, and msg len is 7. Expected result 4 is obtained.
* 5.Call the Ctrl interface, ctx is not NULL, and set aad. Expected result 5 is obtained.
* 6.Call the Update interface, ctx is not NULL, and plain len is 7. Expected result 6 is obtained.
* 7.Call the Ctrl interface, ctx is not NULL, and get tag. Expected result 7 is obtained.
* 8.Call the Ctrl interface, ctx is not NULL, and get tag. Expected result 8 is obtained.
* 9.Call the Reinit interface, ctx is not NULL, iv is not NULL, and ivLen is 8. Expected result 9 is obtained.
* 10.Call the Ctrl interface, ctx is not NULL, and get tag. Expected result 10 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Success. Return CRYPT_SUCCESS.
* 4.Success. Return CRYPT_SUCCESS.
* 5.Success. Return CRYPT_SUCCESS.
* 6.Success. Return CRYPT_SUCCESS.
* 7.Success. Return CRYPT_SUCCESS.
* 8.Failed. Return CRYPT_EAL_ERR_STATE.
* 9.Success. Return CRYPT_SUCCESS.
* 10.Success. Return CRYPT_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_CCM_CTRL_API_TC005(int id, int keyLen)
{
TestMemInit();
uint8_t key[32] = { 0 };
uint8_t iv[8] = { 0 };
uint32_t ivLen = sizeof(iv);
uint8_t aad[10] = { 0 };
uint8_t tag[16] = { 0 };
uint8_t cmpTag[16] = { 0 };
uint32_t tagLen;
uint64_t count = 0;
uint8_t data[20] = { 0 };
uint8_t out[16] = { 0 };
uint32_t outLen = sizeof(out);
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(id);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true) == CRYPT_SUCCESS);
tagLen = 8;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
count = 7;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data, 7, out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, cmpTag, tagLen), CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, iv, ivLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_CCM_CTRL_API_TC006
* @title CRYPT_EAL_CipherCtrl interface get tag Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the Ctrl interface, ctx is not NULL, and msg len is 20. Expected result 3 is obtained.
* 4.Call the Ctrl interface, ctx is not NULL, and plain len is 20. Expected result 4 is obtained.
* 5.Call the Reinit interface, ctx is not NULL, iv is not NULL, and ivLen is 8. Expected result 5 is obtained.
* 6.Call the Ctrl interface, ctx is not NULL, and msg len is 40. Expected result 6 is obtained.
* 7.Call the Ctrl interface, ctx is not NULL, and plain len is 30. Expected result 7 is obtained.
* 8.Call the Ctrl interface, ctx is not NULL, and tag len is 10. Expected result 8 is obtained.
* 9.Call the Ctrl interface, ctx is not NULL, and get tag. Expected result 9 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Success. Return CRYPT_SUCCESS.
* 4.Success. Return CRYPT_SUCCESS.
* 5.Success. Return CRYPT_SUCCESS.
* 6.Success. Return CRYPT_SUCCESS.
* 7.Success. Return CRYPT_SUCCESS.
* 8.Failed. Return CRYPT_EAL_ERR_STATE.
* 9.Failed. Return CRYPT_MODES_MSGLEN_LEFT_ERROR.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_CCM_CTRL_API_TC006(int id, int keyLen)
{
TestMemInit();
uint8_t key[32] = { 0 };
uint8_t iv[8] = { 0 };
uint32_t ivLen = sizeof(iv);
uint8_t tag[16] = { 0 };
uint32_t tagLen = sizeof(tag);
uint64_t count = 0;
uint8_t data[40] = { 0 };
uint32_t dataLen = 0;
uint8_t out[40] = { 0 };
uint32_t outLen = sizeof(out);
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(id);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true) == CRYPT_SUCCESS);
count = 20;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)) == CRYPT_SUCCESS);
dataLen = 20;
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data, dataLen, out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, iv, ivLen) == CRYPT_SUCCESS);
count = 40;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)) == CRYPT_SUCCESS);
outLen = sizeof(out);
dataLen = 30;
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data, dataLen, out, &outLen) == CRYPT_SUCCESS);
tagLen = 10;
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)), CRYPT_EAL_ERR_STATE);
tagLen = 16;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen) == CRYPT_MODES_MSGLEN_LEFT_ERROR);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_CCM_UPDATE_FUNC_TC001
* @title AES CCM update encryption and decryption Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx.
* 2.Call the Init interface.
* 3.Call the Reinit interface.
* 4.Call the Ctrl interface, set msg len, tag len and aad.
* 5.Call the Update interface, ctx is not NULL, and encrypt data. Expected result 1 is obtained.
* 6.Call the Ctrl interface, ctx is not NULL, and get tag. Expected result 2 is obtained.
* 7.Call the Init interface.
* 8.Call the Reinit interface.
* 9.Call the Ctrl interface, set msg len, tag len and aad.
* 10.Call the Update interface, ctx is not NULL, and decrypt data. Expected result 3 is obtained.
* 11.Call the Ctrl interface, ctx is not NULL, and get tag. Expected result 4 is obtained.
* @expect
* 1.Success. Return CRYPT_SUCCESS.
* 2.Success. Return CRYPT_SUCCESS.
* 3.Success. Return CRYPT_SUCCESS.
* 4.Success. Return CRYPT_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_CCM_UPDATE_FUNC_TC001(int isProvider, int id, Hex *key, Hex *iv, Hex *aad,
Hex *plaintext, Hex *ciphertext)
{
#ifndef HITLS_CRYPTO_CCM
SKIP_TEST();
#endif
TestMemInit();
uint8_t iv0[8] = { 0 };
uint8_t tag[16] = { 0 };
uint32_t tagLen = sizeof(tag);
uint64_t count;
uint8_t out[1024] = { 0 };
uint32_t outLen = sizeof(out);
CRYPT_EAL_CipherCtx *ctx = TestCipherNewCtx(NULL, id, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
// encrypt
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv0, sizeof(iv0), true), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, iv->x, iv->len) == CRYPT_SUCCESS);
count = plaintext->len;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)) == CRYPT_SUCCESS);
tagLen = ciphertext->len - plaintext->len;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, plaintext->x, plaintext->len, out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen) == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(out, ciphertext->x, outLen) == 0);
ASSERT_TRUE(memcmp(tag, ciphertext->x + outLen, tagLen) == 0);
// decrypt
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv0, sizeof(iv0), false), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, iv->x, iv->len) == CRYPT_SUCCESS);
count = plaintext->len;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)) == CRYPT_SUCCESS);
tagLen = ciphertext->len - plaintext->len;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, ciphertext->x, plaintext->len, out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen) == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(out, plaintext->x, outLen) == 0);
ASSERT_TRUE(memcmp(tag, ciphertext->x + outLen, tagLen) == 0);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_CCM_CTRL_API_TC007
* @title CRYPT_EAL_CipherCtrl state switching Test
* @precon Registering memory-related functions.
* @brief
* 1.Call the Reinit interface and then Call the Ctrl interface to get tag. Expected result 1 is obtained.
* 2.Call the update interface and then Call the Ctrl interface to get tag. Expected result 2 is obtained.
* 3.Call the Init interface and then Call the Ctrl interface to get tag. Expected result 3 is obtained.
* 4.Call the Init and the Deinit interface, and then Call the Init interface. Expected result 4 is obtained.
* 5.Call the Ctrl interface to get tag. Expected result 5 is obtained.
* 6.Call the Init and the Deinit interface, and then Call the Ctrl interface to get tag. Expected result 6 is obtained.
* 7.Call the Init interface and the Reinit interface, then Call the Deinit interface,
* and then Call the Ctrl interface to get tag. Expected result 7 is obtained.
* 8.Call the Init interface, call the Ctrl interface set aad, set tag len. Expected result 8 is obtained.
* 9.Call the Init interface, call the Ctrl interface set msglen, and call Update interface and Reinit interface,
* and then call the Ctrl interface get tag. Expected result 9 is obtained.
* 10.Call the Init interface, call the Ctrl interface set msglen, call the update interface for encryption,
* and then call the Ctrl interface set msglen. Expected result 10 is obtained,
* 11.Call the Ctrl interface get tag. Expected result 11 is obtained.
* 12.Call the Init interface, call the Ctrl interface set msglen, call the update interface for encryption,
* and then call the Ctrl interface set aad. Expected result 12 is obtained,
* 13.Call the Ctrl interface get tag. Expected result 13 is obtained.
* 14.Call the Init interface, call the ctrl interface set msglen, call the update interface for encryption,
* and then call the Ctrl interface set taglen. Expected result 14 is obtained,
* 15.Call the Ctrl interface get tag. Expected result 15 is obtained.
* @expect
* 1.Success. Return CRYPT_SUCCESS.
* 2.Success. Return CRYPT_SUCCESS.
* 3.Success. Return CRYPT_SUCCESS.
* 4.Failed. Return CRYPT_EAL_ERR_STATE.
* 5.Failed. Return CRYPT_EAL_ERR_STATE.
* 6.Failed. Return CRYPT_EAL_ERR_STATE.
* 7.Failed. Return CRYPT_EAL_ERR_STATE.
* 9.Success. Return CRYPT_SUCCESS.
* 10.Failed. Return CRYPT_EAL_ERR_STATE.
* 11.Success. Return CRYPT_SUCCESS.
* 12.Failed. Return CRYPT_EAL_ERR_STATE.
* 13.Success. Return CRYPT_SUCCESS.
* 14.Failed. Return CRYPT_EAL_ERR_STATE.
* 15.Success. Return CRYPT_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_CCM_CTRL_API_TC007(int id, int keyLen)
{
TestMemInit();
uint8_t key[32] = { 0 };
uint8_t iv[8] = { 0 };
uint32_t ivLen = sizeof(iv);
uint8_t tag[16] = { 0 };
uint32_t tagLen = sizeof(tag);
uint64_t count = 0;
uint8_t data[40] = { 0 };
uint8_t out[40] = { 0 };
uint8_t aad[40] = { 0 };
uint32_t outLen = sizeof(out);
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(id);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherReinit(ctx, iv, ivLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherUpdate(ctx, data, 0, out, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);
CRYPT_EAL_CipherDeinit(ctx);
ASSERT_EQ(CRYPT_EAL_CipherReinit(ctx, iv, ivLen), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);
CRYPT_EAL_CipherDeinit(ctx);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherReinit(ctx, iv, ivLen), CRYPT_SUCCESS);
CRYPT_EAL_CipherDeinit(ctx);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherUpdate(ctx, data, 0, out, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherReinit(ctx, iv, ivLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherUpdate(ctx, data, 0, out, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherUpdate(ctx, data, 0, out, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherUpdate(ctx, data, 0, out, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_CCM_UPDATE_FUNC_TC002
* @title Test on the same address in plaintext and ciphertext
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the Ctrl interface, ctx is not NULL, and set tag len. Expected result 3 is obtained.
* 4.Call the Ctrl interface, ctx is not NULL, and set msg len. Expected result 4 is obtained.
* 5.Call the Ctrl interface, ctx is not NULL, and set aad. Expected result 5 is obtained.
* 6.Call the Update interface, ctx is not NULL, and encrypt data. Expected result 6 is obtained.
* 7.Compare the ciphertext. Expected result 7 is obtained.
* 8.Compare the tag. Expected result 8 is obtained.
* 9.Call the Deinit interface and Call the Init interface. Expected result 9 is obtained.
* 10.Call the Ctrl interface set tag len. Expected result 10 is obtained.
* 11.Call the Ctrl interface set msg len. Expected result 11 is obtained.
* 12.Call the Ctrl interface set aad. Expected result 12 is obtained.
* 13.Call the Update interface to decrypt data. Expected result 13 is obtained.
* 14.Compare the plaintext. Expected result 14 is obtained.
* 15.Compare the tag. Expected result 15 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.Success. Return CRYPT_SUCCESS.
* 3.Success. Return CRYPT_SUCCESS.
* 4.Success. Return CRYPT_SUCCESS.
* 5.Success. Return CRYPT_SUCCESS.
* 6.Success. Return CRYPT_SUCCESS.
* 7.Consistent with expected vector.
* 8.Consistent with expected vector.
* 9.Success, Return CRYPT_SUCCESS
* 10.Success, Return CRYPT_SUCCESS
* 11.Success, Return CRYPT_SUCCESS
* 12.Success, Return CRYPT_SUCCESS
* 13.Success, Return CRYPT_SUCCESS
* 14.Consistent with expected vector.
* 15.Consistent with expected vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_CCM_UPDATE_FUNC_TC002(int algId, Hex *key, Hex *iv, Hex *aad, Hex *pt,
Hex *ct, Hex *tag)
{
#ifndef HITLS_CRYPTO_CCM
SKIP_TEST();
#endif
TestMemInit();
CRYPT_EAL_CipherCtx *ctx = NULL;
uint8_t *outTag = NULL;
uint8_t *out = NULL;
uint32_t tagLen = tag->len;
uint32_t outLen = pt->len;
uint64_t msgLen = pt->len;
out = (uint8_t *)malloc(outLen * sizeof(uint8_t));
ASSERT_TRUE(out != NULL);
outTag = (uint8_t *)malloc(sizeof(uint8_t) * tagLen);
ASSERT_TRUE(outTag != NULL);
ASSERT_TRUE(memcpy_s(out, outLen, pt->x, pt->len) == EOK);
ctx = CRYPT_EAL_CipherNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &msgLen, sizeof(msgLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, out, pt->len, (uint8_t *)out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("Compare Ct", out, ct->len, ct->x, ct->len);
ASSERT_COMPARE("Compare Enc Tag", outTag, tagLen, tag->x, tag->len);
CRYPT_EAL_CipherDeinit(ctx);
ASSERT_TRUE(memcpy_s(out, outLen, ct->x, ct->len) == EOK);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, false) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &msgLen, sizeof(msgLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, out, ct->len, (uint8_t *)out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("Compare Pt", out, pt->len, pt->x, pt->len);
ASSERT_COMPARE("Compare Dec Tag", outTag, tagLen, tag->x, tag->len);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
free(out);
free(outTag);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_CCM_MULTI_THREAD_FUNC_TC001
* @title Multi-thread Test
* @precon Registering memory-related functions.
* @brief
* 1.Start three threads. Expected result 1 is obtained.
* 2.Call the eal interface in the thread for encryption. Expected result 2 is obtained.
* 3.Call the eal interface in the thread for decryption. Expected result 2 is obtained.
* @expect
* 1.Success.
* 2.The encryption is successful. The ciphertext and tag are the same as the vector.
* 3.The decryption is successful. The plaintext and tag are consistent with the vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_CCM_MULTI_THREAD_FUNC_TC001(int isProvider, int algId, Hex *key, Hex *iv, Hex *aad,
Hex *pt, Hex *ct, Hex *tag)
{
int ret;
TestMemInit();
const uint32_t threadNum = 3; // Number of threads.
pthread_t thrd[threadNum];
ThreadParameter arg[3] = {
// 3 Threads
{.key = key->x, .iv = iv->x, .aad = aad->x, .pt = pt->x, .ct = ct->x, .tag = tag->x,
.keyLen = key->len, .ivLen = iv->len, .aadLen = aad->len,
.ptLen = pt->len, .ctLen = ct->len, .tagLen = tag->len,
.algId = algId, .isProvider = isProvider},
{.key = key->x, .iv = iv->x, .aad = aad->x, .pt = pt->x, .ct = ct->x, .tag = tag->x,
.keyLen = key->len, .ivLen = iv->len, .aadLen = aad->len,
.ptLen = pt->len, .ctLen = ct->len, .tagLen = tag->len,
.algId = algId, .isProvider = isProvider},
{.key = key->x, .iv = iv->x, .aad = aad->x, .pt = pt->x, .ct = ct->x, .tag = tag->x,
.keyLen = key->len, .ivLen = iv->len, .aadLen = aad->len,
.ptLen = pt->len, .ctLen = ct->len, .tagLen = tag->len,
.algId = algId, .isProvider = isProvider},
};
for (uint32_t i = 0; i < threadNum; i++) {
ret = pthread_create(&thrd[i], NULL, (void *)MultiThreadTest, &arg[i]);
ASSERT_TRUE(ret == 0);
}
for (uint32_t i = 0; i < threadNum; i++) {
pthread_join(thrd[i], NULL);
}
EXIT:
return;
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/aes/test_suite_sdv_eal_aes_ccm.c | C | unknown | 42,413 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include <string.h>
#include "securec.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "crypt_modes_gcm.h"
#include "crypt_local_types.h"
#include "crypt_aes.h"
#include "crypt_eal_cipher.h"
#define FREE(res) \
do { \
if ((res) != NULL) { \
free(res); \
} \
} while (0)
/* END_HEADER */
/**
* @test SDV_CRYPTO_AES_GCM_UPDATE_FUNC_TC001
* @title AES-GCM decryption full vector test
* @precon Registering memory-related functions.
* @brief
* 1.Call the Init interface. Expected result 1 is obtained.
* 2.Call the Ctrl interface to set parameters. Expected result 2 is obtained.
* 3.Call the update interface to update message. Expected result 3 is obtained.
* 4.Call the Ctrl interface to get tag. Expected result 4 is obtained.
* 5.Compare the plaintext data. Expected result 5 is obtained.
* 6.Compare the tag data. Expected result 6 is obtained.
* @expect
* 1.The init is successful, return CRYPT_SUCCESS.
* 2.The setting is successful, return CRYPT_SUCCESS.
* 3.The update is successful, return CRYPT_SUCCESS.
* 4.The getting is successful, return CRYPT_SUCCESS.
* 5.Plaintext is consistent with the test vector.
* 6.Tag is consistent with the test vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_GCM_UPDATE_FUNC_TC001(int isProvider, int algId, Hex *key, Hex *iv,
Hex *aad, Hex *pt, Hex *ct, Hex *tag, int result)
{
#ifndef HITLS_CRYPTO_GCM
SKIP_TEST();
#endif
TestMemInit();
CRYPT_EAL_CipherCtx *ctx = NULL;
uint8_t *outTag = NULL;
uint8_t *out = NULL;
uint32_t tagLen = tag->len;
uint32_t outLen;
if (ct->len > 0) {
out = (uint8_t *)BSL_SAL_Malloc(ct->len * sizeof(uint8_t));
outLen = ct->len * sizeof(uint8_t);
ASSERT_TRUE(out != NULL);
} else {
out = (uint8_t *)BSL_SAL_Malloc(1 * sizeof(uint8_t));
outLen = 1 * sizeof(uint8_t);
ASSERT_TRUE(out != NULL);
}
ctx = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, false) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, ct->x, ct->len, (uint8_t *)out, &outLen) == CRYPT_SUCCESS);
outTag = (uint8_t *)BSL_SAL_Malloc(sizeof(uint8_t) * tagLen);
ASSERT_TRUE(outTag != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
if (pt->x != NULL) {
ASSERT_TRUE(memcmp(out, pt->x, pt->len) == 0);
}
if (result == 0) {
ASSERT_COMPARE("Compare Tag", outTag, tagLen, tag->x, tag->len);
} else {
ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) != 0);
}
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
FREE(out);
FREE(outTag);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_GCM_UPDATE_FUNC_TC002
* @title AES-GCM encryption full vector test
* @precon Registering memory-related functions.
* @brief
* 1.Call the Init interface. Expected result 1 is obtained.
* 2.Call the Ctrl interface to set parameters. Expected result 2 is obtained.
* 3.Call the update interface to update message. Expected result 3 is obtained.
* 4.Call the Ctrl interface to get tag. Expected result 4 is obtained.
* 5.Compare the ciphertext data. Expected result 5 is obtained.
* 6.Compare the tag data. Expected result 6 is obtained.
* @expect
* 1.The init is successful, return CRYPT_SUCCESS.
* 2.The setting is successful, return CRYPT_SUCCESS.
* 3.The update is successful, return CRYPT_SUCCESS.
* 4.The getting is successful, return CRYPT_SUCCESS.
* 5.Ciphertext is consistent with the test vector.
* 6.Tag is consistent with the test vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_GCM_UPDATE_FUNC_TC002(int isProvider, int algId, Hex *key, Hex *iv, Hex *aad, Hex *pt, Hex *ct, Hex *tag)
{
#ifndef HITLS_CRYPTO_GCM
SKIP_TEST();
#endif
TestMemInit();
CRYPT_EAL_CipherCtx *ctx = NULL;
uint8_t *outTag = NULL;
uint8_t *out = NULL;
uint32_t tagLen = tag->len;
uint32_t outLen;
if (ct->len > 0) {
out = (uint8_t *)BSL_SAL_Malloc(ct->len * sizeof(uint8_t));
outLen = ct->len * sizeof(uint8_t);
ASSERT_TRUE(out != NULL);
} else {
out = (uint8_t *)BSL_SAL_Malloc(1 * sizeof(uint8_t));
outLen = 1 * sizeof(uint8_t);
ASSERT_TRUE(out != NULL);
}
ctx = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, pt->x, pt->len, (uint8_t *)out, &outLen) == CRYPT_SUCCESS);
outTag = (uint8_t *)BSL_SAL_Malloc(sizeof(uint8_t) * tagLen);
ASSERT_TRUE(outTag != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
if (ct->x != NULL) {
ASSERT_TRUE(memcmp(out, ct->x, ct->len) == 0);
}
ASSERT_COMPARE("Compare Tag", outTag, tagLen, tag->x, tag->len);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
FREE(out);
FREE(outTag);
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/aes/test_suite_sdv_eal_aes_gcm.c | C | unknown | 6,263 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include <string.h>
#include "securec.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "crypt_modes_gcm.h"
#include "crypt_local_types.h"
#include "crypt_aes.h"
#include "crypt_eal_cipher.h"
#include "eal_cipher_local.h"
#define DATA_LEN 16
#define DATA_MAX_LEN 1024
#define MAX_OUTPUT 50000
/* END_HEADER */
/**
* @test SDV_CRYPTO_AES_MULTI_UPDATE_FUNC_TC001
* @title Impact of two updates on the encryption and decryption functions
* @precon Registering memory-related functions.
* @brief
* 1.Call the EAL interface to encrypt a piece of data twice, and then verify the encryption result and tag. Expected result 1 is obtained.
* 2.Call the EAL interface to decrypt a piece of data twice, and check the decryption result and tag. Expected result 2 is obtained.
* @expect
* 1.The encryption result and tag value are the same as expected, the verification is successful.
* 2.The decryption result and tag value are the same as expected, the verification is successful.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_MULTI_UPDATE_FUNC_TC001(int algId, Hex *key, Hex *iv, Hex *aad, Hex *pt1, Hex *pt2, Hex *ct, Hex *tag)
{
if (IsCipherAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
CRYPT_EAL_CipherCtx *ctx = NULL;
uint32_t tagLen = tag->len;
uint8_t result[DATA_MAX_LEN];
uint8_t tagResult[DATA_LEN];
uint32_t outLen = DATA_MAX_LEN;
ctx = CRYPT_EAL_CipherNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, pt1->x, pt1->len, result, &outLen) == CRYPT_SUCCESS);
outLen = DATA_MAX_LEN - pt1->len;
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, pt2->x, pt2->len, result + pt1->len, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)tagResult, tag->len) == CRYPT_SUCCESS);
ASSERT_COMPARE("enc result", (uint8_t *)result, pt1->len + pt2->len, ct->x, ct->len);
ASSERT_COMPARE("enc tagResult", (uint8_t *)tagResult, tag->len, tag->x, tag->len);
CRYPT_EAL_CipherFreeCtx(ctx);
ctx = CRYPT_EAL_CipherNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, false) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
(void)memset_s(result, sizeof(result), 0, sizeof(result));
(void)memset_s(tagResult, sizeof(tagResult), 0, sizeof(tagResult));
outLen = DATA_MAX_LEN;
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, ct->x, pt1->len, result, &outLen) == CRYPT_SUCCESS);
outLen = DATA_MAX_LEN - pt1->len;
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, ct->x + pt1->len, pt2->len, result + pt1->len, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)tagResult, tag->len) == CRYPT_SUCCESS);
ASSERT_COMPARE("dec result1", (uint8_t *)result, pt1->len, pt1->x, pt1->len);
ASSERT_COMPARE("dec result2", (uint8_t *)result + pt1->len, pt2->len, pt2->x, pt2->len);
ASSERT_COMPARE("dec tagResult", (uint8_t *)tagResult, tag->len, tag->x, tag->len);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_MULTI_UPDATE_FUNC_TC002
* @title Impact of three updates on the encryption function
* @precon Registering memory-related functions.
* @brief
* 1.Call the EAL interface to encrypt a piece of data for three times, and then verify the encryption result and tag. Expected result 1 is obtained.
* 2.Call the EAL interface to decrypt a piece of data for three times, and then verify the decryption result and tag. Expected result 2 is obtained.
* @expect
* 1.The encryption result and tag value are the same as expected, the verification is successful.
* 2.The decryption result and tag value are the same as expected, the verification is successful.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_MULTI_UPDATE_FUNC_TC002(int isProvider, int algId, Hex *key, Hex *iv, Hex *aad, Hex *pt1,
Hex *pt2, Hex *pt3, Hex *ct, Hex *tag)
{
TestMemInit();
CRYPT_EAL_CipherCtx *ctx = NULL;
CRYPT_EAL_CipherCtx *decCtx = NULL;
uint32_t tagLen = tag->len;
uint8_t result[DATA_MAX_LEN];
uint8_t tagResult[tagLen];
uint32_t outLen = DATA_MAX_LEN;
uint64_t count;
ctx = (isProvider == 0) ? CRYPT_EAL_CipherNewCtx(algId) :
CRYPT_EAL_ProviderCipherNewCtx(NULL, algId, "provider=default");
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true) == CRYPT_SUCCESS);
if (algId == CRYPT_CIPHER_AES128_CCM || algId == CRYPT_CIPHER_AES192_CCM || algId == CRYPT_CIPHER_AES256_CCM) {
count = pt1->len + pt2->len + pt3->len;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)) == CRYPT_SUCCESS);
}
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, pt1->x, pt1->len, result, &outLen) == CRYPT_SUCCESS);
outLen = DATA_MAX_LEN - pt1->len;
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, pt2->x, pt2->len, result + pt1->len, &outLen) == CRYPT_SUCCESS);
outLen = DATA_MAX_LEN - pt1->len - pt2->len;
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, pt3->x, pt3->len, result + pt1->len + pt2->len, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)tagResult, tag->len) == CRYPT_SUCCESS);
ASSERT_COMPARE("enc result", (uint8_t *)result, pt1->len + pt2->len + pt3->len, ct->x, ct->len);
ASSERT_COMPARE("enc tagResult", (uint8_t *)tagResult, tag->len, tag->x, tag->len);
(void)memset_s(result, sizeof(result), 0, sizeof(result));
(void)memset_s(tagResult, sizeof(tagResult), 0, sizeof(tagResult));
outLen = DATA_MAX_LEN;
tagLen = tag->len;
// decrypt
decCtx = CRYPT_EAL_CipherNewCtx(algId);
ASSERT_TRUE(CRYPT_EAL_CipherInit(decCtx, key->x, key->len, iv->x, iv->len, false) == CRYPT_SUCCESS);
if (algId == CRYPT_CIPHER_AES128_CCM || algId == CRYPT_CIPHER_AES192_CCM || algId == CRYPT_CIPHER_AES256_CCM) {
count = ct->len;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(decCtx, CRYPT_CTRL_SET_MSGLEN, &count, sizeof(count)) == CRYPT_SUCCESS);
}
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(decCtx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(decCtx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(decCtx, ct->x, pt1->len, result, &outLen) == CRYPT_SUCCESS);
outLen = DATA_MAX_LEN - pt1->len;
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(decCtx, ct->x + pt1->len, pt2->len, result + pt1->len, &outLen) == CRYPT_SUCCESS);
outLen = DATA_MAX_LEN - pt1->len - pt2->len;
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(decCtx, ct->x + pt1->len + pt2->len, pt3->len, result + pt1->len + pt2->len, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(decCtx, CRYPT_CTRL_GET_TAG, (uint8_t *)tagResult, tag->len) == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(result, pt1->x, pt1->len) == 0);
ASSERT_TRUE(memcmp(result + pt1->len, pt2->x, pt2->len) == 0);
ASSERT_TRUE(memcmp(result + pt1->len + pt2->len, pt3->x, pt3->len) == 0);
ASSERT_TRUE(memcmp(tagResult, tag->x, tag->len) == 0);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
CRYPT_EAL_CipherFreeCtx(decCtx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_GETINFO_API_TC001
* @title CRYPT_EAL_CipherGetInfo Checking the Algorithm Grouping Mode Function Test
* @precon Registering memory-related functions.
* @brief
* 1.Call the GetInfo interface with a correct ID, set type to CRYPT_INFO_IS_AEAD, and set infoStatus to NULL. Expected result 1 is obtained.
* 2.Call the GetInfo interface with a wrong ID, set type to CRYPT_INFO_IS_AEAD, and set infoStatus to not NULL. Expected result 2 is obtained.
* 3.Call the GetInfo interface with ID CRYPT_CIPHER_AES128_CCM, set type to CRYPT_INFO_MAX, and set infoStatus to not NULL. Expected result 3 is obtained.
* 4.Call the GetInfo interface with ID CRYPT_CIPHER_AES128_CCM, set type to CRYPT_INFO_IS_AEAD, and set infoStatus to not NULL. Expected result 4 is obtained.
* 5.Call the GetInfo interface with ID CRYPT_CIPHER_AES128_CFB, set type to CRYPT_INFO_IS_AEAD, and set infoStatus to not NULL. Expected result 5 is obtained.
* 6.Call the GetInfo interface with ID CRYPT_CIPHER_AES128_CCM, set type to CRYPT_INFO_IS_STREAM, and set infoStatus to not NULL. Expected result 6 is obtained.
* 7.Call the GetInfo interface with ID CRYPT_CIPHER_SM4_CBC, set type to CRYPT_INFO_IS_STREAM, and set infoStatus to not NULL. Expected result 7 is obtained.
* 8.Call the GetInfo interface with ID CRYPT_CIPHER_AES128_CBC, set type to CRYPT_INFO_IV_LEN. Expected result 8 is obtained.
* 9.Call the GetInfo interface with ID CRYPT_CIPHER_AES192_CBC, set type to CRYPT_INFO_KEY_LEN. Expected result 9 is obtained.
* @expect
* 1.Failed. Return CRYPT_INVALID_ARG.
* 2.Failed. Return CRYPT_ERR_ALGID.
* 3.Failed. Return CRYPT_EAL_INTO_TYPE_NOT_SUPPORT.
* 4.Success. Return CRYPT_SUCCESS, infoStatus is 0.
* 5.Success. Return CRYPT_SUCCESS, infoStatus is 1.
* 6.Success. Return CRYPT_SUCCESS, infoStatus is 1.
* 7.Success. Return CRYPT_SUCCESS, infoStatus is 0.
* 8.Success. Return CRYPT_SUCCESS, ivLen is 16.
* 9.Success. Return CRYPT_SUCCESS, keyLen is 24.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_GETINFO_API_TC001(void)
{
TestMemInit();
uint32_t infoStatus = 0;
ASSERT_TRUE(CRYPT_EAL_CipherGetInfo(CRYPT_CIPHER_AES128_CCM, CRYPT_INFO_IS_AEAD, NULL) == CRYPT_INVALID_ARG);
ASSERT_TRUE(CRYPT_EAL_CipherGetInfo(CRYPT_CIPHER_MAX, CRYPT_INFO_IS_AEAD, &infoStatus) == CRYPT_ERR_ALGID);
ASSERT_TRUE(CRYPT_EAL_CipherGetInfo(CRYPT_CIPHER_AES128_CCM, CRYPT_INFO_MAX,
&infoStatus) == CRYPT_EAL_INTO_TYPE_NOT_SUPPORT);
ASSERT_TRUE(CRYPT_EAL_CipherGetInfo(CRYPT_CIPHER_AES128_CCM, CRYPT_INFO_IS_AEAD, &infoStatus) == CRYPT_SUCCESS);
ASSERT_TRUE(infoStatus == 1);
ASSERT_TRUE(CRYPT_EAL_CipherGetInfo(CRYPT_CIPHER_AES128_CFB, CRYPT_INFO_IS_AEAD, &infoStatus) == CRYPT_SUCCESS);
ASSERT_TRUE(infoStatus == 0);
ASSERT_TRUE(CRYPT_EAL_CipherGetInfo(CRYPT_CIPHER_AES128_CCM, CRYPT_INFO_IS_STREAM, &infoStatus) == CRYPT_SUCCESS);
ASSERT_TRUE(infoStatus == 1);
ASSERT_TRUE(CRYPT_EAL_CipherGetInfo(CRYPT_CIPHER_SM4_CBC, CRYPT_INFO_IS_STREAM, &infoStatus) == CRYPT_SUCCESS);
ASSERT_TRUE(infoStatus == 0);
uint32_t ivLen = 0;
ASSERT_TRUE(CRYPT_EAL_CipherGetInfo(CRYPT_CIPHER_AES128_CBC, CRYPT_INFO_IV_LEN, &ivLen) == CRYPT_SUCCESS);
ASSERT_TRUE(ivLen == 16);
uint32_t keyLen = 0;
ASSERT_TRUE(CRYPT_EAL_CipherGetInfo(CRYPT_CIPHER_AES192_CBC, CRYPT_INFO_KEY_LEN, &keyLen) == CRYPT_SUCCESS);
ASSERT_TRUE(keyLen == 24);
EXIT:
return;
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/aes/test_suite_sdv_eal_cipher.c | C | unknown | 12,007 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include "securec.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "crypt_bn.h"
#include "bn_basic.h"
#include "crypt_eal_rand.h"
#include "crypt_util_rand.h"
#include "crypto_test_util.h"
#if defined(HITLS_SIXTY_FOUR_BITS)
#define BN_UINT_MAX UINT64_MAX
#define BN_DIGITS_MAX 65
#define DH_BN_DIGITS_MAX 129
#elif defined(HITLS_THIRTY_TWO_BITS)
#define BN_UINT_MAX UINT32_MAX
#define BN_DIGITS_MAX 65 * 2
#define DH_BN_DIGITS_MAX 129 * 2
#else
#error
#endif
#define BITS_OF_BYTE 8
#define BIGNUM_REDUNDANCY_BITS 64
#define LONG_BN_BYTES_32 32
#define SHORT_BN_BITS_128 128
#define LONG_BN_BITS_256 256
#define UINT8_MAX_NUM 255
#define BN_SIZE 1024
extern int32_t ModExpInputCheck(
const BN_BigNum *r, const BN_BigNum *a, const BN_BigNum *e, const BN_BigNum *m, const BN_Optimizer *opt);
extern int32_t ModExpCore(BN_BigNum *x, BN_BigNum *y, const BN_BigNum *e, const BN_BigNum *m, BN_Optimizer *opt);
extern int32_t BnGcdCheckInput(const BN_BigNum *r, const BN_BigNum *a, const BN_BigNum *b, const BN_Optimizer *opt);
extern int32_t InverseInputCheck(const BN_BigNum *r, const BN_BigNum *x, const BN_BigNum *m, const BN_Optimizer *opt);
static int32_t TEST_Random(uint8_t *r, uint32_t randLen)
{
for (uint32_t i = 0; i < randLen; i++) {
r[i] = rand() % UINT8_MAX_NUM;
}
return 0;
}
static int32_t TEST_RandomEx(void *libCtx, uint8_t *r, uint32_t randLen)
{
(void) libCtx;
for (uint32_t i = 0; i < randLen; i++) {
r[i] = rand() % UINT8_MAX_NUM;
}
return 0;
}
uint32_t TEST_GetMax(uint32_t num1, uint32_t num2, uint32_t num3)
{
uint32_t res = num1;
res = (res > num2) ? res : num2;
res = (res > num3) ? res : num3;
return res;
}
BN_BigNum *TEST_VectorToBN(int sign, uint8_t *buff, uint32_t length)
{
if (length == 0) {
return NULL;
}
BN_BigNum *bn = BN_Create(length * 8); // 8 bits per byte
if (bn != NULL) {
if (BN_Bin2Bn(bn, buff, length) != CRYPT_SUCCESS) {
BN_Destroy(bn);
bn = NULL;
} else {
BN_SetSign(bn, sign != 0);
}
}
return bn;
}
void TEST_RegSimpleRand(void)
{
CRYPT_RandRegist(TestSimpleRand);
}
int32_t TEST_BnTestCaseInit(void)
{
TEST_RegSimpleRand();
TestMemInit();
return CRYPT_SUCCESS;
}
/* END_HEADER */
/**
* @test SDV_CRYPTO_BN_CREATE_API_TC001
* @title BN_Create: Invalid parameter.
* @precon nan
* @brief
* 1. Call the BN_Create method, input parameter is BN_MAX_BITS + 1, expected result 1
* 2. Call the BN_Create method, input parameter is 0, expected result 2
* @expect
* 1. Return NULL.
* 2. Return non-NULL.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_CREATE_API_TC001(void)
{
BN_BigNum *bn = NULL;
TestMemInit();
bn = BN_Create((1u << 29) + 1); // BN_MAX_BITS + 1
ASSERT_TRUE(bn == NULL);
bn = BN_Create(0);
ASSERT_TRUE(bn != NULL);
EXIT:
BN_Destroy(bn);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_SETSIGN_API_TC001
* @title BN_SetSign: Test invalid parameters and normal functions.
* @precon nan
* @brief
* 1. Create BN_BigNum bn, the initial value is 0.
* 2. Call the BN_SetSign method, a is null, expected result 1
* 3. Call the BN_SetSign method, a is bn, sign is true, expected result 2
* 4. Set bn to 1, expected result 3
* 5. Call the BN_SetSign method, a is bn, sign is true/false, expected result 4
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_BN_NO_NEGATIVE_ZERO
* 3-4. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_SETSIGN_API_TC001(void)
{
BN_BigNum *bn = NULL;
TestMemInit();
ASSERT_TRUE(BN_SetSign(NULL, 0) == CRYPT_NULL_INPUT);
bn = BN_Create(BN_MAX_BITS);
ASSERT_TRUE(bn != NULL);
ASSERT_TRUE(BN_SetSign(bn, true) == CRYPT_BN_NO_NEGATIVE_ZERO);
ASSERT_TRUE(BN_SetLimb(bn, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SetSign(bn, false) == CRYPT_SUCCESS);
EXIT:
BN_Destroy(bn);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_COPY_API_TC001
* @title BN_Copy: The dest parameter space is smaller than src parameter.
* @precon nan
* @brief
* 1. Call the BN_Copy method, parameters are all, expected result 1
* 2. Create BN_BigNum bn a and r, the size of r is half of a, expected result 2
* 3. Call the BN_Copy method, copy a to r, expected result 3
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_SUCCESS
* 3. CRYPT_SUCCESS(Big number can be automatically expanded.)
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_COPY_API_TC001(void)
{
BN_BigNum *r = NULL;
BN_BigNum *a = NULL;
uint8_t buff[LONG_BN_BYTES_32] = {'F'};
TestMemInit();
ASSERT_TRUE(BN_Copy(NULL, NULL) == CRYPT_NULL_INPUT);
// r.room < a.bits
r = BN_Create(SHORT_BN_BITS_128);
ASSERT_TRUE(r != NULL);
// SHORT_BN_BYTES 16 = 32 / 2
ASSERT_TRUE(BN_Bin2Bn(r, buff, sizeof(buff) / 2) == CRYPT_SUCCESS);
a = BN_Create(LONG_BN_BITS_256);
ASSERT_TRUE(a != NULL);
ASSERT_TRUE(BN_Bin2Bn(a, buff, sizeof(buff)) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Copy(r, a) == CRYPT_SUCCESS);
EXIT:
BN_Destroy(r);
BN_Destroy(a);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_ZEROIZE_API_TC001
* @title BN_Zeroize: Invalid parameter.
* @precon nan
* @brief
* 1. Call the BN_Zeroize, parameter is null, expected result 1
* @expect
* 1. CRYPT_NULL_INPUT
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_ZEROIZE_API_TC001(void)
{
ASSERT_TRUE(BN_Zeroize(NULL) == CRYPT_NULL_INPUT);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_SETLIMB_API_TC001
* @title BN_SetLimb: Test invalid parameters and normal functions.
* @precon nan
* @brief
* 1. Create BN_BigNum bn.
* 2. Call the BN_SetLimb method, r is null, w is 0, expected result 1
* 3. Call the BN_SetLimb method, r is bn, w is 0, expected result 2
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_SETLIMB_API_TC001(void)
{
TestMemInit();
BN_BigNum *bn = BN_Create(1);
ASSERT_TRUE(BN_SetLimb(NULL, 0) == CRYPT_NULL_INPUT);
ASSERT_TRUE(BN_SetLimb(bn, 0) == CRYPT_SUCCESS);
EXIT:
BN_Destroy(bn);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_SETBIT_API_TC001
* @title BN_SetBit: Test invalid parameters and normal functions.
* @precon nan
* @brief
* 1. Create BN_BigNum bn.
* 2. Call the BN_SetBit method, a is null, n is 0, expected result 1
* 3. Call the BN_SetBit method, a is bn, n is invalid, expected result 2
* 4. Call the BN_SetBit method, a is bn, n is valid, expected result 3
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_BN_SPACE_NOT_ENOUGH
* 2. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_SETBIT_API_TC001(void)
{
TestMemInit();
BN_BigNum *bn = BN_Create(1);
ASSERT_TRUE(BN_SetBit(NULL, 0) == CRYPT_NULL_INPUT);
ASSERT_TRUE(BN_SetBit(bn, (uint32_t)sizeof(BN_UINT) << 3) == CRYPT_BN_SPACE_NOT_ENOUGH);
ASSERT_TRUE(BN_SetBit(bn, ((uint32_t)sizeof(BN_UINT) << 3) - 1) == CRYPT_SUCCESS);
EXIT:
BN_Destroy(bn);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_GETBIT_API_TC001
* @title BN_GetBit: Test invalid parameters and normal functions.
* @precon nan
* @brief
* 1. Call the BN_GetBit method, a is null, n is 0, expected result 1
* 2. Create BN_BigNum bn, bn = 0, expected result 2
* 3. Call the BN_GetBit method, get the first bit of bn, expected result 3
* 4. Set limb of bn to BN_UINT_MAX, expected result 4
* 5. Call the BN_GetBit method, Check whether the number of the specified bit is 1:
* (1) bit = limbBits - 1, expected result 5
* (1) bit = limbBits, expected result 6
* (1) bit = limbBits + 1, expected result 7
* @expect
* 1. Return 0.
* 2. CRYPT_SUCCESS
* 3. The first bit of bn is 0.
* 4. CRYPT_SUCCESS. The number of bits in the limb is limbBits.
* 5. true
* 6. false
* 7. false
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_GETBIT_API_TC001(void)
{
BN_BigNum *bn = NULL;
const int limbBits = sizeof(BN_UINT) * BITS_OF_BYTE;
ASSERT_TRUE(BN_GetBit(NULL, 0) == 0);
TestMemInit();
bn = BN_Create(SHORT_BN_BITS_128);
ASSERT_TRUE(bn != NULL);
// a = 0 , n = 0
ASSERT_TRUE(BN_SetLimb(bn, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_GetBit(bn, 0) == 0);
ASSERT_TRUE(BN_SetLimb(bn, BN_UINT_MAX) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_GetBit(bn, limbBits - 1) == true);
ASSERT_TRUE(BN_GetBit(bn, limbBits) == false);
ASSERT_TRUE(BN_GetBit(bn, limbBits + 1) == false);
EXIT:
BN_Destroy(bn);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_CLRBIT_API_TC001
* @title BN_ClrBit: Test invalid parameters and normal functions.
* @precon nan
* @brief
* 1. Call the BN_ClrBit method, a is null, n is 0, expected result 1
* 2. Create BN_BigNum bn, and set bn to -1, expected result 2
* 3. Call the BN_ClrBit method, set the lowest bit to 0, expected result 3
* 4. Set bn to 1, expected result 4
* 5. Call the BN_ClrBit method, a is bn, n is BN_UINT_BITS, expected result 5
* 6. Call the BN_ClrBit method, a is bn, n is valid, expected result 6
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_SUCCESS
* 3. CRYPT_SUCCESS, bn changed from - 1 to 0.
* 4. CRYPT_SUCCESS
* 5. CRYPT_BN_SPACE_NOT_ENOUGH
* 6. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_CLRBIT_API_TC001(void)
{
BN_BigNum *bn = NULL;
ASSERT_TRUE(BN_ClrBit(NULL, 0) == CRYPT_NULL_INPUT);
TestMemInit();
bn = BN_Create(BN_MAX_BITS);
/* bn = -1 */
ASSERT_TRUE(BN_SetLimb(bn, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SetSign(bn, 1) == CRYPT_SUCCESS);
/* Set the lowest bit to 0. */
ASSERT_TRUE(BN_ClrBit(bn, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_IsZero(bn));
ASSERT_TRUE(BN_IsNegative(bn) == false);
/* bn = 1 */
ASSERT_TRUE(BN_SetLimb(bn, 1) == CRYPT_SUCCESS);
ASSERT_EQ(BN_ClrBit(bn, ((uint32_t)sizeof(BN_UINT) << 3)), CRYPT_BN_SPACE_NOT_ENOUGH); // BN_UINT_BITS
ASSERT_TRUE(BN_ClrBit(bn, ((uint32_t)sizeof(BN_UINT) << 3) - 1) == CRYPT_SUCCESS); // BN_UINT_BITS - 1
EXIT:
BN_Destroy(bn);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_RSHIFT_FUNC_TC001
* @title BN_Rshift test.
* @precon Vectors: hex and its result after right-shifting n bits.
* @brief
* 1. Convert vectors to bn.
* 2. Call BN_Rshift, and compared the result with vector, expected result 1:
* (1) Pointer addresses for parameters are different from each other.
* (2) The address of the output parameter pointer r is the same as that of the input parameter pointer a.
* 3. Test the scenario where the output parameter space is insufficient, expected result 1.
* @expect
* 1. The calculation result is consistent with the vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_RSHIFT_FUNC_TC001(int sign, Hex *hex, int n, int signRes, Hex *result)
{
TestMemInit();
BN_BigNum *r = NULL;
BN_BigNum *q = NULL;
BN_BigNum *p = NULL;
BN_BigNum *a = TEST_VectorToBN(sign, hex->x, hex->len);
BN_BigNum *res = TEST_VectorToBN(signRes, result->x, result->len);
ASSERT_TRUE(a != NULL && res != NULL);
r = BN_Create(BN_Bits(a) + BIGNUM_REDUNDANCY_BITS);
ASSERT_TRUE(r != NULL);
ASSERT_EQ(BN_Rshift(r, a, n), CRYPT_SUCCESS); // r != a
ASSERT_TRUE(BN_Cmp(r, res) == 0);
ASSERT_EQ(BN_Copy(r, a), CRYPT_SUCCESS);
ASSERT_EQ(BN_Rshift(r, r, n), CRYPT_SUCCESS); // r == a
ASSERT_TRUE(BN_Cmp(r, res) == 0);
/* Test the scenario where the output parameter space of q is insufficient */
q = BN_Create(0);
ASSERT_TRUE(q != NULL);
ASSERT_EQ(BN_Rshift(q, a, n), CRYPT_SUCCESS); // r != a
ASSERT_TRUE(BN_Cmp(r, res) == 0);
EXIT:
BN_Destroy(a);
BN_Destroy(r);
BN_Destroy(q);
BN_Destroy(p);
BN_Destroy(res);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_MODINV_API_TC001
* @title BN_ModInv test.
* @precon nan
* @brief
* 1. Call BN_ModInv method:
* (1) all parameters are valid, expected result 1.
* (2) r is null, expected result 2.
* (3) a is null, expected result 3.
* (4) m is null, expected result 4.
* (5) opt is null, expected result 5.
* (6) a is zero or m is zero, expected result 6.
* (7) r.room.bits < m.bits, expected result 7.
* (8) r.room.bits = m.bits, expected result 8.
* (9) r.room.bits > m.bits, expected result 9.
* @expect
* 1. CRYPT_SUCCESS
* 2-5. CRYPT_NULL_INPUT
* 6. CRYPT_BN_ERR_DIVISOR_ZERO
* 7-9. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_MODINV_API_TC001(void)
{
TestMemInit();
uint8_t buff[LONG_BN_BYTES_32];
BN_BigNum *a = BN_Create(LONG_BN_BITS_256);
BN_BigNum *m = BN_Create(LONG_BN_BITS_256);
BN_BigNum *zero = BN_Create(LONG_BN_BITS_256);
BN_BigNum *r128 = BN_Create(SHORT_BN_BITS_128);
BN_BigNum *r256 = BN_Create(LONG_BN_BITS_256);
BN_BigNum *r257 = BN_Create(LONG_BN_BITS_256 + 1);
BN_Optimizer *opt = BN_OptimizerCreate();
ASSERT_TRUE(a != NULL && m != NULL && r128 != NULL && r256 != NULL && zero != NULL && opt != NULL);
ASSERT_TRUE(BN_IsZero(zero) == true);
// a = FF...FF (32 bytes)
ASSERT_TRUE(memset_s(buff, sizeof(buff), 0xFF, LONG_BN_BYTES_32) == EOK);
ASSERT_TRUE(BN_Bin2Bn(a, buff, LONG_BN_BYTES_32) == CRYPT_SUCCESS);
// m == FF...FD (32 bytes)
buff[LONG_BN_BYTES_32 - 1] = (uint8_t)0xFD;
ASSERT_TRUE(BN_Bin2Bn(m, buff, LONG_BN_BYTES_32) == CRYPT_SUCCESS);
// NULL
ASSERT_TRUE(BN_ModInv(r256, a, m, opt) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_ModInv(NULL, a, m, opt) == CRYPT_NULL_INPUT);
ASSERT_TRUE(BN_ModInv(r256, NULL, m, opt) == CRYPT_NULL_INPUT);
ASSERT_TRUE(BN_ModInv(r256, a, NULL, opt) == CRYPT_NULL_INPUT);
ASSERT_TRUE(BN_ModInv(r256, a, m, NULL) == CRYPT_NULL_INPUT);
// zero
ASSERT_TRUE(BN_ModInv(r256, a, zero, opt) == CRYPT_BN_ERR_DIVISOR_ZERO);
ASSERT_TRUE(BN_ModInv(r256, zero, m, opt) == CRYPT_BN_ERR_DIVISOR_ZERO);
// r.room.bits < m.bits
ASSERT_TRUE(BN_ModInv(r128, a, m, opt) == CRYPT_SUCCESS);
// r.room.bits == m.bits
ASSERT_TRUE(BN_ModInv(r256, a, m, opt) == CRYPT_SUCCESS);
// r.room.bits > m.bits
ASSERT_TRUE(BN_ModInv(r257, a, m, opt) == CRYPT_SUCCESS);
EXIT:
BN_Destroy(a);
BN_Destroy(m);
BN_Destroy(zero);
BN_Destroy(r128);
BN_Destroy(r256);
BN_Destroy(r257);
BN_OptimizerDestroy(opt);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_MODINV_FUNC_TC002
* @title BN_ModInv test.
* @precon Vectors: hex1^(-1) mod modulo = result
* @brief
* 1. Convert vectors to bn.
* 2. Call BN_ModInv, and compared the result with vector, expected result 1.
* 3. If success is returned in the previous step, continue to test BN_ModInv when the output parameter address
* is the same as the input parameter address. expected result 2:
* (1) The address of the output parameter pointer r is the same as that of the input parameter pointer a.
* (2) The address of the output parameter pointer r is the same as that of the input parameter pointer m.
* 4. Test the scenario where the output parameter space is insufficient, expected result 2.
* @expect
* 1. Reutrn CRYPT_BN_ERR_NO_INVERSE on result is null. Otherwise, CRYPT_SUCCESS and result is same with vector.
* 2. The calculation result is consistent with the vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_MODINV_FUNC_TC002(int sign, Hex *hex, Hex *modulo, Hex *result)
{
TestMemInit();
int32_t ret;
BN_BigNum *res = NULL;
BN_BigNum *r = NULL;
BN_Optimizer *opt = BN_OptimizerCreate();
BN_BigNum *a = TEST_VectorToBN(sign, hex->x, hex->len);
BN_BigNum *m = TEST_VectorToBN(0, modulo->x, modulo->len);
ASSERT_TRUE(a != NULL && m != NULL && opt != NULL);
r = BN_Create(BN_Bits(a) + BN_Bits(m) + BIGNUM_REDUNDANCY_BITS);
ASSERT_TRUE(r != NULL);
ASSERT_TRUE(BN_Copy(r, a) == CRYPT_SUCCESS);
ret = BN_ModInv(r, a, m, opt); // r != a
if (result->len == 0) {
ASSERT_TRUE(ret == CRYPT_BN_ERR_NO_INVERSE); // No results exist
} else {
ASSERT_TRUE(ret == CRYPT_SUCCESS);
res = BN_Create(result->len * BITS_OF_BYTE);
ASSERT_TRUE(res != NULL);
ASSERT_TRUE(BN_Bin2Bn(res, result->x, result->len) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Cmp(r, res) == 0);
ASSERT_TRUE(BN_Copy(r, a) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_ModInv(r, r, m, opt) == CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("r == a", BN_Cmp(r, res) == 0);
ASSERT_TRUE(BN_Copy(r, m) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_ModInv(r, a, r, opt) == CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("r == m", BN_Cmp(r, res) == 0);
BN_Destroy(r);
/* Test the scenario where the output parameter space is insufficient. */
r = BN_Create(0);
ASSERT_TRUE(r != NULL);
ASSERT_TRUE(BN_ModInv(r, a, m, opt) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Cmp(r, res) == 0);
BN_Destroy(r);
r = BN_Create(0);
ASSERT_TRUE(r != NULL);
ASSERT_TRUE(BN_Copy(r, a) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_ModInv(r, r, m, opt) == CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("r == a", BN_Cmp(r, res) == 0);
BN_Destroy(r);
r = BN_Create(0);
ASSERT_TRUE(r != NULL);
ASSERT_TRUE(BN_Copy(r, m) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_ModInv(r, a, r, opt) == CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("r == m", BN_Cmp(r, res) == 0);
}
EXIT:
BN_Destroy(a);
BN_Destroy(m);
BN_Destroy(r);
BN_Destroy(res);
BN_OptimizerDestroy(opt);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_MOD_EXP_INPUT_CHECK_API_TC001
* @title ModExpInputCheck: Test invalid parameters and normal functions.
* @precon nan
* @brief
* 1. Call the ModExpInputCheck method, parameters are null,expected result 1
* 2. Call the ModExpInputCheck method, the size of r is smaller then m, expected result 2
* 3. Call the ModExpInputCheck method, m is 0, expected result 3
* 4. Call the ModExpInputCheck method, e is a negative number, expected result 4
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_SUCCESS
* 3. CRYPT_BN_ERR_DIVISOR_ZERO
* 4. CRYPT_BN_ERR_EXP_NO_NEGATIVE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_MOD_EXP_INPUT_CHECK_API_TC001(void)
{
BN_BigNum *bn = NULL;
BN_BigNum *r = NULL;
BN_BigNum *a = NULL;
BN_BigNum *e = NULL;
BN_BigNum *m = NULL;
BN_Optimizer *opt = NULL;
TestMemInit();
ASSERT_TRUE(ModExpInputCheck(NULL, NULL, NULL, NULL, NULL) == CRYPT_NULL_INPUT);
bn = BN_Create(1);
a = BN_Create(BN_MAX_BITS);
e = BN_Create(BN_MAX_BITS);
opt = BN_OptimizerCreate();
r = BN_Create(1);
m = BN_Create(BN_MAX_BITS);
ASSERT_TRUE(BN_SetBit(m, BN_SIZE) == CRYPT_SUCCESS);
ASSERT_TRUE(ModExpInputCheck(r, a, e, m, opt) == CRYPT_SUCCESS);
BN_Destroy(r);
r = BN_Create(BN_MAX_BITS);
ASSERT_TRUE(ModExpInputCheck(r, a, e, bn, opt) == CRYPT_BN_ERR_DIVISOR_ZERO);
ASSERT_TRUE(BN_SetBit(e, BN_SIZE) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SetSign(e, true) == CRYPT_SUCCESS);
ASSERT_TRUE(ModExpInputCheck(r, a, e, m, opt) == CRYPT_BN_ERR_EXP_NO_NEGATIVE);
EXIT:
BN_Destroy(bn);
BN_Destroy(r);
BN_Destroy(a);
BN_Destroy(e);
BN_Destroy(m);
BN_OptimizerDestroy(opt);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_MODEXP_API_TC001
* @title BN_ModExp: Test invalid parameters.
* @precon nan
* @brief
* 1. Call the BN_ModExp method, parameters are null, expected result 1
* 2. Call the BN_ModExp method, the size of r is smaller then m, expected result 2
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_MODEXP_API_TC001(void)
{
uint8_t buff[LONG_BN_BYTES_32];
TestMemInit();
BN_BigNum *a = BN_Create(LONG_BN_BITS_256);
BN_BigNum *e = BN_Create(LONG_BN_BITS_256);
BN_BigNum *r = BN_Create(LONG_BN_BITS_256);
BN_BigNum *m = BN_Create(LONG_BN_BITS_256);
BN_Optimizer *opt = BN_OptimizerCreate();
ASSERT_TRUE(a != NULL);
ASSERT_TRUE(e != NULL);
ASSERT_TRUE(r != NULL);
ASSERT_TRUE(m != NULL);
ASSERT_TRUE(opt != NULL);
ASSERT_TRUE(memset_s(buff, sizeof(buff), 0xFF, LONG_BN_BYTES_32) == EOK);
ASSERT_TRUE(BN_Bin2Bn(a, buff, LONG_BN_BYTES_32) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Bin2Bn(e, buff, LONG_BN_BYTES_32) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Bin2Bn(m, buff, LONG_BN_BYTES_32) == CRYPT_SUCCESS);
// NULL
ASSERT_TRUE(BN_ModExp(NULL, NULL, NULL, NULL, NULL) == CRYPT_NULL_INPUT);
BN_Destroy(r);
r = BN_Create(LONG_BN_BITS_256 - BIGNUM_REDUNDANCY_BITS);
ASSERT_TRUE(BN_ModExp(r, a, e, m, opt) == CRYPT_SUCCESS);
EXIT:
BN_Destroy(a);
BN_Destroy(e);
BN_Destroy(r);
BN_Destroy(m);
BN_OptimizerDestroy(opt);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_MODEXP_API_TC002
* @title BN_ModExp: Invalid parameter and function test.
* @precon nan
* @brief
* 1. Call the BN_ModExp method, the divisor is 0, expected result 1
* 2. Call the BN_ModExp method, the value of the exponent is negative, expected result 2
* 3. Call the BN_ModExp method, all parameters are valid, expected result 3
* @expect
* 1. CRYPT_BN_ERR_DIVISOR_ZERO
* 2. CRYPT_BN_ERR_EXP_NO_NEGATIVE
* 3. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_MODEXP_API_TC002(void)
{
uint8_t buff[LONG_BN_BYTES_32];
BN_BigNum *a = BN_Create(LONG_BN_BYTES_32 * 8);
BN_BigNum *e = BN_Create(LONG_BN_BYTES_32 * 8);
BN_BigNum *m = BN_Create(LONG_BN_BYTES_32 * 8);
BN_BigNum *r = BN_Create(LONG_BN_BITS_256);
BN_BigNum *zero = BN_Create(LONG_BN_BITS_256);
BN_BigNum *one = BN_Create(LONG_BN_BITS_256);
BN_BigNum *negOne = BN_Create(LONG_BN_BITS_256);
BN_Optimizer *opt = BN_OptimizerCreate();
TestMemInit();
ASSERT_TRUE(r != NULL);
ASSERT_TRUE(zero != NULL);
ASSERT_TRUE(one != NULL);
ASSERT_TRUE(negOne != NULL);
ASSERT_TRUE(opt != NULL);
ASSERT_TRUE(memset_s(buff, sizeof(buff), 0xFF, LONG_BN_BYTES_32) == EOK);
ASSERT_TRUE(a != NULL);
ASSERT_TRUE(BN_Bin2Bn(a, buff, LONG_BN_BYTES_32) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SetSign(a, false) == CRYPT_SUCCESS);
ASSERT_TRUE(e != NULL);
ASSERT_TRUE(BN_Bin2Bn(e, buff, LONG_BN_BYTES_32) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SetSign(e, false) == CRYPT_SUCCESS);
ASSERT_TRUE(m != NULL);
ASSERT_TRUE(BN_Bin2Bn(m, buff, LONG_BN_BYTES_32) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SetSign(m, false) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Zeroize(zero) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SetLimb(one, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SetLimb(negOne, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SetSign(negOne, true) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_ModExp(r, a, e, zero, opt) == CRYPT_BN_ERR_DIVISOR_ZERO);
ASSERT_TRUE(BN_ModExp(r, a, negOne, m, opt) == CRYPT_BN_ERR_EXP_NO_NEGATIVE);
ASSERT_TRUE(BN_ModExp(r, zero, zero, m, opt) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Cmp(r, one) == 0);
ASSERT_TRUE(BN_ModExp(r, zero, zero, one, opt) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Cmp(r, zero) == 0);
ASSERT_TRUE(BN_ModExp(r, a, e, negOne, opt) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Cmp(r, zero) == 0);
EXIT:
BN_Destroy(a);
BN_Destroy(e);
BN_Destroy(r);
BN_Destroy(m);
BN_Destroy(zero);
BN_Destroy(one);
BN_Destroy(negOne);
BN_OptimizerDestroy(opt);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_MODEXP_FUNC_TC001
* @title BN_ModExp test.
* @precon Vectors: two big numbers, mod, result.
* @brief
* 1. Convert vectors to big numbers.
* 2. Call BN_ModExp to calculate the modular exponentiation, and compared to the vector value, expected result 1:
* (1) Pointer addresses for parameters are different from each other.
* (2) The address of the output parameter pointer r is the same as that of the input parameter pointer a.
* (3) The address of the output parameter pointer r is the same as that of the input parameter pointer e.
* (4) The address of the output parameter pointer r is the same as that of the input parameter pointer m.
* 3. Test the scenario where the output parameter space is insufficient, expected result 1.
* @expect
* 1. The calculation result is consistent with the vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_MODEXP_FUNC_TC001(int sign1, Hex *hex1, Hex *hex2, Hex *modulo, Hex *result)
{
TestMemInit();
BN_BigNum *r = NULL;
BN_Optimizer *opt = NULL;
uint32_t maxBits;
BN_BigNum *res = TEST_VectorToBN(0, result->x, result->len);
BN_BigNum *a = TEST_VectorToBN(sign1, hex1->x, hex1->len);
BN_BigNum *e = TEST_VectorToBN(0, hex2->x, hex2->len);
BN_BigNum *m = TEST_VectorToBN(0, modulo->x, modulo->len);
ASSERT_TRUE(res != NULL && a != NULL && e != NULL && m != NULL);
maxBits = TEST_GetMax(BN_Bits(a), BN_Bits(e), BN_Bits(m));
r = BN_Create(maxBits + BIGNUM_REDUNDANCY_BITS);
ASSERT_TRUE(r != NULL);
opt = BN_OptimizerCreate();
ASSERT_TRUE(opt != NULL);
ASSERT_TRUE(BN_Copy(r, a) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_ModExp(r, a, e, m, opt) == CRYPT_SUCCESS); // r != a
ASSERT_TRUE_AND_LOG("r != a", BN_Cmp(r, res) == 0);
ASSERT_TRUE(BN_Copy(r, a) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_ModExp(r, r, e, m, opt) == CRYPT_SUCCESS); // r == a
ASSERT_TRUE_AND_LOG("r == a", BN_Cmp(r, res) == 0);
ASSERT_TRUE(BN_Copy(r, e) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_ModExp(r, a, r, m, opt) == CRYPT_SUCCESS); // r == e
ASSERT_TRUE_AND_LOG("r == e", BN_Cmp(r, res) == 0);
ASSERT_TRUE(BN_Copy(r, m) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_ModExp(r, a, e, r, opt) == CRYPT_SUCCESS); // r == m
ASSERT_TRUE_AND_LOG("r == m", BN_Cmp(r, res) == 0);
// Test the scenario where the output parameter space is insufficient.
BN_Destroy(r);
r = BN_Create(0);
ASSERT_TRUE(r != NULL);
ASSERT_TRUE(BN_ModExp(r, a, e, m, opt) == CRYPT_SUCCESS); // r != a
ASSERT_TRUE_AND_LOG("r != a", BN_Cmp(r, res) == 0);
BN_Destroy(r);
r = BN_Create(0);
ASSERT_TRUE(r != NULL);
ASSERT_TRUE(BN_Copy(r, a) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_ModExp(r, r, e, m, opt) == CRYPT_SUCCESS); // r == a
ASSERT_TRUE_AND_LOG("r == a", BN_Cmp(r, res) == 0);
BN_Destroy(r);
r = BN_Create(0);
ASSERT_TRUE(r != NULL);
ASSERT_TRUE(BN_Copy(r, e) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_ModExp(r, a, r, m, opt) == CRYPT_SUCCESS); // r == e
ASSERT_TRUE_AND_LOG("r == e", BN_Cmp(r, res) == 0);
BN_Destroy(r);
r = BN_Create(0);
ASSERT_TRUE(r != NULL);
ASSERT_TRUE(BN_Copy(r, m) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_ModExp(r, a, e, r, opt) == CRYPT_SUCCESS); // r == m
ASSERT_TRUE_AND_LOG("r == m", BN_Cmp(r, res) == 0);
EXIT:
BN_Destroy(a);
BN_Destroy(e);
BN_Destroy(m);
BN_Destroy(r);
BN_Destroy(res);
BN_OptimizerDestroy(opt);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_MODEXPCORE_API_TC001
* @title ModExpCore: Invalid parameter.
* @precon nan
* @brief
* 1. Call the ModExpCore method, the divisor is 0, expected result 1
* @expect
* 1. CRYPT_BN_ERR_DIVISOR_ZERO
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_MODEXPCORE_API_TC001(void)
{
TestMemInit();
BN_BigNum *a = BN_Create(LONG_BN_BITS_256);
BN_BigNum *e = BN_Create(LONG_BN_BITS_256);
BN_BigNum *r = BN_Create(LONG_BN_BITS_256);
BN_BigNum *m = BN_Create(LONG_BN_BITS_256);
BN_Optimizer *opt = BN_OptimizerCreate();
ASSERT_TRUE(BN_SetLimb(e, 10) == CRYPT_SUCCESS);
ASSERT_TRUE(ModExpCore(r, a, e, m, opt) == CRYPT_BN_ERR_DIVISOR_ZERO);
EXIT:
BN_Destroy(a);
BN_Destroy(e);
BN_Destroy(r);
BN_Destroy(m);
BN_OptimizerDestroy(opt);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_MOD_API_TC001
* @title BN_Mod: Invalid parameter.
* @precon nan
* @brief
* 1. Call the BN_Mod method, all parameters are null, expected result 1
* 2. Call the BN_Mod method, mod is UINT8_MAX_NUM, expected result 2
* 3. Call the BN_Mod method, mod is 0, expected result 3
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_SUCCESS
* 3. CRYPT_BN_ERR_DIVISOR_ZERO
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_MOD_API_TC001(void)
{
TestMemInit();
BN_BigNum *a = BN_Create(LONG_BN_BITS_256);
BN_BigNum *r = BN_Create(SHORT_BN_BITS_128);
BN_BigNum *m = BN_Create(LONG_BN_BITS_256);
BN_Optimizer *opt = BN_OptimizerCreate();
ASSERT_TRUE(BN_Mod(NULL, NULL, NULL, NULL) == CRYPT_NULL_INPUT);
ASSERT_TRUE(BN_SetBit(m, UINT8_MAX_NUM) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Mod(r, a, m, opt) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SetLimb(m, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Mod(r, a, m, opt) == CRYPT_BN_ERR_DIVISOR_ZERO);
EXIT:
BN_Destroy(a);
BN_Destroy(r);
BN_Destroy(m);
BN_OptimizerDestroy(opt);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_MOD_FUNC_TC001
* @title BN_Mod test.
* @precon Vectors: hex1 mod module = result
* @brief
* 1. Convert vectors to bn.
* 2. Call BN_Mod, and compared the result with vector, expected result 1:
* (1) Pointer addresses for parameters are different from each other.
* (2) The address of the output parameter pointer r is the same as that of the input parameter pointer a.
* (3) The address of the output parameter pointer r is the same as that of the input parameter pointer m.
* 3. Test the scenario where the output parameter space is insufficient, expected result 1.
* @expect
* 1. The calculation result is consistent with the vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_MOD_FUNC_TC001(int sign1, Hex *hex1, int sign2, Hex *modulo, Hex *result)
{
TestMemInit();
BN_BigNum *r = NULL;
BN_Optimizer *opt = NULL;
BN_BigNum *res = TEST_VectorToBN(0, result->x, result->len);
BN_BigNum *a = TEST_VectorToBN(sign1, hex1->x, hex1->len);
BN_BigNum *m = TEST_VectorToBN(sign2, modulo->x, modulo->len);
ASSERT_TRUE(a != NULL && m != NULL && res != NULL);
r = BN_Create(BN_Bits(a) + BN_Bits(m) + BIGNUM_REDUNDANCY_BITS);
ASSERT_TRUE(r != NULL);
opt = BN_OptimizerCreate();
ASSERT_TRUE(opt != NULL);
ASSERT_EQ(BN_Copy(r, a), CRYPT_SUCCESS);
ASSERT_EQ(BN_Mod(r, a, m, opt), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("r != a", BN_Cmp(r, res) == 0);
ASSERT_EQ(BN_Copy(r, a), CRYPT_SUCCESS);
ASSERT_EQ(BN_Mod(r, r, m, opt), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("r == a", BN_Cmp(r, res) == 0);
ASSERT_EQ(BN_Copy(r, m), CRYPT_SUCCESS);
ASSERT_EQ(BN_Mod(r, a, r, opt), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("r == m", BN_Cmp(r, res) == 0);
/* Test the scenario where the output parameter space is insufficient. */
BN_Destroy(r);
r = BN_Create(0);
ASSERT_TRUE(r != NULL);
ASSERT_EQ(BN_Mod(r, a, m, opt), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("r != a", BN_Cmp(r, res) == 0);
ASSERT_EQ(BN_Copy(r, m), CRYPT_SUCCESS);
ASSERT_EQ(BN_Mod(r, a, r, opt), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("r == m", BN_Cmp(r, res) == 0);
BN_Destroy(r);
r = BN_Create(0);
ASSERT_TRUE(r != NULL);
ASSERT_EQ(BN_Copy(r, a), CRYPT_SUCCESS);
ASSERT_EQ(BN_Mod(r, r, m, opt), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("r == a", BN_Cmp(r, res) == 0);
EXIT:
BN_Destroy(a);
BN_Destroy(m);
BN_Destroy(r);
BN_Destroy(res);
BN_OptimizerDestroy(opt);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_PRIMECHECK_API_TC001
* @title BN_PrimeCheck: Invalid parameter.
* @precon nan
* @brief
* 1. Create BN_BigNum bn, set the value of bn to 10, expected result 1
* 2. Call the BN_PrimeCheck to check bn, expected result 2
* @expect
* 1. CRYPT_SUCCESS
* 1. CRYPT_BN_NOR_CHECK_PRIME
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_PRIMECHECK_API_TC001(void)
{
TestMemInit();
BN_BigNum *bn = BN_Create(LONG_BN_BITS_256);
BN_Optimizer *opt = BN_OptimizerCreate();
ASSERT_TRUE(BN_SetLimb(bn, 10) == CRYPT_SUCCESS); // bn == 10
ASSERT_TRUE(BN_PrimeCheck(bn, 0, opt, NULL) == CRYPT_BN_NOR_CHECK_PRIME);
EXIT:
BN_Destroy(bn);
BN_OptimizerDestroy(opt);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_PRIME_CHECK_FUNC_TC001
* @title BN_PrimeCheck method test.
* @precon A big number and information about whether the big number is prime.
* @brief
* 1. Convert hex to bn.
* 2. Init the drbg.
* 3. Call the BN_PrimeCheck method to check whether the big number is prime, expected result 1
* @expect
* 1. Return CRYPT_SUCCESS on isPrime != 0, CRYPT_BN_NOR_CHECK_PRIME otherwise.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_PRIME_CHECK_FUNC_TC001(Hex *hex, int isPrime)
{
#ifndef HITLS_CRYPTO_DRBG
(void)hex;
(void)isPrime;
SKIP_TEST();
#else
TestMemInit();
int32_t ret;
BN_BigNum *bn = BN_Create(hex->len * BITS_OF_BYTE);
BN_Optimizer *opt = BN_OptimizerCreate();
ASSERT_TRUE(bn != NULL && opt != NULL);
ASSERT_EQ(BN_Bin2Bn(bn, hex->x, hex->len), CRYPT_SUCCESS);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ret = BN_PrimeCheck(bn, 0, opt, NULL);
if (isPrime != 0) {
ASSERT_EQ(ret, CRYPT_SUCCESS);
} else {
ASSERT_EQ(ret, CRYPT_BN_NOR_CHECK_PRIME);
}
EXIT:
TestRandDeInit();
BN_Destroy(bn);
BN_OptimizerDestroy(opt);
#endif
}
/* END_CASE */
static int32_t PrimeGenCb(BN_CbCtx *callBack, int32_t process, int32_t target)
{
if (callBack == NULL)
return CRYPT_SUCCESS;
int32_t *limit = BN_CbCtxGetArg(callBack);
if (process < *limit) {
return CRYPT_SUCCESS;
}
(void)target;
printf("now try tims is %d, gen failed\n", process);
return -1;
}
/**
* @test SDV_CRYPTO_BN_GENPRIMELIMB_API_TC001
* @title BN_GenPrime method test.
* @precon nan
* @brief
* 1. Create BN_CbCtx and call the BN_CbCtxSet method to register BN_CallBack method.
* 2. Init the drbg.
* 3. Call the BN_GenPrime method to generate prime, bits is LONG_BN_BITS_256, half is false, expected result 1
* 4. Call the BN_GenPrime method to generate prime, bits < 14, half is true, expected result 2
* 5. Call the BN_GenPrime method to generate prime, bits is 10, expected result 3
* @expect
* 1-3. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_GENPRIMELIMB_API_TC001(void)
{
TestMemInit();
BN_Optimizer *opt = BN_OptimizerCreate();
ASSERT_TRUE(opt != NULL);
BN_CbCtx *cb = BN_CbCtxCreate();
ASSERT_TRUE(cb != NULL);
int32_t limit = 256;
BN_CbCtxSet(cb, PrimeGenCb, &limit);
const uint32_t bits = LONG_BN_BITS_256;
bool half = false;
BN_BigNum *r = BN_Create(LONG_BN_BITS_256);
ASSERT_TRUE(r != NULL);
CRYPT_RandRegist(TEST_Random);
CRYPT_RandRegistEx(TEST_RandomEx);
ASSERT_TRUE(BN_GenPrime(r, NULL, bits, half, opt, cb) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_GenPrime(r, NULL, 13, true, opt, cb) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_GenPrime(r, NULL, 10, half, opt, cb) == CRYPT_SUCCESS);
EXIT:
BN_CbCtxDestroy(cb);
BN_Destroy(r);
BN_OptimizerDestroy(opt);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_ADDLIMB_FUNC_TC001
* @title BN_AddLimb method test.
* @precon nan
* @brief
* 1. Convert vectors to big numbers.
* 2. Call the BN_AddLimb method to calculate the sum of two numbers, expected result 1.
* 3. If expectRet=CRYPT_SUCCESS, call the BN_Cmp to compare r and resHex, expected result 3.
* @expect
* 1. The return value is the same as 'expectRet'.
* 2. The calculated sum is 0.
* 3. Both are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_ADDLIMB_FUNC_TC001(int sign, Hex *rHex, int limb, int resSign, Hex *resHex, int expectRet)
{
TestMemInit();
BN_BigNum *resBn = NULL;
BN_BigNum *a = TEST_VectorToBN(sign, rHex->x, rHex->len);
BN_BigNum *r = TEST_VectorToBN(resSign, resHex->x, resHex->len);
/* a and r can be null. */
resBn = BN_Create(SHORT_BN_BITS_128);
ASSERT_TRUE(resBn != NULL);
ASSERT_EQ(BN_AddLimb(resBn, a, limb), expectRet);
if (expectRet == CRYPT_SUCCESS) {
ASSERT_EQ(BN_Cmp(resBn, r), 0);
}
EXIT:
BN_Destroy(a);
BN_Destroy(r);
BN_Destroy(resBn);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_SUB_FUNC_TC001
* @title BN_Sub test.
* @precon Vectors: hex1 - hex2 = result
* @brief
* 1. Convert vectors to big numbers.
* 2. Call BN_Sub to calculate hex1 minus hex2, and compared the result with vector, expected result 1:
* (1) Pointer addresses for parameters are different from each other.
* (2) The address of the output parameter pointer r is the same as that of the input parameter pointer a.
* (3) The address of the output parameter pointer r is the same as that of the input parameter pointer b.
* 3. Test the scenario where the output parameter space is insufficient, expected result 1.
* @expect
* 1. The calculation result is consistent with the vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_SUB_FUNC_TC001(int sign1, Hex *hex1, int sign2, Hex *hex2, int signRes, Hex *result)
{
TestMemInit();
BN_BigNum *r = NULL;
BN_BigNum *n = NULL;
uint32_t maxBits;
BN_BigNum *res = TEST_VectorToBN(signRes, result->x, result->len);
BN_BigNum *a = TEST_VectorToBN(sign1, hex1->x, hex1->len);
BN_BigNum *b = TEST_VectorToBN(sign2, hex2->x, hex2->len);
ASSERT_TRUE(res != NULL && a != NULL && b != NULL);
maxBits = TEST_GetMax(BN_Bits(a), BN_Bits(b), 0);
r = BN_Create(maxBits + BIGNUM_REDUNDANCY_BITS);
ASSERT_TRUE(r != NULL);
ASSERT_EQ(BN_Copy(r, a), CRYPT_SUCCESS);
ASSERT_EQ(BN_Sub(r, a, b), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("r != a", BN_Cmp(r, res) == 0);
ASSERT_EQ(BN_Copy(r, a), CRYPT_SUCCESS);
ASSERT_EQ(BN_Sub(r, r, b), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("r == a", BN_Cmp(r, res) == 0);
ASSERT_EQ(BN_Copy(r, b), CRYPT_SUCCESS);
ASSERT_EQ(BN_Sub(r, a, r), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("r == b", BN_Cmp(r, res) == 0);
/* Test the scenario where the output parameter space is insufficient. */
n = BN_Create(0);
ASSERT_TRUE(n != NULL);
ASSERT_EQ(BN_Sub(n, a, b), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("n != a", BN_Cmp(n, res) == 0);
ASSERT_EQ(BN_Sub(a, a, b), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("a == a", BN_Cmp(a, res) == 0);
EXIT:
BN_Destroy(a);
BN_Destroy(b);
BN_Destroy(r);
BN_Destroy(n);
BN_Destroy(res);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_SUBLIMB_API_TC001
* @title BN_SubLimb method test.
* @precon nan
* @brief
* 1. Create BN_BigNum r and a.
* 2. Call the BN_SubLimb method, parameters are null, expected result 1
* 3. Call the BN_AddLimb method to subtract a from 2, expected result 2
* 4. Call the BN_AddLimb method to subtract a from 1, expected result 3
* 5. Call the BN_AddLimb method to subtract a from 0, expected result 4
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_SUBLIMB_API_TC001(void)
{
BN_BigNum *r = NULL;
BN_BigNum *a = NULL;
TestMemInit();
r = BN_Create(LONG_BN_BITS_256);
a = BN_Create(LONG_BN_BITS_256);
ASSERT_TRUE(r != NULL && a != NULL);
ASSERT_TRUE(BN_SubLimb(NULL, NULL, 0) == CRYPT_NULL_INPUT);
ASSERT_TRUE(BN_SubLimb(r, a, 2) == CRYPT_SUCCESS); // r == LONG_BN_BITS_256 - 2
ASSERT_TRUE(BN_SetBit(a, 1) == CRYPT_SUCCESS); // a->size == 1
ASSERT_TRUE(BN_SetSign(a, true) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SubLimb(r, a, 1) == CRYPT_SUCCESS); // r == LONG_BN_BITS_256 - 1
ASSERT_TRUE(BN_SetBit(a, SHORT_BN_BITS_128 - 1) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SubLimb(r, a, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SetBit(a, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SubLimb(r, a, 0) == CRYPT_SUCCESS);
BN_Destroy(a);
a = NULL;
a = BN_Create(0);
ASSERT_TRUE(a != NULL);
ASSERT_TRUE(BN_SubLimb(r, a, 10) == CRYPT_SUCCESS);
EXIT:
BN_Destroy(r);
BN_Destroy(a);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_SUB_LIMB_FUNC_TC001
* @title BN_SubLimb test.
* @precon Vectors: hex1 - hex2 = result
* @brief
* 1. Convert vectors to big numbers.
* 2. Call BN_SubLimb to calculate hex1 minus hex2, and compared the result with vector, expected result 1.
* 3. Test the scenario where the output parameter space is insufficient, expected result 1.
* @expect
* 1. The calculation result is consistent with the vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_SUB_LIMB_FUNC_TC001(int sign1, Hex *hex1, Hex *hex2, int signRes, Hex *result)
{
TestMemInit();
BN_BigNum *r = NULL;
BN_BigNum *n = NULL;
BN_UINT w = 0;
BN_BigNum *res = TEST_VectorToBN(signRes, result->x, result->len);
BN_BigNum *a = TEST_VectorToBN(sign1, hex1->x, hex1->len);
ASSERT_TRUE(res != NULL && a != NULL);
// w
ASSERT_TRUE(sizeof(BN_UINT) >= hex2->len);
for (uint32_t i = 0; i < hex2->len; i++) {
w <<= BITS_OF_BYTE;
w += hex2->x[i];
}
// r
r = BN_Create(BN_Bits(a) + BIGNUM_REDUNDANCY_BITS);
ASSERT_TRUE(r != NULL);
ASSERT_EQ(BN_Copy(r, a), CRYPT_SUCCESS);
ASSERT_EQ(BN_SubLimb(r, a, w), CRYPT_SUCCESS);
ASSERT_TRUE(BN_Cmp(r, res) == 0);
/* Test the scenario where the output parameter space is insufficient. */
n = BN_Create(0);
ASSERT_TRUE(n != NULL);
ASSERT_EQ(BN_Zeroize(a), CRYPT_SUCCESS);
ASSERT_TRUE(BN_SubLimb(n, a, w) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SetLimb(res, w) == CRYPT_SUCCESS);
if (w != 0) {
res->sign = true;
}
ASSERT_TRUE(BN_Cmp(n, res) == 0);
EXIT:
BN_Destroy(a);
BN_Destroy(r);
BN_Destroy(n);
BN_Destroy(res);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_DIV_FUNC_TC001
* @title BN_Div test.
* @precon Vectors: hex1 / hex2 = resultQ, hex1 % hex2 = resultR
* @brief
* 1. Convert vectors to big numbers.
* 2. Call BN_Div method, and compared the result with vector, expected result 1:
* (1) Pointer addresses for parameters are different from each other.
* (2) q == x, r == y.
* 3. Test the scenario where the output parameter space is insufficient, expected result 1.
* @expect
* 1. The calculation result is consistent with the vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_DIV_FUNC_TC001(
int sign1, Hex *hex1, int sign2, Hex *hex2, int signQ, Hex *resultQ, int signR, Hex *resultR)
{
TestMemInit();
BN_BigNum *q = NULL;
BN_BigNum *r = NULL;
BN_BigNum *q1 = NULL;
BN_BigNum *n = NULL;
BN_Optimizer *opt = NULL;
uint32_t maxBits;
BN_BigNum *resQ = TEST_VectorToBN(signQ, resultQ->x, resultQ->len);
BN_BigNum *resR = TEST_VectorToBN(signR, resultR->x, resultR->len);
BN_BigNum *x = TEST_VectorToBN(sign1, hex1->x, hex1->len);
BN_BigNum *y = TEST_VectorToBN(sign2, hex2->x, hex2->len);
ASSERT_TRUE(resQ != NULL && resR != NULL && x != NULL && y != NULL);
maxBits = TEST_GetMax(BN_Bits(x), BN_Bits(y), 0);
// q
q = BN_Create(maxBits + BIGNUM_REDUNDANCY_BITS);
r = BN_Create(maxBits + BIGNUM_REDUNDANCY_BITS);
ASSERT_TRUE(q != NULL && r != NULL);
opt = BN_OptimizerCreate();
ASSERT_TRUE(opt != NULL);
ASSERT_EQ(BN_Copy(q, x), CRYPT_SUCCESS);
ASSERT_EQ(BN_Copy(r, y), CRYPT_SUCCESS);
ASSERT_EQ(BN_Div(q, r, x, y, opt), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("q != x, r != y", BN_Cmp(q, resQ) == 0);
ASSERT_TRUE_AND_LOG("q != x, r != y", BN_Cmp(r, resR) == 0);
ASSERT_EQ(BN_Copy(q, x), CRYPT_SUCCESS);
ASSERT_EQ(BN_Copy(r, y), CRYPT_SUCCESS);
ASSERT_EQ(BN_Div(q, r, q, r, opt), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("q == x, r == y", BN_Cmp(q, resQ) == 0);
ASSERT_TRUE_AND_LOG("q == x, r == y", BN_Cmp(r, resR) == 0);
/* Test the scenario where the output parameter space is insufficient. */
n = BN_Create(0);
q1 = BN_Create(0);
ASSERT_TRUE(n != NULL);
ASSERT_TRUE(q1 != NULL);
ASSERT_EQ(BN_Div(q1, n, x, y, opt), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("q1 != x, n != y", BN_Cmp(q1, resQ) == 0);
ASSERT_TRUE_AND_LOG("q1 != x, n != y", BN_Cmp(n, resR) == 0);
EXIT:
BN_Destroy(x);
BN_Destroy(y);
BN_Destroy(q);
BN_Destroy(r);
BN_Destroy(n);
BN_Destroy(q1);
BN_Destroy(resQ);
BN_Destroy(resR);
BN_OptimizerDestroy(opt);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_SQR_API_TC001
* @title BN_Sqr method test.
* @precon nan
* @brief
* 1. Call the BN_Sqr method, parameters are null, expected result 1
* 2. Call the BN_Sqr method, parameters are valid, expected result 2
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_SQR_API_TC001(void)
{
uint8_t buff[LONG_BN_BYTES_32];
BN_BigNum *a = NULL;
BN_BigNum *r = NULL;
BN_BigNum *zero = NULL;
BN_Optimizer *opt = NULL;
TestMemInit();
a = BN_Create(SHORT_BN_BITS_128);
r = BN_Create(SHORT_BN_BITS_128);
ASSERT_TRUE(a != NULL && r != NULL);
opt = BN_OptimizerCreate();
ASSERT_TRUE(opt != NULL);
ASSERT_TRUE(BN_Sqr(NULL, NULL, NULL) == CRYPT_NULL_INPUT);
ASSERT_TRUE(BN_Sqr(r, a, opt) == CRYPT_SUCCESS);
memset_s(buff, sizeof(buff), 0xFF, LONG_BN_BYTES_32);
ASSERT_TRUE(BN_Bin2Bn(a, buff, sizeof(buff)) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Sqr(r, a, opt) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Bin2Bn(a, buff, sizeof(buff) / 2) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Sqr(r, a, opt) == CRYPT_SUCCESS);
EXIT:
BN_Destroy(a);
BN_Destroy(r);
BN_Destroy(zero);
BN_OptimizerDestroy(opt);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_SQR_FUNC_TC001
* @title BN_Sqr method test.
* @precon nan
* @brief
* 1. Call the BN_Copy method, Compute (-1)*(-1) or 1*1, expected result 1
* 2. Compare r and result, expected result 2
* @expect
* 1. CRYPT_SUCCESS
* 2. r = result
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_SQR_FUNC_TC001(int sign1, Hex *hex1, Hex *result)
{
TestMemInit();
BN_BigNum *a;
BN_BigNum *res = NULL;
BN_BigNum *r = NULL;
BN_Optimizer *opt = NULL;
a = BN_Create(hex1->len * BITS_OF_BYTE);
res = BN_Create(result->len * BITS_OF_BYTE);
ASSERT_TRUE(a != NULL && res != NULL);
ASSERT_TRUE(BN_Bin2Bn(res, result->x, result->len) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Bin2Bn(a, hex1->x, hex1->len) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SetSign(a, sign1 != 0) == CRYPT_SUCCESS);
// r.bits > a.bits * 2
r = BN_Create(BN_Bits(a) * 2 + BIGNUM_REDUNDANCY_BITS);
ASSERT_TRUE(r != NULL);
opt = BN_OptimizerCreate();
ASSERT_TRUE(opt != NULL);
ASSERT_TRUE(BN_Copy(r, a) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Sqr(r, a, opt) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Cmp(r, res) == 0);
EXIT:
BN_Destroy(a);
BN_Destroy(r);
BN_Destroy(res);
BN_OptimizerDestroy(opt);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_RAND_API_TC001
* @title BN_Rand: Invalid parameter.
* @precon nan
* @brief
* 1. Call the BN_Rand, parameters are null and 0, expected result 1
* 2. Call the BN_Rand, top is out of maximum value(BN_RAND_TOP_TWOBIT + 1), expected result 2
* 3. Call the BN_Rand, bottom is out of maximum value(BN_RAND_BOTTOM_TWOBIT + 1), expected result 3
* 4. Call the BN_Rand, bit is 0, top and bottom are not 0, expected result 4
* 5. Call the BN_Rand, bit > BN_MAX_BITS, expected result 5
* 6. Call the BN_Rand, bit, top and bottom is 0, expected result 6
* @expect
* 1. CRYPT_NULL_INPUT
* 2-3. CRYPT_BN_ERR_RAND_TOP_BOTTOM
* 4. CRYPT_BN_ERR_RAND_BITS_NOT_ENOUGH
* 5. CRYPT_BN_BITS_TOO_MAX
* 6. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_RAND_API_TC001(void)
{
#ifndef HITLS_CRYPTO_DRBG
SKIP_TEST();
#else
BN_BigNum *bn = NULL;
TestMemInit();
bn = BN_Create(BITS_OF_BYTE);
ASSERT_TRUE(BN_Rand(NULL, 0, 0, 0) == CRYPT_NULL_INPUT);
ASSERT_TRUE(
BN_Rand(bn, BITS_OF_BYTE, BN_RAND_TOP_TWOBIT + 1, BN_RAND_BOTTOM_TWOBIT) == CRYPT_BN_ERR_RAND_TOP_BOTTOM);
ASSERT_TRUE(
BN_Rand(bn, BITS_OF_BYTE, BN_RAND_TOP_TWOBIT, BN_RAND_BOTTOM_TWOBIT + 1) == CRYPT_BN_ERR_RAND_TOP_BOTTOM);
ASSERT_TRUE(BN_Rand(bn, 0, BN_RAND_TOP_TWOBIT, BN_RAND_BOTTOM_TWOBIT) == CRYPT_BN_ERR_RAND_BITS_NOT_ENOUGH);
ASSERT_TRUE(BN_Rand(bn, BN_MAX_BITS + 1, BN_RAND_TOP_TWOBIT, BN_RAND_BOTTOM_TWOBIT) == CRYPT_BN_BITS_TOO_MAX);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_TRUE(BN_Rand(bn, 0, 0, 0) == CRYPT_SUCCESS);
EXIT:
BN_Destroy(bn);
return;
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_RANDRANGE_API_TC001
* @title BN_RandRange: Invalid parameter.
* @precon nan
* @brief
* 1. Call the BN_RandRange method, parameters are null, expected result 1
* 2. Call the BN_RandRange method, parameters are 0, expected result 2
* 3. Call the BN_RandRange method, parameters are -1, expected result 3
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_BN_ERR_RAND_ZERO
* 3. CRYPT_BN_ERR_RAND_NEGATIVE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_RANDRANGE_API_TC001(void)
{
BN_BigNum *bn = NULL;
TestMemInit();
bn = BN_Create(BITS_OF_BYTE);
ASSERT_TRUE(BN_RandRange(NULL, NULL) == CRYPT_NULL_INPUT);
ASSERT_TRUE(BN_RandRange(bn, bn) == CRYPT_BN_ERR_RAND_ZERO);
ASSERT_TRUE(BN_SetLimb(bn, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SetSign(bn, true) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_RandRange(bn, bn) == CRYPT_BN_ERR_RAND_NEGATIVE);
EXIT:
BN_Destroy(bn);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_BNGCDCHECKINPUT_API_TC001
* @title BnGcdCheckInput: Invalid parameter.
* @precon nan
* @brief
* 1. Call the BnGcdCheckInput method, parameters are null, expected result 1
* 2. Call the BnGcdCheckInput method, a and b are BN_MAX_BITS, expected result 2
* 3. Call the BnGcdCheckInput method, a and b are 0, expected result 3
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_SUCCESS
* 3. CRYPT_BN_ERR_GCD_NO_ZERO
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_BNGCDCHECKINPUT_API_TC001(void)
{
BN_BigNum *r;
BN_BigNum *a;
BN_BigNum *b;
BN_Optimizer *opt = NULL;
TestMemInit();
r = BN_Create(BITS_OF_BYTE);
a = BN_Create(LONG_BN_BITS_256);
b = BN_Create(LONG_BN_BITS_256);
opt = BN_OptimizerCreate();
ASSERT_TRUE(BnGcdCheckInput(NULL, NULL, NULL, NULL) == CRYPT_NULL_INPUT);
ASSERT_TRUE(BN_SetLimb(a, BN_MAX_BITS) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SetLimb(b, BN_MAX_BITS) == CRYPT_SUCCESS);
ASSERT_TRUE(BnGcdCheckInput(r, a, b, opt) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Zeroize(a) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Zeroize(b) == CRYPT_SUCCESS);
ASSERT_TRUE(BnGcdCheckInput(r, a, b, opt) == CRYPT_BN_ERR_GCD_NO_ZERO);
EXIT:
BN_Destroy(r);
BN_Destroy(a);
BN_Destroy(b);
BN_OptimizerDestroy(opt);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_MODINVINPUTCHECK_API_TC001
* @title InverseInputCheck: Invalid parameter.
* @precon nan
* @brief
* 1. Call the InverseInputCheck method, parameters are null, expected result 1
* 2. Call the InverseInputCheck method, x and m are BN_MAX_BITS, expected result 2
* 3. Call the InverseInputCheck method, x and m are 0, expected result 3
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_SUCCESS
* 3. CRYPT_BN_ERR_DIVISOR_ZERO
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_MODINVINPUTCHECK_API_TC001(void)
{
BN_BigNum *r;
BN_BigNum *x;
BN_BigNum *m;
BN_Optimizer *opt = NULL;
TestMemInit();
r = BN_Create(BITS_OF_BYTE);
x = BN_Create(LONG_BN_BITS_256);
m = BN_Create(LONG_BN_BITS_256);
opt = BN_OptimizerCreate();
ASSERT_TRUE(r != NULL && x != NULL && m != NULL && opt != NULL);
ASSERT_TRUE(InverseInputCheck(NULL, NULL, NULL, NULL) == CRYPT_NULL_INPUT);
ASSERT_TRUE(BN_SetLimb(x, BN_MAX_BITS) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SetLimb(m, BN_MAX_BITS) == CRYPT_SUCCESS);
ASSERT_TRUE(InverseInputCheck(r, x, m, opt) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Zeroize(x) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Zeroize(m) == CRYPT_SUCCESS);
ASSERT_TRUE(InverseInputCheck(r, x, m, opt) == CRYPT_BN_ERR_DIVISOR_ZERO);
EXIT:
BN_Destroy(r);
BN_Destroy(x);
BN_Destroy(m);
BN_OptimizerDestroy(opt);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_U64_FUNC_TC001
* @title BN_U64Array2Bn/BN_Bn2U64Array test.
* @precon nan
* @brief
* 1. Randomly generate a 64-bit unsigned array.
* 2. Convert the array to a big number, and then convert the big number to array, expected result 1.
* 3. compare whether the arrays are the same, expected result 2
* @expect
* 1. CRYPT_SUCCESS
* 2. The two arrays are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_U64_FUNC_TC001(int len)
{
TestMemInit();
BN_BigNum *a = BN_Create(0);
uint64_t *input = calloc(1, len * sizeof(uint64_t));
uint64_t *output = calloc(1, len * sizeof(uint64_t));
uint32_t outlen = len;
for (int i = 0; i < len; i++) {
input[i] = rand();
}
input[len - 1] = 1;
ASSERT_TRUE(BN_U64Array2Bn(a, input, (uint32_t)len) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Bn2U64Array(a, output, &outlen) == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(input, output, outlen * sizeof(uint64_t)) == 0);
input[len - 1] = 0;
ASSERT_TRUE(BN_U64Array2Bn(a, input, len) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Bn2U64Array(a, output, &outlen) == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(input, output, outlen * sizeof(uint64_t)) == 0);
EXIT:
BN_Destroy(a);
free(input);
free(output);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_UINT_FUNC_TC001
* @title BN_Array2BN/BN_BN2Array test.
* @precon nan
* @brief
* 1. Randomly generate a BN_UINT unsigned array.
* 2. Convert the array to a big number, and then convert the big number to array, expected result 1.
* 3. compare whether the arrays are the same, expected result 2
* @expect
* 1. CRYPT_SUCCESS
* 2. The two arrays are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_UINT_FUNC_TC001(int len)
{
#if defined(HITLS_CRYPTO_CURVE_SM2_ASM) || (defined(HITLS_CRYPTO_CURVE_NISTP256_ASM) && \
defined(HITLS_CRYPTO_NIST_USE_ACCEL))
TestMemInit();
BN_BigNum *a = BN_Create(0);
BN_UINT *input = calloc(1, len * sizeof(BN_UINT));
BN_UINT *output = calloc(1, len * sizeof(BN_UINT));
for (int i = 0; i < len; i++) {
input[i] = rand();
}
ASSERT_TRUE(BN_Array2BN(a, input, len) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_BN2Array(a, output, len) == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(input, output, len * sizeof(BN_UINT)) == 0);
EXIT:
BN_Destroy(a);
free(input);
free(output);
#else
(void)len;
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_GCD_FUNC_TC001
* @title BN_Gcd test.
* @precon Vectors: two big numbers, result.
* @brief
* 1. Convert vectors to big numbers.
* 2. Call BN_Gcd to calculate the modular exponentiation, and compared to the vector value, expected result 1:
* (1) Pointer addresses for parameters are different from each other.
* (2) The address of the output parameter pointer r is the same as that of the input parameter pointer a.
* (3) The address of the output parameter pointer r is the same as that of the input parameter pointer b.
* 3. Test the scenario where the output parameter space is insufficient, expected result 1.
* @expect
* 1. The calculation result is consistent with the vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_GCD_FUNC_TC001(int sign1, Hex *hex1, int sign2, Hex *hex2, Hex *result)
{
TestMemInit();
BN_BigNum *out = NULL;
BN_Optimizer *opt = NULL;
uint32_t maxBits;
BN_BigNum *bn = TEST_VectorToBN(sign1, hex1->x, hex1->len);
BN_BigNum *bn2 = TEST_VectorToBN(sign2, hex2->x, hex2->len);
BN_BigNum *res = TEST_VectorToBN(0, result->x, result->len);
ASSERT_TRUE(bn != NULL && bn2 != NULL && res != NULL);
maxBits = TEST_GetMax(BN_Bits(bn), BN_Bits(bn2), 0);
out = BN_Create(maxBits + BIGNUM_REDUNDANCY_BITS);
ASSERT_TRUE(out != NULL);
opt = BN_OptimizerCreate();
ASSERT_TRUE(opt != NULL);
ASSERT_EQ(BN_Copy(out, bn), CRYPT_SUCCESS);
ASSERT_EQ(BN_Gcd(out, bn, bn2, opt), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("r != a", BN_Cmp(out, res) == 0);
ASSERT_EQ(BN_Copy(out, bn), CRYPT_SUCCESS);
ASSERT_EQ(BN_Gcd(out, out, bn2, opt), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("r == a", BN_Cmp(out, res) == 0);
ASSERT_EQ(BN_Copy(out, bn2), CRYPT_SUCCESS);
ASSERT_EQ(BN_Gcd(out, bn, out, opt), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("r == b", BN_Cmp(out, res) == 0);
BN_Destroy(out);
/* Test the scenario where the output parameter space is insufficient. */
out = BN_Create(0);
ASSERT_TRUE(out != NULL);
ASSERT_EQ(BN_Gcd(out, bn, bn2, opt), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("r != a", BN_Cmp(out, res) == 0);
BN_Destroy(out);
out = BN_Create(0);
ASSERT_TRUE(out != NULL);
ASSERT_EQ(BN_Copy(out, bn), CRYPT_SUCCESS);
ASSERT_EQ(BN_Gcd(out, out, bn2, opt), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("r == a", BN_Cmp(out, res) == 0);
BN_Destroy(out);
out = BN_Create(0);
ASSERT_TRUE(out != NULL);
ASSERT_EQ(BN_Copy(out, bn2), CRYPT_SUCCESS);
ASSERT_EQ(BN_Gcd(out, bn, out, opt), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("r == b", BN_Cmp(out, res) == 0);
EXIT:
BN_Destroy(bn);
BN_Destroy(bn2);
BN_Destroy(res);
BN_Destroy(out);
BN_OptimizerDestroy(opt);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_CMP_FUNC_TC001
* @title BN_Cmp test.
* @precon Vectors: two big numbers, result.
* @brief
* 1. Convert vectors to big numbers.
* 2. Call the BN_Cmp method to compare two large numbers, expected result 1.
* @expect
* 1. The comparison results are the same as 'result'.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_CMP_FUNC_TC001(int sign1, Hex *hex1, int sign2, Hex *hex2, int result)
{
TestMemInit();
BN_BigNum *bn1 = TEST_VectorToBN(sign1, hex1->x, hex1->len);
BN_BigNum *bn2 = TEST_VectorToBN(sign2, hex2->x, hex2->len);
/* bn1 and bn2 can be null. */
ASSERT_EQ(BN_Cmp(bn1, bn2), result);
EXIT:
BN_Destroy(bn1);
BN_Destroy(bn2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_ADD_FUNC_TC001
* @title BN_Add test.
* @precon a + b = r
* @brief
* 1. Convert vectors to big numbers.
* 2. Call the BN_Add method to calculate the sum of two large numbers, expected result 1.
* 3. If expectRet=CRYPT_SUCCESS and r=null(i.e.a=-b), call BN_IsZero to check whether sum is 0, expected result 2.
* 4. If expectRet=CRYPT_SUCCESS, call the BN_Cmp to compare r and resBn, expected result 3.
* @expect
* 1. The return value is the same as 'expectRet'.
* 2. The calculated sum is 0.
* 3. Both are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_ADD_FUNC_TC001(int sign1, int sign2, int sign3, Hex *a, Hex *b, Hex *r, int expectRet)
{
TestMemInit();
BN_BigNum *resBn = NULL;
BN_BigNum *bn1 = TEST_VectorToBN(sign1, a->x, a->len);
BN_BigNum *bn2 = TEST_VectorToBN(sign2, b->x, b->len);
BN_BigNum *sum = TEST_VectorToBN(sign3, r->x, r->len);
/* bn1, bn2 and sum can be null. */
resBn = BN_Create(SHORT_BN_BITS_128);
ASSERT_TRUE(resBn != NULL);
ASSERT_EQ(BN_Add(resBn, bn1, bn2), expectRet);
if (expectRet == CRYPT_SUCCESS) {
if (r->len == 0) {
ASSERT_EQ(BN_IsZero(resBn), 1);
} else {
ASSERT_EQ(BN_Cmp(resBn, sum), 0);
}
}
EXIT:
BN_Destroy(bn1);
BN_Destroy(bn2);
BN_Destroy(sum);
BN_Destroy(resBn);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_BN_TO_BIN_FIX_ZERO_API_TC001
* @title BN_Bn2BinFixZero test.
* @precon nan
* @brief
* 1. Call the BN_Create method to create bn, parameter is 0, expected result 1.
* 2. Call the BN_Bn2BinFixZero method, expected result 2:
* (1) bn is null
* (2) bin is null
* (3) binLen is 0
* 3. Call the BN_Bn2BinFixZero method, all parameters are valid, expected result 3
* 4. Destroy bn and recreate bn, bits is 128, expected result 4.
* 5. Set the highest bit of bn to 1, expected result 5.
* 6. Call the BN_Bn2BinFixZero method, binLen is 1, expected result 6.
* @expect
* 1. Success.
* 2. CRYPT_NULL_INPUT.
* 3. CRYPT_SUCCESS.
* 4. Success.
* 5. CRYPT_SUCCESS.
* 6. CRYPT_BN_BUFF_LEN_NOT_ENOUGH.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_BN_TO_BIN_FIX_ZERO_API_TC001(void)
{
TestMemInit();
uint8_t bin[1] = {0};
BN_BigNum *bn = BN_Create(0);
ASSERT_TRUE(bn != NULL);
ASSERT_EQ(BN_Bn2BinFixZero(NULL, bin, 1), CRYPT_NULL_INPUT);
ASSERT_EQ(BN_Bn2BinFixZero(bn, NULL, 1), CRYPT_NULL_INPUT);
ASSERT_EQ(BN_Bn2BinFixZero(bn, bin, 0), CRYPT_NULL_INPUT);
// bn bytes is 0
ASSERT_EQ(BN_Bn2BinFixZero(bn, bin, 1), CRYPT_SUCCESS);
BN_Destroy(bn);
bn = BN_Create(SHORT_BN_BITS_128);
ASSERT_TRUE(bn != NULL);
ASSERT_EQ(BN_SetBit(bn, SHORT_BN_BITS_128 - 1), CRYPT_SUCCESS);
ASSERT_EQ(BN_Bn2BinFixZero(bn, bin, 1), CRYPT_BN_BUFF_LEN_NOT_ENOUGH);
EXIT:
BN_Destroy(bn);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_BN_Rand_API_TC001(void)
{
TEST_BnTestCaseInit();
BN_BigNum bn[2] = {{0}};
BN_UINT bn_data[DH_BN_DIGITS_MAX * 2] = { 0 };
BN_Init(bn, bn_data, DH_BN_DIGITS_MAX, 2);
ASSERT_TRUE(BN_Rand(&bn[0], 8192, 1, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_RandRange(&bn[1], &bn[0]) == CRYPT_SUCCESS);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_BN_Add_API_TC001(void)
{
TEST_BnTestCaseInit();
BN_BigNum bn[3] = {{0}};
BN_UINT bn_data[BN_DIGITS_MAX * 3] = { 0 };
BN_Init(bn, bn_data, BN_DIGITS_MAX, 3);
ASSERT_TRUE(BN_Rand(&bn[0], 4096, 1, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Rand(&bn[1], 4096, 1, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Add(&bn[2], &bn[0], &bn[1]) == CRYPT_SUCCESS);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_BN_Mul_API_TC001(void)
{
TEST_BnTestCaseInit();
BN_Optimizer *opt = BN_OptimizerCreate();
BN_BigNum bn[2] = {{0}};
BN_BigNum rn = {0};
BN_UINT bn_data[BN_DIGITS_MAX * 2] = { 0 };
BN_UINT r_data[DH_BN_DIGITS_MAX * 2] = { 0 };
BN_Init(bn, bn_data, BN_DIGITS_MAX, 2);
ASSERT_TRUE(BN_Rand(&bn[0], 4096, 1, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Rand(&bn[1], 4096, 1, 1) == CRYPT_SUCCESS);
BN_Init(&rn, r_data, DH_BN_DIGITS_MAX, 1);
ASSERT_TRUE(BN_Mul(&rn, &bn[0], &bn[1], opt) == CRYPT_SUCCESS);
EXIT:
BN_OptimizerDestroy(opt);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_BN_Div_API_TC001(void)
{
TEST_BnTestCaseInit();
BN_Optimizer *opt = BN_OptimizerCreate();
BN_BigNum bn[4] = {{0}};
BN_UINT bn_data[BN_DIGITS_MAX * 4] = { 0 };
BN_Init(bn, bn_data, BN_DIGITS_MAX, 4);
ASSERT_TRUE(BN_Rand(&bn[2], 4096, 1, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Rand(&bn[3], 4096, 1, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Div(&bn[0], &bn[1], &bn[2], &bn[3], opt) == CRYPT_SUCCESS);
EXIT:
BN_OptimizerDestroy(opt);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_BN_Mod_API_TC001(void)
{
TEST_BnTestCaseInit();
BN_Optimizer *opt = BN_OptimizerCreate();
BN_UINT res = 0;
BN_UINT input = 3;
BN_BigNum bn[4] = {{0}};
BN_UINT bn_data[BN_DIGITS_MAX * 4] = { 0 };
BN_Init(bn, bn_data, BN_DIGITS_MAX, 4);
ASSERT_TRUE(BN_Rand(&bn[1], 4096, 1, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Rand(&bn[2], 4096, 1, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Rand(&bn[3], 4096, 1, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_ModMul(&bn[0], &bn[1], &bn[2], &bn[3], opt) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_ModSqr(&bn[0], &bn[1], &bn[2], opt) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_ModAdd(&bn[0], &bn[1], &bn[2], &bn[3], opt) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_ModLimb(&res, &bn[1], input) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_AddLimb(&bn[0], &bn[1], input) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SetLimb(&bn[0], input) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Cmp(&bn[1], &bn[2]) != CRYPT_SUCCESS);
EXIT:
BN_OptimizerDestroy(opt);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_BN_ModLimb_API_TC001(void)
{
TEST_BnTestCaseInit();
BN_Optimizer *opt = BN_OptimizerCreate();
ASSERT_TRUE(opt != NULL);
BN_UINT res = 0;
BN_UINT input = 3;
BN_BigNum bn[2] = {{0}};
BN_UINT bn_data[DH_BN_DIGITS_MAX * 2] = { 0 };
BN_Init(bn, bn_data, DH_BN_DIGITS_MAX, 2);
ASSERT_TRUE(BN_ModLimb(&res, &bn[1], input) == CRYPT_SUCCESS);
EXIT:
BN_OptimizerDestroy(opt);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_BN_rshift_API_TC001(void)
{
TEST_BnTestCaseInit();
BN_UINT input = 3;
BN_BigNum bn[2] = {{0}};
BN_UINT bn_data[DH_BN_DIGITS_MAX * 2] = { 0 };
BN_Init(bn, bn_data, DH_BN_DIGITS_MAX, 2);
ASSERT_TRUE(BN_Rand(&bn[1], 4096, 1, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Rshift(&bn[0], &bn[1], input) == CRYPT_SUCCESS);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_BN_ModExp_API_TC001(void)
{
TEST_BnTestCaseInit();
BN_Optimizer *opt = BN_OptimizerCreate();
ASSERT_TRUE(opt != NULL);
BN_BigNum bn[4] = {{0}};
BN_UINT bn_data[DH_BN_DIGITS_MAX * 4] = { 0 };
BN_Init(bn, bn_data, DH_BN_DIGITS_MAX, 4);
ASSERT_TRUE(BN_Rand(&bn[1], 8192, 1, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Rand(&bn[2], 8192, 1, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Rand(&bn[3], 8192, 1, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_ModExp(&bn[0], &bn[1], &bn[2], &bn[3], opt) == CRYPT_SUCCESS);
EXIT:
BN_OptimizerDestroy(opt);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_BN_SET_FLAG_TC001(void)
{
TEST_BnTestCaseInit();
BN_BigNum a = {0};
ASSERT_TRUE(BN_SetFlag(&a, 0xFF) == CRYPT_BN_FLAG_INVALID);
ASSERT_TRUE(BN_SetFlag(&a, CRYPT_BN_FLAG_STATIC) == CRYPT_SUCCESS);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_BN_GETLIMB_API_TC001(void)
{
TEST_BnTestCaseInit();
int32_t ret;
BN_BigNum *a = BN_Create(LONG_BN_BITS_256);
ASSERT_TRUE(a != NULL);
ASSERT_TRUE(BN_GetLimb(NULL) == 0);
ret = BN_SetLimb(a, 0);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(BN_GetLimb(a) == 0);
ret = BN_SetLimb(a, 1);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(BN_GetLimb(a) == 1);
ret = BN_SetLimb(a, 2);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(BN_GetLimb(a) == 2);
ret = BN_SetLimb(a, BN_UINT_MAX - 1);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(BN_GetLimb(a) == BN_UINT_MAX - 1);
ret = BN_SetLimb(a, BN_UINT_MAX);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(BN_GetLimb(a) == BN_UINT_MAX);
ret = BN_Lshift(a, a, BN_UINT_MAX + 1);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(BN_GetLimb(a) == BN_UINT_MAX);
EXIT:
BN_Destroy(a);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_BN_MASKBIT_API_TC001(void)
{
TEST_BnTestCaseInit();
ASSERT_TRUE(BN_MaskBit(NULL, 0) == CRYPT_NULL_INPUT);
int32_t ret;
BN_BigNum *bn = BN_Create(1);
ret = BN_SetBit(bn, 1);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
BN_SetSign(bn, 1);
ret = BN_MaskBit(bn, 0);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(bn->sign == 0);
ret = BN_SetLimb(bn, BN_UINT_MAX * 2);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = BN_MaskBit(bn, BN_UINT_BITS * 3);
ASSERT_TRUE(ret == CRYPT_BN_SPACE_NOT_ENOUGH);
EXIT:
BN_Destroy(bn);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_BN_MULLIMB_API_TC001(void)
{
TEST_BnTestCaseInit();
int32_t ret;
uint8_t buff[LONG_BN_BYTES_32];
BN_BigNum *a = BN_Create(LONG_BN_BITS_256);
BN_BigNum *b = BN_Create(LONG_BN_BITS_256);
BN_BigNum *r1 = BN_Create(LONG_BN_BITS_256);
BN_BigNum *r2 = BN_Create(LONG_BN_BITS_256 * 2); // 512 == 2 * 256
BN_BigNum *zero = BN_Create(LONG_BN_BITS_256);
BN_Optimizer *opt = BN_OptimizerCreate();
ASSERT_TRUE(a != NULL);
ASSERT_TRUE(b != NULL);
ASSERT_TRUE(r1 != NULL);
ASSERT_TRUE(r2 != NULL);
ASSERT_TRUE(zero != NULL);
ASSERT_TRUE(opt != NULL);
memset_s(buff, sizeof(buff), 0xFF, LONG_BN_BYTES_32);
ret = BN_Bin2Bn(a, buff, LONG_BN_BYTES_32);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = BN_SetLimb(b, BN_UINT_MAX);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = BN_Zeroize(zero);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(BN_IsZero(zero));
// NULL
ASSERT_TRUE(BN_MulLimb(NULL, a, BN_UINT_MAX) == CRYPT_NULL_INPUT);
ASSERT_TRUE(BN_MulLimb(r1, NULL, BN_UINT_MAX) == CRYPT_NULL_INPUT);
// a == 0
ret = BN_MulLimb(r1, zero, BN_UINT_MAX);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(BN_IsZero(r1));
// w == 0
ret = BN_MulLimb(r1, a, 0);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(BN_IsZero(r1));
// a == 0
ret = BN_MulLimb(r1, a, BN_UINT_MAX);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = BN_Mul(r2, a, b, opt);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Cmp(r1, r2) == CRYPT_SUCCESS);
EXIT:
BN_Destroy(a);
BN_Destroy(b);
BN_Destroy(r1);
BN_Destroy(r2);
BN_Destroy(zero);
BN_OptimizerDestroy(opt);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_BN_DIVLIMB_API_TC001(void)
{
TEST_BnTestCaseInit();
int32_t ret;
uint8_t buff[LONG_BN_BYTES_32];
BN_BigNum *a = BN_Create(LONG_BN_BITS_256);
BN_BigNum *b = BN_Create(LONG_BN_BITS_256);
BN_BigNum *r1 = BN_Create(LONG_BN_BITS_256);
BN_BigNum *r2 = BN_Create(LONG_BN_BITS_256 * 2); // 512 == 2 * 256
BN_BigNum *res2 = BN_Create(LONG_BN_BITS_256 * 2); // 512 == 2 * 256
BN_BigNum *zero = BN_Create(LONG_BN_BITS_256);
BN_Optimizer *opt = BN_OptimizerCreate();
ASSERT_TRUE(a != NULL);
ASSERT_TRUE(b != NULL);
ASSERT_TRUE(r1 != NULL);
ASSERT_TRUE(r2 != NULL);
ASSERT_TRUE(zero != NULL);
ASSERT_TRUE(opt != NULL);
BN_UINT res1;
// BN_UINT res2;
memset_s(buff, sizeof(buff), 0xFF, LONG_BN_BYTES_32);
ret = BN_Bin2Bn(a, buff, LONG_BN_BYTES_32);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = BN_SetLimb(b, BN_UINT_MAX);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = BN_Zeroize(zero);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(BN_IsZero(zero));
// NULL
ASSERT_TRUE(BN_DivLimb(NULL, &res1, a, BN_UINT_MAX) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_DivLimb(r1, NULL, a, BN_UINT_MAX) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_DivLimb(NULL, NULL, a, BN_UINT_MAX) == CRYPT_NULL_INPUT);
ASSERT_TRUE(BN_DivLimb(r1, &res1, NULL, BN_UINT_MAX) == CRYPT_NULL_INPUT);
// a == 0
ret = BN_DivLimb(r1, &res1, zero, BN_UINT_MAX);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(BN_IsZero(r1));
ASSERT_TRUE(res1 == 0);
// w == 0
ret = BN_DivLimb(r1, &res1, a, 0);
ASSERT_TRUE(ret == CRYPT_BN_ERR_DIVISOR_ZERO);
ret = BN_Copy(r1, a);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = BN_DivLimb(r1, &res1, r1, BN_UINT_MAX);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = BN_Div(r2, res2, a, b, opt);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Cmp(r1, r2) == CRYPT_SUCCESS);
ASSERT_TRUE(res1 == res2->data[0]);
EXIT:
BN_Destroy(a);
BN_Destroy(b);
BN_Destroy(r1);
BN_Destroy(r2);
BN_Destroy(res2);
BN_Destroy(zero);
BN_OptimizerDestroy(opt);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_BN_EXTEND_API_TC001(void)
{
TEST_BnTestCaseInit();
uint32_t word = BITS_TO_BN_UNIT(BN_MAX_BITS) + 1;
BN_BigNum *a = BN_Create(LONG_BN_BITS_256);
ASSERT_TRUE(a != NULL);
ASSERT_TRUE(BN_Extend(a, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_SetFlag(a, CRYPT_BN_FLAG_STATIC) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Extend(a, word) == CRYPT_BN_NOT_SUPPORT_EXTENSION);
ASSERT_TRUE(BN_SetFlag(a, CRYPT_BN_FLAG_CONSTTIME) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Extend(a, word) == CRYPT_BN_BITS_TOO_MAX);
ASSERT_TRUE(BN_Extend(a, word - 1) == CRYPT_SUCCESS);
EXIT:
BN_Destroy(a);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_BN_FIXSIZE_API_TC001(void)
{
TEST_BnTestCaseInit();
BN_BigNum *a = BN_Create(LONG_BN_BITS_256);
ASSERT_TRUE(a != NULL);
a->size = 1;
BN_FixSize(a);
ASSERT_TRUE(a->size == 0);
EXIT:
BN_Destroy(a);
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/bn/test_suite_sdv_bn.c | C | unknown | 72,996 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "securec.h"
#include "crypt_eal_mac.h"
#include "crypt_errno.h"
#include "bsl_sal.h"
#define CBC_MAC_MAC_LEN 16
#define SM4_KEY_LEN 16
#define SM4_IV_LEN 16
#define SM4_BLOCK_SIZE 16
#define TEST_FAIL (-1)
#define TEST_SUCCESS (0)
#define DATA_MAX_LEN (65538)
/* END_HEADER */
/* @
* @test SDV_CRYPT_EAL_CBC_MAC_API_TC001
* @spec -
* @title Impact of the algorithm ID on the CRYPT_EAL_MacNewCtx interface
* @precon nan
* @brief 1. algorithm is CRYPT_MAC_CBC_MAC_SM4
2. algorithm is CRYPT_MAC_MAX
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CBC_MAC_API_TC001(void)
{
TestMemInit();
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(CRYPT_MAC_CBC_MAC_SM4);
ASSERT_TRUE(ctx != NULL);
CRYPT_EAL_MacFreeCtx(ctx);
EXIT:
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CMAC_API_TC003
* @spec -
* @title Impact of the ctx status on the CRYPT_EAL_MacInit interface
* @precon nan
* @brief
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CBC_MAC_API_TC003(int algId, int padType)
{
if (IsMacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
const uint32_t keyLen = SM4_KEY_LEN;
uint8_t key[keyLen];
uint32_t macLen = CBC_MAC_MAC_LEN;
uint8_t mac[macLen];
const uint32_t dataLen = CBC_MAC_MAC_LEN;
uint8_t data[dataLen];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, keyLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, keyLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_CBC_MAC_PADDING, &padType, sizeof(CRYPT_PaddingType)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, keyLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, keyLen) == CRYPT_SUCCESS);
CRYPT_EAL_MacDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, keyLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, keyLen) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CBC_MAC_API_TC004
* @spec -
* @title Impact of Input Parameters on the CRYPT_EAL_MacUpdate Interface
* @precon nan
* @brief
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CBC_MAC_API_TC004(int algId, int padType)
{
if (IsMacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
const uint32_t len = SM4_KEY_LEN;
uint8_t key[len];
const uint32_t dataLen = SM4_KEY_LEN;
uint8_t data[dataLen];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_CBC_MAC_PADDING, &padType, sizeof(CRYPT_PaddingType)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(NULL, data, dataLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, NULL, dataLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CBC_MAC_API_TC005
* @spec -
* @title Impact of the ctx status on the CRYPT_EAL_MacUpdate interface
* @precon nan
* @brief
15.update成功，返回CRYPT_SUCCESS
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CBC_MAC_API_TC005(int algId, int padType)
{
if (IsMacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
const uint32_t len = SM4_KEY_LEN;
uint8_t key[len];
uint32_t macLen = CBC_MAC_MAC_LEN;
uint8_t mac[macLen];
const uint32_t dataLen = SM4_KEY_LEN;
uint8_t data[dataLen];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_CBC_MAC_PADDING, &padType, sizeof(CRYPT_PaddingType)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_EAL_ERR_STATE);
CRYPT_EAL_MacDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CBC_MAC_API_TC006
* @spec -
* @title Impact of Input Parameters on the CRYPT_EAL_MacFinal Interface
* @precon nan
* @brief
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CBC_MAC_API_TC006(int algId, int padType)
{
if (IsMacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
const uint32_t len = SM4_KEY_LEN;
uint8_t key[len];
uint32_t macLen = CBC_MAC_MAC_LEN;
uint8_t mac[macLen];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_CBC_MAC_PADDING, &padType, sizeof(CRYPT_PaddingType)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(NULL, mac, &macLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, NULL, &macLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, NULL) == CRYPT_NULL_INPUT);
macLen = CBC_MAC_MAC_LEN - 1;
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_CBC_MAC_OUT_BUFF_LEN_NOT_ENOUGH);
macLen = CBC_MAC_MAC_LEN + 1;
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CBC_MAC_API_TC007
* @spec -
* @title Impact of ctx Status Change on the CRYPT_EAL_MacFinal Interface
* @precon nan
* @brief
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CBC_MAC_API_TC007(int algId, int padType, Hex *key1, Hex *mac1, Hex *key2, Hex *data2, Hex *mac2, Hex *mac3)
{
if (IsMacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
uint32_t macLen = CBC_MAC_MAC_LEN;
uint8_t mac[macLen];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data2->x, data2->len) == CRYPT_EAL_ERR_STATE);
// mac1
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key1->x, key1->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_CBC_MAC_PADDING, &padType, sizeof(CRYPT_PaddingType)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("mac1 result cmp", mac, macLen, mac1->x, mac1->len);
// mac2
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key2->x, key2->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data2->x, data2->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("mac2 result cmp", mac, macLen, mac2->x, mac2->len);
CRYPT_EAL_MacDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_EAL_ERR_STATE);
// mac3
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key2->x, key2->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("mac3 result cmp", mac, macLen, mac3->x, mac3->len);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_EAL_ERR_STATE);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CBC_MAC_API_TC008
* @spec -
* @title Impact of Input Parameters on the CRYPT_EAL_GetMacLen Interface.
* @precon nan
* @brief
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CBC_MAC_API_TC008(int algId)
{
if (IsMacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
const uint32_t len = SM4_KEY_LEN;
uint8_t key[len];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(NULL) == 0);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == CBC_MAC_MAC_LEN);
uint32_t result = 0;
ASSERT_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_GET_MACLEN, &result, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(result == CBC_MAC_MAC_LEN);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CBC_MAC_API_TC009
* @spec -
* @title Impact of the ctx Status on the CRYPT_EAL_GetMacLen Interface
* @precon nan
* @brief
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CBC_MAC_API_TC009(int algId, int padType)
{
if (IsMacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
const uint32_t len = SM4_KEY_LEN;
uint8_t key[len];
uint32_t macLen = CBC_MAC_MAC_LEN;
uint8_t mac[macLen];
const uint32_t dataLen = CBC_MAC_MAC_LEN;
uint8_t data[dataLen];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == CBC_MAC_MAC_LEN);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == CBC_MAC_MAC_LEN);
ASSERT_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_CBC_MAC_PADDING, &padType, sizeof(CRYPT_PaddingType)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == CBC_MAC_MAC_LEN);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == CBC_MAC_MAC_LEN);
CRYPT_EAL_MacDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == CBC_MAC_MAC_LEN);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == CBC_MAC_MAC_LEN);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CBC_MAC_API_TC010
* @spec -
* @title Impact of Input Parameters on the CRYPT_EAL_MacDeinit Interface Test
* @precon nan
* @brief
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CBC_MAC_API_TC010(int algId)
{
if (IsMacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
const uint32_t len = SM4_KEY_LEN;
uint8_t key[len];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
CRYPT_EAL_MacDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
CRYPT_EAL_MacDeinit(NULL);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CBC_MAC_API_TC011
* @spec -
* @title Impact of Input Parameters on the CRYPT_EAL_MacReinit Interface
* @precon nan
* @brief
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CBC_MAC_API_TC011(int algId)
{
if (IsMacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
const uint32_t len = SM4_KEY_LEN;
uint8_t key[len];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(NULL) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CBC_MAC_API_TC012
* @spec -
* @title Impact of ctx status change on the CRYPT_EAL_MacReinit interface
* @precon nan
* @brief
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CBC_MAC_API_TC012(int algId, int padType)
{
if (IsMacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
const uint32_t len = SM4_KEY_LEN;
uint8_t key[len];
uint32_t macLen = CBC_MAC_MAC_LEN;
uint8_t mac[macLen];
const uint32_t dataLen = SM4_KEY_LEN;
uint8_t data[dataLen];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_CBC_MAC_PADDING, &padType, sizeof(CRYPT_PaddingType)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
CRYPT_EAL_MacDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_EAL_ERR_STATE);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CBC_MAC_FUN_TC004
* @spec -
* @title Impact of All-0 and All-F Data Keys on CBC MAC Calculation
* @precon nan
* @brief
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CBC_MAC_FUN_TC004(int algId, int padType, Hex *key, Hex *data, Hex *vecMac)
{
if (IsMacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
uint32_t macLen = CBC_MAC_MAC_LEN;
uint8_t mac[macLen];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key->x, key->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_CBC_MAC_PADDING, &padType, sizeof(CRYPT_PaddingType)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data->x, data->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("mac1 result cmp", mac, macLen, vecMac->x, vecMac->len);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
static int32_t UpdateMultiTime(CRYPT_EAL_MacCtx *ctx, Hex *data, int updateTimes, uint8_t *mac, uint32_t *macLen)
{
int32_t ret = CRYPT_SUCCESS;
for (int i = 0; i < updateTimes; i++) {
ret = CRYPT_EAL_MacUpdate(ctx, data->x, data->len);
if (ret != CRYPT_SUCCESS) {
return ret;
}
}
return CRYPT_EAL_MacFinal(ctx, mac, macLen);
}
/* @
* @test SDV_CRYPT_EAL_CBC_MAC_FUN_TC006
* @spec -
* @title Compare the cmac results of multiple updates and one update.
* @precon nan
* @brief
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CBC_MAC_FUN_TC006(int algId, int padType, Hex *key, Hex *data, int updateTimes)
{
if (IsMacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
uint32_t macLen1 = CBC_MAC_MAC_LEN;
uint8_t mac1[CBC_MAC_MAC_LEN] = {};
uint32_t macLen2 = CBC_MAC_MAC_LEN;
uint8_t mac2[CBC_MAC_MAC_LEN] = {};
uint8_t *totalInData = NULL;
uint32_t totalLen = 0;
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key->x, key->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_CBC_MAC_PADDING, &padType,
sizeof(CRYPT_PaddingType)) == CRYPT_SUCCESS);
ASSERT_TRUE(UpdateMultiTime(ctx, data, updateTimes, mac1, &macLen1) == CRYPT_SUCCESS);
CRYPT_EAL_MacDeinit(ctx);
totalInData = BSL_SAL_Calloc(data->len * updateTimes, 1);
ASSERT_TRUE(totalInData != NULL);
for (int i = 0; i < updateTimes; i++) {
memcpy(totalInData + totalLen, data->x, data->len);
totalLen += data->len;
}
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key->x, key->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_CBC_MAC_PADDING, &padType,
sizeof(CRYPT_PaddingType)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, totalInData, totalLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac2, &macLen2) == CRYPT_SUCCESS);
ASSERT_TRUE(macLen1 == macLen2);
ASSERT_COMPARE("mac1 vs mac2 result cmp", mac2, macLen2, mac1, macLen1);
EXIT:
BSL_SAL_FREE(totalInData);
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_CBC_MAC_SAMEADDR_FUNC_TC001
* @title CBC-MAC in/out同地址测试
* @precon nan
* @brief
* 1.使用EAL层接口进行CBC-MAC计算,其中所有的输入和输出地址相同,有预期结果1
* @expect
* 1.计算成功，结果与mac向量一致
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CBC_MAC_SAMEADDR_FUNC_TC001(int algId, Hex *key, Hex *data, Hex *mac)
{
TestMacSameAddr(algId, key, data, mac);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_CBC_MAC_ADDR_NOT_ALIGN_FUNC_TC001
* @title CBC-MAC 非地址对齐测试
* @precon nan
* @brief
* 1.使用EAL层接口进行CBC-MAC计算,其中所有的buffer地址未对齐,有预期结果1
* @expect
* 1.计算成功，结果与mac向量一致
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CBC_MAC_ADDR_NOT_ALIGN_FUNC_TC001(int algId, Hex *key, Hex *data, Hex *mac)
{
TestMacAddrNotAlign(algId, key, data, mac);
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/cbc_mac/test_suite_sdv_eal_mac_cbc_mac.c | C | unknown | 19,510 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "crypt_errno.h"
#include "crypt_eal_cipher.h"
#include "bsl_sal.h"
#include "securec.h"
/* END_HEADER */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_INIT_API_TC001
* @title CRYPT_EAL_CipherInit Invalid input parameter
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface, ctx is NULL, other parameters are normal. Expected result 1 is obtained.
* 3.Call the Init interface, key is NULL, other parameters are normal. Expected result 2 is obtained.
* 4.Call the Init interface, iv is NULL, other parameters are normal. Expected result 2 is obtained.
* @expect
* 1.Failed. Return CRYPT_NULL_INPUT.
* 2.Failed. Return CRYPT_NULL_INPUT.
* 3.Failed. Return CRYPT_NULL_INPUT.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_INIT_API_TC001(void)
{
TestMemInit();
uint8_t key[32] = {0};
uint8_t iv[12] = {0};
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(CRYPT_EAL_CipherInit(NULL, key, sizeof(key), iv, sizeof(iv), true) == CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, NULL, sizeof(key), iv, sizeof(iv), true), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, sizeof(key), NULL, sizeof(iv), true), CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_INIT_API_TC002
* @title CRYPT_EAL_CipherInit Invalid input parameter
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface with keyLen is 33, other parameters are normal. Expected result 1 is obtained.
* 3.Call the Init interface with keyLen is 31, other parameters are normal. Expected result 2 is obtained.
* 4.Call the Init interface with ivLen is 11, other parameters are normal. Expected result 3 is obtained.
* 5.Call the Init interface with ivLen is 13, other parameters are normal. Expected result 4 is obtained.
* 6.Call the Init interface with ivLen is 9, other parameters are normal. Expected result 5 is obtained.
* 7.Call the Init interface with ivLen is 7, other parameters are normal. Expected result 6 is obtained.
* @expect
* 1.Failed. Return CRYPT_CHACHA20_KEYLEN_ERROR.
* 2.Failed. Return CRYPT_CHACHA20_KEYLEN_ERROR.
* 3.Failed. Return CRYPT_MODES_IVLEN_ERROR.
* 4.Failed. Return CRYPT_MODES_IVLEN_ERROR.
* 5.Failed. Return CRYPT_MODES_IVLEN_ERROR.
* 6.Failed. Return CRYPT_MODES_IVLEN_ERROR.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_INIT_API_TC002(void)
{
TestMemInit();
uint8_t key[32] = {0};
uint8_t iv[12] = {0};
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, (uint8_t *)key, 33, iv, sizeof(iv), true),
CRYPT_CHACHA20_KEYLEN_ERROR);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, (uint8_t *)key, 31, iv, sizeof(iv), true),
CRYPT_CHACHA20_KEYLEN_ERROR);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, sizeof(key), (uint8_t *)iv, 13, true),
CRYPT_MODES_IVLEN_ERROR);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, sizeof(key), (uint8_t *)iv, 11, true),
CRYPT_MODES_IVLEN_ERROR);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, sizeof(key), (uint8_t *)iv, 9, true),
CRYPT_MODES_IVLEN_ERROR);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, sizeof(key), (uint8_t *)iv, 7, true),
CRYPT_MODES_IVLEN_ERROR);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_REINIT_API_TC001
* @title CRYPT_EAL_CipherReinit Invalid input parameter Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx.
* 2.Call the Init interface. Expected result 1 is obtained.
* 3.Call the Reinit interface with iv is NULL, and set other parameters correctly. Expected result 2 is obtained.
* 4.Call the Reinit interface with ctx is NULL, and set other parameters correctly. Expected result 3 is obtained.
* @expect
* 1.The init is successful and return CRYPT_SUCCESS.
* 2.Failed. Return CRYPT_NULL_INPUT.
* 3.Failed. Return CRYPT_NULL_INPUT.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_REINIT_API_TC001(void)
{
TestMemInit();
uint8_t key[32] = {0};
uint8_t iv[12] = {0};
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key, sizeof(key), iv, sizeof(iv), true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, NULL, sizeof(iv)) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(NULL, iv, sizeof(iv)) == CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_REINIT_API_TC002
* @title CRYPT_EAL_CipherReinit Invalid input parameter Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx.
* 2.Call the Init interface. Expected result 1 is obtained.
* 3.Call the Reinit interface with ivLen is 11, and set other parameters correctly. Expected result 2 is obtained.
* 4.Call the Reinit interface with ivLen is 13, and set other parameters correctly. Expected result 3 is obtained.
* 5.Call the Reinit interface with ivLen is 9, and set other parameters correctly. Expected result 4 is obtained.
* 6.Call the Reinit interface with ivLen is 7, and set other parameters correctly. Expected result 5 is obtained.
* @expect
* 1.The init is successful and return CRYPT_SUCCESS.
* 2.Failed. Return CRYPT_MODES_IVLEN_ERROR.
* 3.Failed. Return CRYPT_MODES_IVLEN_ERROR.
* 4.Failed. Return CRYPT_MODES_IVLEN_ERROR.
* 5.Failed. Return CRYPT_MODES_IVLEN_ERROR.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_REINIT_API_TC002(void)
{
TestMemInit();
uint8_t key[32] = {0};
uint8_t iv[12] = {0};
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key, sizeof(key), iv, sizeof(iv), true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, (uint8_t *)iv, 13) == CRYPT_MODES_IVLEN_ERROR);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, (uint8_t *)iv, 11) == CRYPT_MODES_IVLEN_ERROR);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, (uint8_t *)iv, 9) == CRYPT_MODES_IVLEN_ERROR);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, (uint8_t *)iv, 7) == CRYPT_MODES_IVLEN_ERROR);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_REINIT_API_TC003
* @title Call sequence error Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx.
* 2.Call the Reinit interface. All parameters are normal. Expected result 1 is obtained.
* @expect
* 1.Failed. Return CRYPT_EAL_ERR_STATE.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_REINIT_API_TC003(void)
{
TestMemInit();
uint8_t iv[12] = {0};
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, iv, sizeof(iv)) == CRYPT_EAL_ERR_STATE);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_UPDATE_API_TC001
* @title Invalid input parameter of CRYPT_EAL_CipherUpdate Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx.
* 2.Call the Init interface. Expected result 1 is obtained.
* 3.Call the Ctrl interface to set aad. Expected result 2 is obtained.
* 4.Call the Update interface, ctx is NULL, and other parameters are normal. Expected result 3 is obtained.
* 4.Call the Update interface, in is NULL, and other parameters are normal. Expected result 4 is obtained.
* 5.Call the Update interface, inLen is 0, and other parameters are normal. Expected result 5 is obtained.
* 6.Call the Update interface, out is NULL, and other parameters are normal. Expected result 6 is obtained.
* 7.Call the Update interface, outLen is NULL, and other parameters are normal. Expected result 7 is obtained.
* @expect
* 1.The init is successful and return CRYPT_SUCCESS.
* 2.Success. Return CRYPT_SUCCESS.
* 3.Failed. Return CRYPT_NULL_INPUT.
* 4.Failed. Return CRYPT_NULL_INPUT.
* 5.Success. Return CRYPT_SUCCESS.
* 6.Failed. Return CRYPT_NULL_INPUT.
* 7.Failed. Return CRYPT_NULL_INPUT.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_API_TC001(void)
{
TestMemInit();
uint8_t key[32] = {0};
uint8_t iv[12] = {0};
uint8_t data[100] = {0};
uint8_t aad[20] = {0};
uint8_t out[100];
uint32_t outLen = sizeof(out);
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key, sizeof(key), iv, sizeof(iv), true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(NULL, data, sizeof(data), out, &outLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, NULL, sizeof(data), out, &outLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data, 0, out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data, sizeof(data), NULL, &outLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data, sizeof(data), (uint8_t *)out, NULL) == CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_UPDATE_API_TC002
* @title CRYPT_EAL_CipherUpdate Invalid input parameter Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx.
* 2.Call the Init interface. All parameters are normal. Expected result 1 is obtained.
* 3.Call the Ctrl interface to set aad. Expected result 2 is obtained.
* 4.Call the Update interface, outLen is inLen - 1, and other parameters are normal. Expected result 3 is obtained.
* @expect
* 1.The init is successful and return CRYPT_SUCCESS.
* 2.Success. Return CRYPT_SUCCESS.
* 3.Failed. The buffer is not enough.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_API_TC002(void)
{
TestMemInit();
uint8_t key[32] = {0};
uint8_t iv[12] = {0};
uint8_t data[100] = {0};
uint8_t aad[20] = {0};
uint8_t out[100];
uint32_t outLen = sizeof(data) - 1;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, sizeof(key), iv, sizeof(iv), true), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)), CRYPT_SUCCESS);
ASSERT_NE(CRYPT_EAL_CipherUpdate(ctx, data, sizeof(data), (uint8_t *)out, &outLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_UPDATE_API_TC003
* @title CRYPT_EAL_CipherUpdate Error State Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx.
* 2.Call the Update interface. All parameters are normal. Expected result 1 is obtained.
* @expect
* 1.Failed. return CRYPT_EAL_ERR_STATE.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_API_TC003(void)
{
TestMemInit();
uint8_t data[100] = {0};
uint8_t out[100];
uint32_t outLen = sizeof(out);
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data, sizeof(data), out, &outLen) == CRYPT_EAL_ERR_STATE);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_CTRL_API_TC001
* @title CRYPT_EAL_CipherCtrl set aad invalid parameter Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx.
* 2.Call the Init interface. All parameters are normal. Expected result 1 is obtained.
* 3.Call the Ctrl interface to set aad with aad is NULL and aadLen is not 0. Expected result 2 is obtained.
* 4.Call the Ctrl interface to set aad with ctx is NULL. Expected result 3 is obtained.
* @expect
* 1.Success. Return CRYPT_SUCCESS.
* 2.Failed. Return CRYPT_NULL_INPUT.
* 3.Failed. Return CRYPT_NULL_INPUT.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_CTRL_API_TC001(void)
{
TestMemInit();
uint8_t key[32] = {0};
uint8_t iv[12] = {0};
uint8_t aad[20] = {0};
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key, sizeof(key), iv, sizeof(iv), true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, NULL, sizeof(aad)) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(NULL, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)) == CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_CTRL_API_TC002
* @title CRYPT_EAL_CipherCtrl get tag invalid parameter Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx.
* 2.Call the Init interface. All parameters are normal. Expected result 1 is obtained.
* 3.Call the Ctrl interface to set aad. Expected result 2 is obtained.
* 4.Call the Ctrl interface to get tag with ctx is NULL. Expected result 3 is obtained.
* 5.Call the Ctrl interface to get tag with data is NULL. Expected result 4 is obtained.
* 6.Call the Ctrl interface to get tag with dataLen is 15. Expected result 5 is obtained.
* 7.Call the Ctrl interface to get tag with dataLen is 17. Expected result 6 is obtained.
* @expect
* 1.Success. Return CRYPT_SUCCESS.
* 2.Success. Return CRYPT_SUCCESS.
* 3.Failed. Return CRYPT_NULL_INPUT.
* 4.Failed. Return CRYPT_NULL_INPUT.
* 5.Failed. Return CRYPT_MODES_TAGLEN_ERROR.
* 6.Failed. Return CRYPT_MODES_TAGLEN_ERROR.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_CTRL_API_TC002(void)
{
TestMemInit();
uint8_t key[32] = {0};
uint8_t iv[12] = {0};
uint8_t aad[20] = {0};
uint8_t out[16];
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key, sizeof(key), iv, sizeof(iv), true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(NULL, CRYPT_CTRL_GET_TAG, out, sizeof(out)) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, NULL, sizeof(out)) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key, sizeof(key), iv, sizeof(iv), true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, out, sizeof(out) - 1) == CRYPT_MODES_TAGLEN_ERROR);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key, sizeof(key), iv, sizeof(iv), true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, out, sizeof(out) + 1) == CRYPT_MODES_TAGLEN_ERROR);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_CTRL_API_TC003
* @title Invalid Algorithms to call Ctrl Interface Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx.
* 2.Call the Init interface. All parameters are normal. Expected result 1 is obtained.
* 3.Call the Ctrl interface to set iv. Expected result 2 is obtained.
* 4.Call the Ctrl interface to get iv. Expected result 3 is obtained.
* 5.Call the Ctrl interface to get blockSize. Expected result 4 is obtained.
* 6.Call the Ctrl interface to set tag len. Expected result 5 is obtained.
* 7.Call the Ctrl interface to set msg len. Expected result 6 is obtained.
* @expect
* 1.The init is successful and return CRYPT_SUCCESS.
* 2.Setting failed.
* 3.Getting failed.
* 4.Getting failed.
* 5.Setting failed. The algorithm is not supported.
* 6.Setting failed. The algorithm is not supported.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_CTRL_API_TC003(void)
{
TestMemInit();
uint8_t key[32] = {0};
uint8_t iv[12] = {0};
uint8_t buf[100] = {0};
uint8_t num = 0;
uint32_t num32 = 0;
uint64_t num64 = 0;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key, sizeof(key), iv, sizeof(iv), true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_IV, (uint8_t *)buf, 12) != CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_BLOCKSIZE, &num, sizeof(uint8_t)) != CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &num32, sizeof(uint32_t)) != CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &num64, sizeof(uint64_t)) != CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_CTRL_API_TC004
* @title Set aad but not initialized Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx.
* 2.Call the Ctrl interface to set iv. Expected result 1 is obtained.
* @expect
* 1.Failed. Return CRYPT_EAL_ERR_STATE.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_CTRL_API_TC004(void)
{
TestMemInit();
uint8_t aad[20] = {0};
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)), CRYPT_EAL_ERR_STATE);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_CTRL_API_TC005
* @title Set aad repeatedly Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx.
* 2.Call the Init interface. All parameters are normal. Expected result 1 is obtained.
* 3.Call the Ctrl interface to set aad. Expected result 2 is obtained.
* 4.Call the Ctrl interface to set aad. Expected result 3 is obtained.
* @expect
* 1.The init is successful and return CRYPT_SUCCESS.
* 2.Success. Return CRYPT_SUCCESS.
* 3.Failed. The Aad has been set.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_CTRL_API_TC005(void)
{
TestMemInit();
uint8_t key[32] = {0};
uint8_t iv[12] = {0};
uint8_t aad[20] = {0};
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key, sizeof(key), iv, sizeof(iv), true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)) != CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_CTRL_API_TC006
* @title Get tag but not initialized Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx.
* 2.Call the Ctrl interface to get tag. Expected result 1 is obtained.
* @expect
* 1.Failed. Has not been initialized.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_CTRL_API_TC006(void)
{
TestMemInit();
uint8_t tag[16] = {0};
const uint32_t tagLen = 16; // chacha-poly tag len is 16
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_NE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_FINAL_API_TC001
* @title Invalid Algorithms to call Final Interface Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx.
* 2.Call the Init interface. Expected result 1 is obtained.
* 3.Call the Ctrl interface to set aad. All parameters are normal. Expected result 2 is obtained.
* 4.Call the Update interface. All parameters are normal. Expected result 3 is obtained.
* 5.Call the Final interface. Expected result 4 is obtained.
* @expect
* 1.Success. Return CRYPT_SUCCESS.
* 2.Success. Return CRYPT_SUCCESS.
* 3.Success. Return CRYPT_SUCCESS.
* 4.Failed. The algorithm is not supported.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_FINAL_API_TC001(void)
{
TestMemInit();
uint8_t key[32] = {0};
uint8_t iv[12] = {0};
uint8_t aad[20] = {0};
uint8_t data[100] = {0};
uint32_t dataLen = sizeof(data);
uint8_t out[100];
uint32_t outLen = sizeof(out);
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key, sizeof(key), iv, sizeof(iv), true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data, dataLen, out, &outLen) == CRYPT_SUCCESS);
outLen = sizeof(out);
ASSERT_TRUE(CRYPT_EAL_CipherFinal(ctx, out, &outLen) != CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_SETPADDING_API_TC001
* @title Invalid Algorithms to call set padding Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx.
* 2.Call the Init interface. All parameters are normal. Expected result 1 is obtained.
* 3.Call the Ctrl interface to set aad. All parameters are normal. Expected result 2 is obtained.
* 4.Call the Getpadding interface. Expected result 3 is obtained.
* @expect
* 1.Success. Return CRYPT_SUCCESS.
* 2.Success. Return CRYPT_SUCCESS.
* 3.Failed. The algorithm is not supported.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_SETPADDING_API_TC001(void)
{
TestMemInit();
uint8_t key[32] = {0};
uint8_t iv[12] = {0};
uint8_t aad[20] = {0};
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key, sizeof(key), iv, sizeof(iv), true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherSetPadding(ctx, CRYPT_PADDING_ZEROS) != CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_GETPADDING_API_TC001
* @title Invalid Algorithms to call get padding Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx.
* 2.Call the Init interface. All parameters are normal. Expected result 1 is obtained.
* 3.Call the Ctrl interface to set aad. All parameters are normal. Expected result 2 is obtained.
* 4.Call the Setpadding interface. Expected result 3 is obtained.
* @expect
* 1.Success. Return CRYPT_SUCCESS.
* 2.Success. Return CRYPT_SUCCESS.
* 3.Failed. The algorithm is not supported.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_GETPADDING_API_TC001(void)
{
TestMemInit();
uint8_t key[32] = {0};
uint8_t iv[12] = {0};
uint8_t aad[20] = {0};
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key, sizeof(key), iv, sizeof(iv), true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad, sizeof(aad)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherGetPadding(ctx) == CRYPT_PADDING_MAX_COUNT);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC001
* @title Encryption and decryption Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface and set to encrypt. Expected result 2 is obtained.
* 3.Call the Ctrl interface to set aad. All parameters are normal. Expected result 3 is obtained.
* 4.Call the Update interface to encrypt data. Expected result 4 is obtained.
* 5.Call the Ctrl interface to obtain the tag and compare with test vector. Expected result 5 is obtained.
* 6.Call the deinit interface to deinitialize the ctx.
* 7.Call the Init interface and set to decrypt. Expected result 6 is obtained.
* 8.Call the Ctrl interface to set aad. All parameters are normal. Expected result 7 is obtained.
* 9.Call the Update interface to decrypt data. Expected result 8 is obtained.
* 10.Call the Ctrl interface to obtain the tag and compare with test vector. Expected result 9 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Succeeded in setting the AAD.
* 4.The encryption is successful and consistent with expected vector.
* 5.Tag is consistent with expected vector.
* 6.The init is successful and return CRYPT_SUCCESS.
* 7.Succeeded in setting the AAD.
* 8.The decryption is successful and consistent with origin plain data.
* 9.Tag is consistent with expected vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC001(Hex *key, Hex *iv, Hex *aad, Hex *data, Hex *cipher, Hex *tag)
{
TestMemInit();
uint8_t outTag[16];
uint8_t out[300];
uint32_t tagLen = tag->len;
uint32_t outLen = sizeof(out);
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data->x, data->len, out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
ASSERT_TRUE(outLen == cipher->len);
ASSERT_TRUE(memcmp(out, cipher->x, cipher->len) == 0);
ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);
CRYPT_EAL_CipherDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, false) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
outLen = sizeof(out);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, cipher->x, cipher->len, (uint8_t *)out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
ASSERT_TRUE(outLen == data->len);
ASSERT_TRUE(memcmp(out, data->x, data->len) == 0);
ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC002
* @title Multi segment encryption and decryption
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface and set to encrypt. Expected result 2 is obtained.
* 3.Call the Ctrl interface to set aad. All parameters are normal. Expected result 3 is obtained.
* 4.Call the Update interface to encrypt partial data. Expected result 4 is obtained.
* 5.Call the Update interface to encrypt remaining data. Expected result 5 is obtained.
* 6.Compare the ciphertext with the test vector. Expected result 6 is obtained.
* 7.Call the Ctrl interface to obtain the tag and compare with test vector. Expected result 7 is obtained.
* 8.Call the deinit interface to deinitialize the ctx.
* 9.Call the Init interface and set to decrypt. Expected result 8 is obtained.
* 10.Call the Ctrl interface to set aad. All parameters are normal. Expected result 9 is obtained.
* 11.Call the Update interface to decrypt partial data. Expected result 10 is obtained.
* 12.all the Update interface to decrypt remaining data. Expected result 11 is obtained.
* 13.Compare the plaintext with the test vector. Expected result 12 is obtained.
* 14.Call the Ctrl interface to obtain the tag and compare with test vector. Expected result 13 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Succeeded in setting the AAD.
* 4.The encryption is successful.
* 5.The encryption is successful.
* 6.Ciphertext is consistent with expected vector.
* 7.Tag is consistent with expected vector.
* 8.The init is successful and return CRYPT_SUCCESS.
* 9.Succeeded in setting the AAD.
* 10.The decryption is successful.
* 11.The decryption is successful.
* 12.Decryption result is consistent with origin plain data.
* 13.Tag is consistent with expected vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC002(Hex *key, Hex *iv, Hex *aad, Hex *data, Hex *cipher, Hex *tag)
{
TestMemInit();
uint8_t outTag[16];
uint8_t out[300];
uint32_t tagLen = tag->len;
uint32_t first = data->len / 2;
uint32_t outLen;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
outLen = first;
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data->x, first, (uint8_t *)out, &outLen) == CRYPT_SUCCESS);
outLen = data->len - first;
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data->x + first, data->len - first, out + first, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(out, cipher->x, cipher->len) == 0);
ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);
CRYPT_EAL_CipherDeinit(ctx);
outLen = first;
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, false) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, cipher->x, first, (uint8_t *)out, &outLen) == CRYPT_SUCCESS);
outLen = cipher->len - first;
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, cipher->x + first, cipher->len - first, out + first, &outLen) ==
CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(out, data->x, data->len) == 0);
ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC003
* @title Encryption and decryption with reinitialization Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the init interface to set to encrypt with the test vector key and non-vector IV. Expected result 2 is obtained.
* 3.Call the Ctrl interface to set non-vector AAD. Expected result 3 is obtained.
* 4.Call the Reinit interface with the test vector IV. Expected result 4 is obtained.
* 5.Call the Ctrl interface to set the test vector AAD. Expected result 5 is obtained.
* 6.Call the Update interface to encrypt data. Expected result 6 is obtained.
* 7.Compare the ciphertext with the test vector. Expected result 7 is obtained.
* 8.Call the Ctrl interface to obtain the tag and compare with test vector. Expected result 8 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Succeeded in setting the AAD.
* 4.The reinitialization is successful.
* 5.Succeeded in setting the AAD.
* 6.The encryption is successful.
* 7.Ciphertext is consistent with expected vector.
* 8.Tag is consistent with expected vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC003(Hex *key, Hex *iv, Hex *aad, Hex *data, Hex *cipher, Hex *tag)
{
TestMemInit();
uint8_t outTag[16];
uint8_t out[300];
uint8_t badIv[12] = {0};
uint8_t badAad[30] = {0};
uint32_t tagLen = tag->len;
uint32_t outLen = sizeof(out);
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, badIv, sizeof(badIv), true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, badAad, sizeof(badAad)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, iv->x, iv->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data->x, data->len, out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
ASSERT_TRUE(outLen == cipher->len);
ASSERT_TRUE(memcmp(out, cipher->x, cipher->len) == 0);
ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/*
* @test SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC004
* @title Repeated init Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the init interface to set to encrypt with the non-vector key and non-vector IV. Expected result 2 is obtained.
* 3.Call the Ctrl interface to set non-vector AAD. Expected result 3 is obtained.
* 4.Call the init interface to set to encrypt with the test vector key and IV. Expected result 4 is obtained.
* 5.Call the Ctrl interface to set the test vector AAD. Expected result 5 is obtained.
* 6.Call the Update interface to encrypt data. Expected result 6 is obtained.
* 7.Compare the ciphertext with the test vector. Expected result 7 is obtained.
* 8.Call the Ctrl interface to obtain the tag and compare with test vector. Expected result 8 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Succeeded in setting the AAD.
* 4.The init is successful.
* 5.Succeeded in setting the AAD.
* 6.The encryption is successful.
* 7.Ciphertext is consistent with expected vector.
* 8.Tag is consistent with expected vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC004(Hex *key, Hex *iv, Hex *aad, Hex *data, Hex *cipher, Hex *tag)
{
TestMemInit();
uint8_t outTag[16];
uint8_t out[300];
uint8_t badIv[12] = {0};
uint8_t badAad[30] = {0};
uint8_t badKey[32] = {0};
uint32_t tagLen = tag->len;
uint32_t outLen = sizeof(out);
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, badKey, sizeof(badKey), badIv, sizeof(badIv), true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, badAad, sizeof(badAad)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data->x, data->len, out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
ASSERT_TRUE(outLen == cipher->len);
ASSERT_TRUE(memcmp(out, cipher->x, cipher->len) == 0);
ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC005
* @title No message scenario Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the init interface to set to encrypt with the test vector key and IV. Expected result 2 is obtained.
* 3.Call the Ctrl interface to set AAD. Expected result 3 is obtained.
* 4.Call the Ctrl interface to obtain the tag and compare with test vector. Expected result 4 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Succeeded in setting the AAD.
* 4.Tag is consistent with expected vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC005(Hex *key, Hex *iv, Hex *aad, Hex *tag)
{
TestMemInit();
uint8_t outTag[16];
uint32_t tagLen = tag->len;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("tag equal", outTag, tagLen, tag->x, tag->len);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC006
* @title Obtaining tag repeatedly Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the init interface to set to encrypt. Expected result 2 is obtained.
* 3.Call the Ctrl interface to set AAD. Expected result 3 is obtained.
* 4.Call the Update interface to encrypt data. Expected result 4 is obtained.
* 5.Compare the ciphertext with the test vector. Expected result 5 is obtained.
* 6.Call the Ctrl interface to obtain the tag and compare with test vector. Expected result 6 is obtained.
* 7.Call the Ctrl interface again to obtain the tag and compare with test vector. Expected result 7 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Succeeded in setting the AAD.
* 4.The encryption is successful.
* 5.Ciphertext is consistent with expected vector.
* 6.Tag is consistent with expected vector.
* 7.Failed to obtain the tag for the second time.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC006(Hex *key, Hex *iv, Hex *aad, Hex *data, Hex *cipher, Hex *tag)
{
TestMemInit();
uint8_t outTag[16];
uint8_t out[300];
uint32_t tagLen = tag->len;
uint32_t outLen = sizeof(out);
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data->x, data->len, out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
ASSERT_TRUE(outLen == cipher->len);
ASSERT_TRUE(memcmp(out, cipher->x, cipher->len) == 0);
ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen), CRYPT_EAL_ERR_STATE);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC007
* @title Memory overlap in plaintext and ciphertext Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the init interface to set to encrypt. Expected result 2 is obtained.
* 3.Call the Ctrl interface to set AAD. Expected result 3 is obtained.
* 4.Call the Update interface to encrypt data. The plaintext and ciphertext memory completely overlap. Expected result 4 is obtained.
* 5.Compare the ciphertext with the test vector. Expected result 5 is obtained.
* 6.Call the Ctrl interface to obtain the tag and compare with test vector. Expected result 6 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Succeeded in setting the AAD.
* 4.The encryption is successful.
* 5.Ciphertext is consistent with expected vector.
* 6.Tag is consistent with expected vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC007(Hex *key, Hex *iv, Hex *aad, Hex *data, Hex *cipher, Hex *tag)
{
TestMemInit();
uint8_t outTag[16];
uint8_t buf[300];
uint32_t tagLen = tag->len;
uint32_t bufLen = sizeof(buf);
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(memcpy_s(buf, bufLen, data->x, data->len) == 0);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, buf, data->len, buf, &bufLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
ASSERT_TRUE(bufLen == cipher->len);
ASSERT_TRUE(memcmp(buf, cipher->x, cipher->len) == 0);
ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC008
* @title 64-bit IV encryption and decryption Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the init interface to set to encrypt. Expected result 2 is obtained.
* 3.Call the Ctrl interface to set AAD. Expected result 3 is obtained.
* 4.Call the Update interface to encrypt data. Expected result 4 is obtained.
* 5.Call the Ctrl interface to obtain the tag and compare with test vector. Expected result 5 is obtained.
* 6.Call the deinit interface to deinitialize the ctx.
* 7.Call the init interface to set to decrypt. Expected result 6 is obtained.
* 8.Call the Ctrl interface to set AAD. Expected result 7 is obtained.
* 9.Call the Update interface to decrypt data. Expected result 8 is obtained.
* 10.Compare the plaintext with the test vector. Expected result 9 is obtained.
* 11.Call the Ctrl interface to obtain the tag and compare with encryption tag. Expected result 10 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Succeeded in setting the AAD.
* 4.The encryption is successful.
* 5.The getting tag is successful.
* 6.The init is successful and return CRYPT_SUCCESS.
* 7.Succeeded in setting the AAD.
* 8.The decryption is successful.
* 9.Decryption result is consistent with origin plaintext.
* 10.Tag is consistent with expected value.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC008(Hex *key, Hex *aad, Hex *data)
{
TestMemInit();
uint8_t outTag1[16];
uint8_t outTag2[16];
uint8_t out[300];
const uint32_t tagLen = sizeof(outTag1);
uint32_t outLen = sizeof(out);
uint8_t iv[8];
(void)memset_s(iv, sizeof(iv), 'A', sizeof(iv));
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv, sizeof(iv), true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data->x, data->len, out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag1, tagLen) == CRYPT_SUCCESS);
CRYPT_EAL_CipherDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv, sizeof(iv), false) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, out, outLen, out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag2, tagLen) == CRYPT_SUCCESS);
ASSERT_TRUE(outLen == data->len);
ASSERT_TRUE(memcmp(out, data->x, data->len) == 0);
ASSERT_TRUE(memcmp(outTag1, outTag2, tagLen) == 0);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC009
* @title Invalid tag in the encryption and decryption Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the init interface to set to encrypt. Expected result 2 is obtained.
* 3.Call the Ctrl interface to set AAD. Expected result 3 is obtained.
* 4.Call the Update interface to encrypt data. Expected result 4 is obtained.
* 5.Compare the ciphertext with the test vector. Expected result 5 is obtained.
* 6.Call the Ctrl interface to obtain the tag and compare with test vector. Expected result 6 is obtained.
* 7.Call the deinit interface to deinitialize the ctx.
* 8.Call the init interface to set to decrypt. Expected result 7 is obtained.
* 9.Call the Ctrl interface to set AAD. Expected result 8 is obtained.
* 10.Call the Update interface to decrypt data. Expected result 9 is obtained.
* 11.Compare the plaintext with the test vector. Expected result 10 is obtained.
* 12.Call the Ctrl interface to obtain the tag and compare with test vector. Expected result 11 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Succeeded in setting the AAD.
* 4.The encryption is successful.
* 5.Ciphertext is consistent with expected vector.
* 6.Tag is not consistent with expected vector.
* 7.The init is successful and return CRYPT_SUCCESS.
* 8.Succeeded in setting the AAD.
* 9.The decryption is successful.
* 10.Decryption result is consistent with origin plain data.
* 11.Tag is not consistent with expected vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC009(Hex *key, Hex *iv, Hex *aad, Hex *data, Hex *cipher, Hex *tag)
{
TestMemInit();
uint8_t outTag[16];
uint8_t out[300];
uint32_t tagLen = tag->len;
uint32_t outLen = sizeof(out);
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data->x, data->len, out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
ASSERT_TRUE(outLen == cipher->len);
ASSERT_TRUE(memcmp(out, cipher->x, cipher->len) == 0);
ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) != 0);
CRYPT_EAL_CipherDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, false) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
outLen = sizeof(out);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, cipher->x, cipher->len, (uint8_t *)out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
ASSERT_TRUE(outLen == data->len);
ASSERT_TRUE(memcmp(out, data->x, data->len) == 0);
ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) != 0);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC002
* @title Encryption and decryption of multiple segments with different lengths Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the init interface to set to encrypt. Expected result 2 is obtained.
* 3.Call the Ctrl interface to set AAD. Expected result 3 is obtained.
* 4.Call the Update interface to encrypt data 1. Expected result 4 is obtained.
* 5.Call the Update interface to encrypt data 2. Expected result 5 is obtained.
* 6.Call the Update interface to encrypt data 3. Expected result 6 is obtained.
* 7.Compare the ciphertext with the test vector. Expected result 7 is obtained.
* 8.Call the Ctrl interface to obtain the tag and compare with test vector. Expected result 8 is obtained.
* 9.Call the deinit interface to deinitialize the ctx.
* 10.Call the init interface to set to decrypt. Expected result 9 is obtained.
* 11.Call the Ctrl interface to set AAD. Expected result 10 is obtained.
* 12.Call the Update interface to decrypt data 1. Expected result 11 is obtained.
* 13.Call the Update interface to decrypt data 2. Expected result 12 is obtained.
* 14.Call the Update interface to decrypt data 3. Expected result 13 is obtained.
* 15.Compare the plaintext with the test vector. Expected result 14 is obtained.
* 16.Call the Ctrl interface to obtain the tag and compare with test vector tag. Expected result 15 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Succeeded in setting the AAD.
* 4.The encryption is successful.
* 5.The encryption is successful.
* 6.The encryption is successful.
* 7.Ciphertext is consistent with expected vector.
* 8.Tag is consistent with expected value.
* 9.The init is successful and return CRYPT_SUCCESS.
* 10.Succeeded in setting the AAD.
* 11.The decryption is successful.
* 12.The decryption is successful.
* 13.The decryption is successful.
* 14.Decryption result is consistent with origin plaintext.
* 15.Tag is consistent with expected value.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CHACHA20POLY1305_UPDATE_FUNC_TC010(Hex *key, Hex *iv, Hex *aad, Hex *pt1, Hex *pt2, Hex *pt3, Hex *cipher, Hex *tag)
{
TestMemInit();
uint8_t outTag[16];
uint8_t out[300];
uint32_t tagLen = tag->len;
uint32_t outLen;
uint32_t totalLen = 0;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_CHACHA20_POLY1305);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
outLen = sizeof(out);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, pt1->x, pt1->len, (uint8_t *)out, &outLen) == CRYPT_SUCCESS);
totalLen += outLen;
outLen = sizeof(out) - pt1->len;
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, pt2->x, pt2->len, out + totalLen, &outLen) == CRYPT_SUCCESS);
totalLen += outLen;
outLen = sizeof(out) - pt1->len - pt2->len;
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, pt3->x, pt3->len, out + totalLen, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(out, cipher->x, cipher->len) == 0);
ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);
CRYPT_EAL_CipherDeinit(ctx);
outLen = sizeof(out);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, false) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, cipher->x, pt1->len, (uint8_t *)out, &outLen) == CRYPT_SUCCESS);
outLen = cipher->len - pt1->len;
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, cipher->x + pt1->len, pt2->len, out + pt1->len, &outLen) ==
CRYPT_SUCCESS);
outLen = cipher->len - pt1->len - pt2->len;
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, cipher->x + pt1->len + pt2->len, pt3->len, out + pt1->len + pt2->len, &outLen) ==
CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(out, pt1->x, pt1->len) == 0);
ASSERT_TRUE(memcmp(out + pt1->len, pt2->x, pt2->len) == 0);
ASSERT_TRUE(memcmp(out + pt1->len + pt2->len, pt3->x, pt3->len) == 0);
ASSERT_TRUE(memcmp(outTag, tag->x, tag->len) == 0);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/chacha-poly/test_suite_sdv_eal_chachapoly.c | C | unknown | 53,845 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
// #include <limits.h>
#include <pthread.h>
#include "securec.h"
#include "crypt_eal_mac.h"
#include "crypt_errno.h"
#include "bsl_sal.h"
#define AES128_KEY_LEN 16
#define AES192_KEY_LEN 24
#define AES256_KEY_LEN 32
#define SM4_KEY_LEN 16
#define CMAC_MAC_AES_LEN 16
#define CMAC_MAC_LEN 16
uint32_t GetKeyLen(int algId)
{
switch (algId) {
case CRYPT_MAC_CMAC_AES128:
return AES128_KEY_LEN;
case CRYPT_MAC_CMAC_AES192:
return AES192_KEY_LEN;
case CRYPT_MAC_CMAC_AES256:
return AES256_KEY_LEN;
case CRYPT_MAC_CMAC_SM4:
return SM4_KEY_LEN;
default:
return 0;
}
}
/* END_HEADER */
/* @
* @test SDV_CRYPT_EAL_CMAC_API_TC001
* @spec -
* @title valid algorithm ID and invalid algorithm ID
* @precon nan
* @brief 1.Invoke the new interface with the input parameter CRYPT_MAC_CMAC_AES128. Expected result 1 is obtained.
2.Invoke the new interface with the input parameter CRYPT_MAC_CMAC_AES192,Expected result 2 is obtained.
3.Invoke the new interface with the input parameter CRYPT_MAC_CMAC_AES256,Expected result 3 is obtained.
4.Invoke the new interface with the input parameter CRYPT_MAC_MAX, Expected result 4 is obtained.
* @expect 1.sucess
2.sucess
3.sucess
4.failed，return NULL
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CMAC_API_TC001(void)
{
TestMemInit();
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(CRYPT_MAC_CMAC_AES128);
ASSERT_TRUE(ctx != NULL);
CRYPT_EAL_MacFreeCtx(ctx);
ctx = CRYPT_EAL_MacNewCtx(CRYPT_MAC_CMAC_AES192);
ASSERT_TRUE(ctx != NULL);
CRYPT_EAL_MacFreeCtx(ctx);
ctx = CRYPT_EAL_MacNewCtx(CRYPT_MAC_CMAC_AES256);
ASSERT_TRUE(ctx != NULL);
CRYPT_EAL_MacFreeCtx(ctx);
ctx = CRYPT_EAL_MacNewCtx(CRYPT_MAC_CMAC_SM4);
ASSERT_TRUE(ctx != NULL);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CMAC_API_TC002
* @spec -
* @title init interface: valid input parameter, invalid input parameter
* @precon nan
* @brief 1.Invoke the new interface. Expected result 1 is obtained.
2.Invoke the init interface and set ctx to NULL. Expected result 2 is obtained.
3.Invoke the init interface and set key to NULL. Expected result 3 is obtained.
4.Invoke the init interface. Set the key to a value other than NULL and len to a value less than the specified key
length. Expected result 4 is obtained.
5.Invoke the init interface and ensure that the input parameters are normal. Expected result 5 is obtained.
6.Invoke the init interface. The key is not NULL and len is greater than the specified key length.
Expected result 6 is obtained.
* @expect 1.new sucess，return CRYPT_EAL_MacCtx pointer
2.init failed, return CRYPT_NULL_INPUT
3.init failed, return CRYPT_NULL_INPUT
4.init failed, return CRYPT_AES_ERR_KEYLEN
5.init sucess, return CRYPT_SUCCESS
6.init failed, return CRYPT_AES_ERR_KEYLEN
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CMAC_API_TC002(int algId)
{
if (IsCmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
const uint32_t len = GetKeyLen(algId);
uint8_t key[len];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
int32_t ret;
if (algId >= CRYPT_MAC_CMAC_AES128 && algId <= CRYPT_MAC_CMAC_AES256) {
ret = CRYPT_AES_ERR_KEYLEN;
} else if (algId == CRYPT_MAC_CMAC_SM4) {
ret = CRYPT_SM4_ERR_KEY_LEN;
}
ASSERT_TRUE(CRYPT_EAL_MacInit(NULL, key, len) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, NULL, len) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len - 1) == ret);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len + 1) == ret);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CMAC_API_TC003
* @spec -
* @title test ctx status
* @precon nan
* @brief 1.Invoke the new interface. Expected result 1 is obtained.
2.Invoke the init interface. Expected result 2 is obtained.
3.Invoke the init interface repeatedly. Expected result 3 is obtained.
4.Invoke the update interface. Expected result 4 is obtained.
5.Invoke the init interface. Expected result 5 is obtained.
6.Invoke the final interface. Expected result 6 is obtained.
7.Invoke the init interface. Expected result 7 is obtained.
8.Invoke the deinit interface. Expected result 8 is obtained.
9.Invoke the init interface. Expected result 9 is obtained.
10.Invoke the reinit interface. Expected result 10 is obtained.
11.Invoke the init interface. Expected result 11 is obtained.
* @expect 1.new sucess, return CRYPT_EAL_MacCtx pointer
2.init sucess, return CRYPT_SUCCESS
3.init sucess, return CRYPT_SUCCESS
4.update sucess, return CRYPT_SUCCESS
5.init sucess, return CRYPT_SUCCESS
6.final sucess, return CRYPT_SUCCESS
7.init sucess, return CRYPT_SUCCESS
8.deinit sucess
9.init sucess, return CRYPT_SUCCESS
10.reinit sucess, return CRYPT_SUCCESS
11.init sucess, return CRYPT_SUCCESS
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CMAC_API_TC003(int algId)
{
if (IsCmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
const uint32_t keyLen = GetKeyLen(algId);
uint8_t key[keyLen];
uint32_t macLen = TestGetMacLen(algId);
uint8_t mac[macLen];
const uint32_t dataLen = TestGetMacLen(algId);
uint8_t data[dataLen];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, keyLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, keyLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, keyLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, keyLen) == CRYPT_SUCCESS);
CRYPT_EAL_MacDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, keyLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, keyLen) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CMAC_API_TC004
* @spec -
* @title update: valid input parameter, invalid input parameter
* @precon nan
* @brief 1.Invoke the new interface. Expected result 1 is obtained.
2.Invoke the init interface. Expected result 2 is obtained.
3.Invoke the update interface and set ctx to NULL. Expected result 3 is obtained.
4.Invoke the update interface. Set in to NULL and len to a value other than 0. Expected result 4 is obtained.
5.Invoke the update interface. Set in to a value other than NULL and len to 0. Expected result 5 is obtained.
6.Invoke the update interface. Set in to NULL and len to 0. Expected result 6 is obtained.
7.Invoke the update interface and ensure that the input parameters are normal. Expected result 7 is obtained.
* @expect 1.new sucess，return CRYPT_EAL_MacCtx pointer
2.init sucess，return CRYPT_SUCCESS
3.update failed，return CRYPT_NULL_INPUT
4.update failed，return CRYPT_NULL_INPUT
5.update sucess，return CRYPT_SUCCESS
6.update sucess，return CRYPT_SUCCESS
7.update sucess，return CRYPT_SUCCESS
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CMAC_API_TC004(int algId)
{
if (IsCmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
const uint32_t len = GetKeyLen(algId);
uint8_t key[len];
const uint32_t dataLen = GetKeyLen(algId);
uint8_t data[dataLen];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(NULL, data, dataLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, NULL, dataLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CMAC_API_TC005
* @spec -
* @precon nan
* @brief 1.Invoke the new interface. Expected result 1 is obtained.
2.Invoke the update interface. Expected result 2 is obtained.
3.Invoke the new interface. Expected result 3 is obtained.
4.Invoke the update interface. Expected result 4 is obtained.
5.Invoke the final interface. Expected result 5 is obtained.
6.Invoke the new interface. Expected result 6 is obtained.
7.Invoke the new interface. Expected result 7 is obtained.
8.Invoke the deinit interface. Expected result 8 is obtained.
9.Invoke the new interface. Expected result 9 is obtained.
10.Invoke the final interface. Expected result 10 is obtained.
11.Invoke the new interface. Expected result 11 is obtained.
12.Invoke the new interface. Expected result 12 is obtained.
13.Invoke the reinit interface. Expected result 13 is obtained.
14.Invoke the new interface. Expected result 14 is obtained.
15.repeat invoke the new interface. Expected result 15 is obtained.
* @expect 1.new sucess，return CRYPT_EAL_MacCtx pointer
2.update failed，return RYPT_EAL_ERR_STATE
3.init sucess，return CRYPT_SUCCESS
4.update sucess，return CRYPT_SUCCESS
5.final sucess，return CRYPT_SUCCESS
6.update failed，return CRYPT_EAL_ERR_STATE
7.update failed，return CRYPT_EAL_ERR_STATE
8.
9.update failed，return CRYPT_EAL_ERR_STATE
10.final sucess，return CRYPT_EAL_ERR_STATE
11.init sucess，return CRYPT_SUCCESS
12.update sucess，return CRYPT_SUCCESS
13.reinit sucess，return CRYPT_SUCCESS
14.update sucess，return CRYPT_SUCCESS
15.update sucess，return CRYPT_SUCCESS
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CMAC_API_TC005(int algId)
{
if (IsCmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
const uint32_t len = GetKeyLen(algId);
uint8_t key[len];
uint32_t macLen = TestGetMacLen(algId);
uint8_t mac[macLen];
const uint32_t dataLen = GetKeyLen(algId);
uint8_t data[dataLen];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_EAL_ERR_STATE);
CRYPT_EAL_MacDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CMAC_API_TC006
* @spec -
* @title finsl : valid input parameter, invalid input parameter
* @precon nan
* @brief 1.调用new接口,有预期结果1
2.调用init接口,有预期结果2
3.调用final接口，ctx为NULL,有预期结果3
4.调用final接口，out为NULL,有预期结果4
5.调用final接口，len为NULL,有预期结果5
6.调用final接口，len数值小于mac数据长度,有预期结果6
7.调用final接口，len数值大于mac数据长度,有预期结果7
8.调用init接口,有预期结果8
9.调用final接口，正常入参,有预期结果9
* @expect 1.new sucess，return CRYPT_EAL_MacCtx pointer
2.init sucess，return CRYPT_SUCCESS
3.final failed，return CRYPT_NULL_INPUT
4.final failed，return CRYPT_NULL_INPUT
5.final failed，return CRYPT_NULL_INPUT
6.final failed，return CRYPT_CMAC_OUT_BUFF_LEN_NOT_ENOUGH
7.final sucess，return CRYPT_SUCCESS
8.init sucess，return CRYPT_SUCCESS
9.final sucess，return CRYPT_SUCCESS
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CMAC_API_TC006(int algId)
{
if (IsCmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
const uint32_t len = GetKeyLen(algId);
uint8_t key[len];
uint32_t macLen = TestGetMacLen(algId);
uint8_t mac[macLen];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(NULL, mac, &macLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, NULL, &macLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, NULL) == CRYPT_NULL_INPUT);
macLen = TestGetMacLen(algId) - 1;
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_CMAC_OUT_BUFF_LEN_NOT_ENOUGH);
macLen = TestGetMacLen(algId) + 1;
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CMAC_API_TC007
* @spec -
* @title test final
* @precon nan
* @brief 1.Invoke the new interface. Expected result 1 is obtained.
2.Invoke the final interface. Expected result 2 is obtained.
3.Invoke the final interface. Expected result 3 is obtained.
4.Invoke the update interface. Expected result 4 is obtained.
5.Invoke the init interface. Expected result 5 is obtained.
6.Invoke the final interface. Expected result 6 is obtained.
7.Invoke the init interface. Expected result 7 is obtained.
8.Invoke the update interface. Expected result 8 is obtained.
9.Invoke the final interface. Expected result 9 is obtained.
10.Invoke the reinit interface. Expected result 10 is obtained.
11.Invoke the final interface. Expected result 11 is obtained.
12.Invoke the init interface. Expected result 12 is obtained.
13.Invoke the reinit interface. Expected result 13 is obtained.
14.Invoke the final interface. Expected result 14 is obtained.
15.repeat invoke the final interface. Expected result 15 is obtained.
* @expect 1.new sucess，return CRYPT_EAL_MacCtx pointer
2.final failed，return RYPT_EAL_ERR_STATE
3.final failed，return RYPT_EAL_ERR_STATE
4.update failed，return YPT_EAL_ERR_STATE
5.init sucess，return CRYPT_SUCCESS
6.final sucess，return CRYPT_SUCCESS
7.init sucess，return CRYPT_SUCCESS
8.update sucess，return CRYPT_SUCCESS
9.final sucess，return CRYPT_SUCCESS
10.
11.final failed，return CRYPT_EAL_ERR_STATE
12.init sucess，return CRYPT_SUCCESS
13.reinit sucess，return CRYPT_SUCCESS
14.final sucess，return CRYPT_SUCCESS
15.final failed，return RYPT_EAL_ERR_STATE
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CMAC_API_TC007(int algId, Hex *key1, Hex *mac1, Hex *key2, Hex *data2, Hex *mac2, Hex *mac3)
{
if (IsCmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
uint32_t macLen = TestGetMacLen(algId);
uint8_t mac[macLen];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data2->x, data2->len) == CRYPT_EAL_ERR_STATE);
// mac1
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key1->x, key1->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("mac1 result cmp", mac, macLen, mac1->x, mac1->len);
// mac2
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key2->x, key2->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data2->x, data2->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("mac2 result cmp", mac, macLen, mac2->x, mac2->len);
CRYPT_EAL_MacDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_EAL_ERR_STATE);
// mac3
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key2->x, key2->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("mac3 result cmp", mac, macLen, mac3->x, mac3->len);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_EAL_ERR_STATE);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CMAC_API_TC008
* @spec -
* @title getMacLen: valid input parameter, invalid input parameter
* @precon nan
* @brief 1. Invoke the new interface. Expected result 1 is obtained.
2. Invoke the init interface. Expected result 2 is obtained.
3. Invoke the getLen interface and set the input parameter to NULL. Expected result 3 is obtained.
4. Invoke the getLen interface and set normal input parameters. Expected result 4 is obtained.
* @expect 1.new sucess，return CRYPT_EAL_MacCtx pointer
2.init sucess，return CRYPT_SUCCESS
3. failed，return 0
4. sucess，return mac length
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CMAC_API_TC008(int algId)
{
if (IsCmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
const uint32_t len = GetKeyLen(algId);
uint8_t key[len];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(NULL) == 0);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == TestGetMacLen(algId));
uint32_t result = 0;
ASSERT_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_GET_MACLEN, &result, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(result == TestGetMacLen(algId));
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CMAC_API_TC009
* @spec -
* @precon nan
* @brief 1. Invoke the new interface. Expected result 1 is obtained.
2. Invoke the getLen interface. Expected result 2 is obtained.
3. Invoke the init interface. Expected result 3 is obtained.
4. Invoke the getLen interface. Expected result 4 is obtained.
5. Invoke the update interface. Expected result 5 is obtained.
6. Invoke the getLen interface. Expected result 6 is obtained.
7. Invoke the final interface. Expected result 7 is obtained.
8. Invoke the getLen interface. Expected result 8 is obtained.
9. Invoke the deinit interface. Expected result 9 is obtained.
10. Invoke the getLen interface. Expected result 10 is obtained.
11. Invoke the deinit interface. Expected result 11 is obtained.
12. Invoke the getLen interface. Expected result 12 is obtained.
* @expect 1.new sucess，return CRYPT_EAL_MacCtx pointer
2. sucess，return mac length
3.init sucess，return CRYPT_SUCCESS
4. sucess，return mac length
5.update sucess，return CRYPT_SUCCESS
6. sucess，return mac length
7.final sucess，return CRYPT_SUCCESS
8. sucess，return mac length
9.
10. sucess，return mac length
11.deinit sucess，return CRYPT_SUCCESS
12. sucess，return mac length
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CMAC_API_TC009(int algId)
{
if (IsCmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
const uint32_t len = GetKeyLen(algId);
uint8_t key[len];
uint32_t macLen = TestGetMacLen(algId);
uint8_t mac[macLen];
const uint32_t dataLen = TestGetMacLen(algId);
uint8_t data[dataLen];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == TestGetMacLen(algId));
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == TestGetMacLen(algId));
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == TestGetMacLen(algId));
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == TestGetMacLen(algId));
CRYPT_EAL_MacDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == TestGetMacLen(algId));
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == TestGetMacLen(algId));
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CMAC_API_TC010
* @spec -
* @title deinit interface test
* @precon nan
* @brief 1. Invoke the new interface. Expected result 1 is obtained.
2. Invoke the init interface. Expected result 2 is obtained.
3. Invoke the deinit interface. Expected result 3 is obtained.
4. Invoke the deinit interface repeatedly. Expected result 4 is obtained.
5. Invoke the init interface. Expected result 5 is obtained.
* @expect 1.new sucess，return CRYPT_EAL_MacCtx pointer
2.init sucess，return CRYPT_SUCCESS3.
4.
5.init sucess，return CRYPT_SUCCESS
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CMAC_API_TC010(int algId)
{
if (IsCmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
const uint32_t len = GetKeyLen(algId);
uint8_t key[len];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
CRYPT_EAL_MacDeinit(ctx);
CRYPT_EAL_MacDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
CRYPT_EAL_MacDeinit(NULL);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CMAC_API_TC011
* @spec -
* @title reinit test
* @precon nan
* @brief 1. Invoke the new interface. Expected result 1 is obtained.
2. Invoke the init interface. Expected result 2 is obtained.
3. Invoke the reinit interface. The value of ctx is NULL. Expected result 3 is obtained.
4. Invoke the reinit interface. The value of ctx is not NUL. Expected result 4 is obtained.
* @expect 1.new sucess，return CRYPT_EAL_MacCtx pointer
2.init sucess，return CRYPT_SUCCESS
3.init failed，return CRYPT_NULL_INPUT
4.reinit sucess，return CRYPT_SUCCESS
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CMAC_API_TC011(int algId)
{
if (IsCmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
const uint32_t len = GetKeyLen(algId);
uint8_t key[len];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(NULL) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CMAC_API_TC012
* @spec -
* @precon nan
* @brief 1. Invoke the new interface. Expected result 1 is obtained.
2. Invoke the reinit interface. Expected result 2 is obtained.
3. Invoke the reinit interface repeatedly. Expected result 3 is obtained.
4. Invoke the init interface. Expected result 4 is obtained.
5. Invoke the reinit interface. Expected result 5 is obtained.
6. Invoke the reinit interface repeatedly. Expected result 6 is obtained.
7. Invoke the update interface. Expected result 7 is obtained.
8. Invoke the reinit interface. Expected result 8 is obtained.
9. Invoke the final interface. Expected result 9 is obtained.
10. Invoke the reinit interface. Expected result 10 is obtained.
11. Invoke the deinit interface. Expected result 11 is obtained.
12. Invoke the reinit interface. Expected result 12 is obtained.
* @expect 1.new sucess，return CRYPT_EAL_MacCtx pointer
2.reinit failed，return CRYPT_NULL_INPUT
3.reinit failed，return CRYPT_NULL_INPUT
4.init sucess，return CRYPT_SUCCESS
5.reinit sucess，return CRYPT_SUCCESS
6.reinit sucess，return CRYPT_SUCCESS
7.update sucess，return CRYPT_SUCCESS
8.reinit sucess，return CRYPT_SUCCESS
9.final sucess，return CRYPT_SUCCESS
10.reinit sucess，return CRYPT_SUCCESS
11.
12.reinit failed，return CRYPT_EAL_ERR_STATE
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CMAC_API_TC012(int algId)
{
if (IsCmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
const uint32_t len = GetKeyLen(algId);
uint8_t key[len];
uint32_t macLen = TestGetMacLen(algId);
uint8_t mac[macLen];
const uint32_t dataLen = GetKeyLen(algId);
uint8_t data[dataLen];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
CRYPT_EAL_MacDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_EAL_ERR_STATE);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_CMAC_FUN_TC004
* @spec -
* @title All 0s and all Fs data key
* @precon nan
* @brief 1.Invoke the new interface. Expected result 1 is obtained.
2. Invoke the init interface. Expected result 2 is obtained.
3. Invoke the update interface. Expected result 3 is obtained.
4. Invoke the final interface. Expected result 4 is obtained.
* @expect 1.new sucess，return CRYPT_EAL_MacCtx pointer
2.init sucess，return CRYPT_SUCCESS
3.update sucess，return CRYPT_SUCCESS
4.final sucess，return CRYPT_SUCCESS
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CMAC_FUN_TC004(int algId, Hex *key, Hex *data, Hex *vecMac)
{
if (IsCmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
uint32_t macLen = TestGetMacLen(algId);
uint8_t mac[macLen];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key->x, key->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data->x, data->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("mac1 result cmp", mac, macLen, vecMac->x, vecMac->len);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
static int32_t UpdateMultiTime(CRYPT_EAL_MacCtx *ctx, Hex *data, int updateTimes, uint8_t *mac, uint32_t *macLen)
{
int32_t ret = CRYPT_SUCCESS;
for (int i = 0; i < updateTimes; i++) {
ret = CRYPT_EAL_MacUpdate(ctx, data->x, data->len);
if (ret != CRYPT_SUCCESS) {
return ret;
}
}
return CRYPT_EAL_MacFinal(ctx, mac, macLen);
}
/* @
* @test SDV_CRYPT_EAL_CMAC_FUN_TC006
* @spec -
* @title Compare the CMACC result with that of the CMACC result after multiple updates and one update.
* @precon nan
* @brief Run the updateTimes command to compare the cmac result with the update command.
* The expected results are the same.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CMAC_FUN_TC006(int algId, Hex *key, Hex *data, int updateTimes)
{
if (IsCmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
uint32_t macLen1 = CMAC_MAC_LEN;
uint8_t mac1[CMAC_MAC_LEN] = {};
uint32_t macLen2 = CMAC_MAC_LEN;
uint8_t mac2[CMAC_MAC_LEN] = {};
uint8_t *totalInData = NULL;
uint32_t totalLen = 0;
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key->x, key->len) == CRYPT_SUCCESS);
ASSERT_TRUE(UpdateMultiTime(ctx, data, updateTimes, mac1, &macLen1) == CRYPT_SUCCESS);
CRYPT_EAL_MacDeinit(ctx);
totalInData = BSL_SAL_Calloc(data->len * updateTimes, 1);
ASSERT_TRUE(totalInData != NULL);
for (int i = 0; i < updateTimes; i++) {
memcpy(totalInData + totalLen, data->x, data->len);
totalLen += data->len;
}
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key->x, key->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, totalInData, totalLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac2, &macLen2) == CRYPT_SUCCESS);
ASSERT_TRUE(macLen1 == macLen2);
ASSERT_COMPARE("mac1 vs mac2 result cmp", mac2, macLen2, mac1, macLen1);
EXIT:
BSL_SAL_FREE(totalInData);
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_CMAC_SAMEADDR_FUNC_TC001
* @title CMAC in/out same addr
* @precon nan
* @brief
* 1.Use the EAL layer interface to perform CMAC calculation. All input and output addresses are the same.
* Expected result 1 is displayed.
* @expect
* 1.compute sucess
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CMAC_SAMEADDR_FUNC_TC001(int algId, Hex *key, Hex *data, Hex *mac)
{
TestMacSameAddr(algId, key, data, mac);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_CMAC_ADDR_NOT_ALIGN_FUNC_TC001
* @title CMAC non-address alignment test
* @precon nan
* @brief
* 1.Use the EAL layer interface to perform CMAC calculation. All buffer addresses are not aligned.
* Expected result 1 is obtained.
* @expect
* 1.compute sucess
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_CMAC_ADDR_NOT_ALIGN_FUNC_TC001(int algId, Hex *key, Hex *data, Hex *mac)
{
TestMacAddrNotAlign(algId, key, data, mac);
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/cmac/test_suite_sdv_eal_mac_cmac.c | C | unknown | 31,290 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
#include "crypt_bn.h"
#include "bsl_sal.h"
#include "crypt_algid.h"
#include "crypt_types.h"
#include "crypt_eal_pkey.h"
#include "crypt_errno.h"
#include "crypt_curve25519.h"
#include "eal_pkey_local.h"
#include "crypt_eal_rand.h"
#include "securec.h"
#include "curve25519_local.h"
#include "crypt_curve25519.h"
#define CRYPT_EAL_PKEY_KEYMGMT_OPERATE 0
#define CRYPT_EAL_PKEY_CIPHER_OPERATE 1
#define CRYPT_EAL_PKEY_EXCH_OPERATE 2
#define CRYPT_EAL_PKEY_SIGN_OPERATE 4
void *malloc_fail(uint32_t size)
{
(void)size;
return NULL;
}
static void Set_Curve25519_Prv(CRYPT_EAL_PkeyPrv *prv, int id, uint8_t *key, uint32_t keyLen)
{
prv->id = id;
prv->key.curve25519Prv.data = key;
prv->key.curve25519Prv.len = keyLen;
}
static void Set_Curve25519_Pub(CRYPT_EAL_PkeyPub *pub, int id, uint8_t *key, uint32_t keyLen)
{
pub->id = id;
pub->key.curve25519Pub.data = key;
pub->key.curve25519Pub.len = keyLen;
}
/* END_HEADER */
/**
* @test SDV_CRYPTO_CURVE25519_SET_PARA_API_TC001
* @title CURVE25519: CRYPT_EAL_PkeySetPara test.
* @precon nan
* @brief
* 1. Create the context of the curve25519 algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeySetPara method, where parameter para.id is CRYPT_PKEY_*25519, expected result 2.
* 3. Call the CRYPT_EAL_PkeySetPara method, where parameter para.id is not CRYPT_PKEY_*25519, expected result 3.
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_EAL_ALG_NOT_SUPPORT
* 3. CRYPT_EAL_ERR_ALGID
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CURVE25519_SET_PARA_API_TC001(int id, int isProvider)
{
TestMemInit();
CRYPT_EAL_PkeyPara para;
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, id, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
para.id = id;
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_EAL_ALG_NOT_SUPPORT);
para.id = CRYPT_PKEY_DSA;
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_EAL_ERR_ALGID);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CURVE25519_SET_PRV_API_TC001
* @title CURVE25519: CRYPT_EAL_PkeySetPrv test.
* @precon Create a valid private key prv.
* @brief
* 1. Create the context of the curve25519 algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeySetPrv method:
* (1). pkey = NULL, expected result 2.
* (2). prv = NULL, expected result 2.
* (3). prv.data = NULL, expected result 2.
* (4). prv.len = 0, expected result 2.
* (5). prv.id != pkey.id, expected result 3.
* (6). prv.len = 33|31, expected result 4.
* (7). All parameters are valid, expected result 5.
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_NULL_INPUT
* 3. CRYPT_EAL_ERR_ALGID
* 4. CRYPT_CURVE25519_KEYLEN_ERROR
* 5. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CURVE25519_SET_PRV_API_TC001(int id, int isProvider)
{
uint8_t key[CRYPT_CURVE25519_KEYLEN] = {0};
CRYPT_EAL_PkeyPrv prv = {0};
Set_Curve25519_Prv(&prv, id, key, CRYPT_CURVE25519_KEYLEN);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, id, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(NULL, &prv), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, NULL), CRYPT_NULL_INPUT);
prv.key.curve25519Prv.data = NULL;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_NULL_INPUT);
prv.key.curve25519Prv.data = key;
prv.key.curve25519Prv.len = 0;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(NULL, &prv), CRYPT_NULL_INPUT);
prv.id = CRYPT_PKEY_DSA;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_EAL_ERR_ALGID);
prv.id = id;
prv.key.curve25519Prv.len = CRYPT_CURVE25519_KEYLEN - 1;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_CURVE25519_KEYLEN_ERROR);
prv.key.curve25519Prv.len = CRYPT_CURVE25519_KEYLEN + 1;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_CURVE25519_KEYLEN_ERROR);
prv.key.curve25519Prv.len = CRYPT_CURVE25519_KEYLEN;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CURVE25519_SET_PUB_API_TC001
* @title CURVE25519: CRYPT_EAL_PkeySetPub test.
* @precon Create a valid public key pub.
* @brief
* 1. Create the context of the curve25519 algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeySetPub method:
* (1). pkey = NULL, expected result 2.
* (2). pub = NULL, expected result 2.
* (3). pub.data = NULL, expected result 2.
* (4). pub.len = 0, expected result 2.
* (5). pub.id != pkey.id, expected result 3.
* (6). pub.len = 33|31, expected result 4.
* (7). All parameters are valid, expected result 5.
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_NULL_INPUT
* 3. CRYPT_EAL_ERR_ALGID
* 4. CRYPT_CURVE25519_KEYLEN_ERROR
* 5. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CURVE25519_SET_PUB_API_TC001(int id)
{
uint8_t key[CRYPT_CURVE25519_KEYLEN] = {0};
CRYPT_EAL_PkeyPub pub = {0};
Set_Curve25519_Pub(&pub, id, key, CRYPT_CURVE25519_KEYLEN);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = CRYPT_EAL_PkeyNewCtx(id);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(NULL, &pub), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, NULL), CRYPT_NULL_INPUT);
pub.key.curve25519Pub.data = NULL;
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_NULL_INPUT);
pub.key.curve25519Pub.data = key;
pub.key.curve25519Pub.len = 0;
ASSERT_EQ(CRYPT_EAL_PkeySetPub(NULL, &pub), CRYPT_NULL_INPUT);
pub.id = CRYPT_PKEY_DSA;
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_EAL_ERR_ALGID);
pub.id = id;
pub.key.curve25519Pub.len = CRYPT_CURVE25519_KEYLEN - 1;
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_CURVE25519_KEYLEN_ERROR);
pub.key.curve25519Pub.len = CRYPT_CURVE25519_KEYLEN + 1;
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_CURVE25519_KEYLEN_ERROR);
pub.key.curve25519Pub.len = CRYPT_CURVE25519_KEYLEN;
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CURVE25519_GET_PRV_API_TC001
* @title CURVE25519: CRYPT_EAL_PkeyGetPrv test.
* @precon Create a valid private key prv.
* @brief
* 1. Create the context of the curve25519 algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeyGetPrv method, where all parameters are valid, expected result 2.
* 3. Call the CRYPT_EAL_PkeySetPrv method to set private key, expected result 3.
* 4. Call the CRYPT_EAL_PkeyGetPrv method, where other parameters are valid, but:
* (1). pkey = NULL, expected result 4.
* (2). prv = NULL, expected result 4.
* (5). prv.id != pkey.id, expected result 5.
* (6). prv.len = 31, expected result 6.
* (6). prv.len = 33, expected result 7.
* (7). All parameters are valid, expected result 7.
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_CURVE25519_NO_PRVKEY
* 3. CRYPT_SUCCESS
* 4. CRYPT_NULL_INPUT
* 5. CRYPT_EAL_ERR_ALGID
* 6. CRYPT_CURVE25519_KEYLEN_ERROR
* 7. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CURVE25519_GET_PRV_API_TC001(int id, int isProvider)
{
uint8_t key[CRYPT_CURVE25519_KEYLEN] = {0};
CRYPT_EAL_PkeyPrv prv = {0};
Set_Curve25519_Prv(&prv, id, key, CRYPT_CURVE25519_KEYLEN);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, id, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prv), CRYPT_CURVE25519_NO_PRVKEY);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(NULL, &prv), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, NULL), CRYPT_NULL_INPUT);
prv.id = CRYPT_PKEY_DSA;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prv), CRYPT_EAL_ERR_ALGID);
prv.id = id;
prv.key.curve25519Prv.len = CRYPT_CURVE25519_KEYLEN - 1;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prv), CRYPT_CURVE25519_KEYLEN_ERROR);
prv.key.curve25519Prv.len = CRYPT_CURVE25519_KEYLEN;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prv), CRYPT_SUCCESS);
prv.key.curve25519Prv.len = CRYPT_CURVE25519_KEYLEN + 1;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prv), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CURVE25519_GET_PUB_API_TC001
* @title CURVE25519: CRYPT_EAL_PkeyGetPub test.
* @precon Create a valid public key pub.
* @brief
* 1. Create the context of the curve25519 algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeyGetPub method, where all parameters are valid, expected result 2.
* 3. Call the CRYPT_EAL_PkeySetPub method to set private key, expected result 3.
* 4. Call the CRYPT_EAL_PkeyGetPub method, where other parameters are valid, but :
* (1). pkey = NULL, expected result 4.
* (2). pub = NULL, expected result 4.
* (5). pub.id != pkey.id, expected result 5.
* (6). pub.len = 31, expected result 6.
* (6). pub.len = 33, expected result 7.
* (7). All parameters are valid, expected result 7.
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_CURVE25519_NO_PUBKEY
* 3. CRYPT_SUCCESS
* 4. CRYPT_NULL_INPUT
* 5. CRYPT_EAL_ERR_ALGID
* 6. CRYPT_CURVE25519_KEYLEN_ERROR
* 7. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CURVE25519_GET_PUB_API_TC001(int id, int isProvider)
{
uint8_t key[CRYPT_CURVE25519_KEYLEN] = {0};
CRYPT_EAL_PkeyPub pub;
Set_Curve25519_Pub(&pub, id, key, CRYPT_CURVE25519_KEYLEN);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, id, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pub), CRYPT_CURVE25519_NO_PUBKEY);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(NULL, &pub), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, NULL), CRYPT_NULL_INPUT);
pub.id = CRYPT_PKEY_DSA;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pub), CRYPT_EAL_ERR_ALGID);
pub.id = id;
pub.key.curve25519Pub.len = CRYPT_CURVE25519_KEYLEN - 1;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pub), CRYPT_CURVE25519_KEYLEN_ERROR);
pub.key.curve25519Pub.len = CRYPT_CURVE25519_KEYLEN;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pub), CRYPT_SUCCESS);
pub.key.curve25519Pub.len = CRYPT_CURVE25519_KEYLEN + 1;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pub), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CURVE25519_GET_KEY_LEN_API_TC001
* @title CURVE25519: CRYPT_EAL_PkeyGetKeyLen test.
* @precon nan
* @brief
* 1. Create the context of the curve25519 algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeyGetKeyLen method, where pkey is NULL, expected result 1.
* 3. Call the CRYPT_EAL_PkeyGetKeyLen method, where pkey is valid, expected result 2.
* @expect
* 1. Success, and context is not NULL.
* 2. Reutrn 0.
* 3. Return CRYPT_CURVE25519_KEYLEN(32)
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CURVE25519_GET_KEY_LEN_API_TC001(int id, int isProvider)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, id, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyGetKeyLen(NULL), 0);
ASSERT_EQ(CRYPT_EAL_PkeyGetKeyLen(pkey), CRYPT_CURVE25519_KEYLEN);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CURVE25519_KEY_GEN_API_TC001
* @title CURVE25519: CRYPT_EAL_PkeyGen test.
* @precon nan
* @brief
* 1. Create the context of the curve25519 algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeyGen method, where pkey is NULL, expected result 1.
* 3. Call the CRYPT_EAL_PkeyGen method, where pkey is valid, expected result 2.
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_NULL_INPUT
* 3. CRYPT_NO_REGIST_RAND
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CURVE25519_KEY_GEN_API_TC001(int id)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = CRYPT_EAL_PkeyNewCtx(id);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyGen(NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_NO_REGIST_RAND);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CURVE25519_KEY_GEN_API_TC002
* @title CURVE25519: CRYPT_EAL_PkeyGen test.
* @precon nan
* @brief
* 1. Create the context of the curve25519 algorithm, expected result 1.
* 2. Init the drbg, expected result 2.
* 3. Generate a key pair, expected result 2.
* 4. Call the CRYPT_EAL_PkeyGetPub method to get public key, expected result 2.
* 5. Call the CRYPT_EAL_PkeyGetPub method to get private key, expected result 2.
* @expect
* 1. Success, and context is not NULL.
* 2. Success
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CURVE25519_KEY_GEN_API_TC002(int id, int isProvider)
{
if (IsCurve25519AlgDisabled(id)) {
SKIP_TEST();
}
uint8_t key[CRYPT_CURVE25519_KEYLEN] = {0};
CRYPT_EAL_PkeyPub pub;
Set_Curve25519_Pub(&pub, id, key, CRYPT_CURVE25519_KEYLEN);
CRYPT_EAL_PkeyPrv prv = {0};
Set_Curve25519_Prv(&prv, id, key, CRYPT_CURVE25519_KEYLEN);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, id, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
/* Sets the entropy source. */
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prv), CRYPT_SUCCESS);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CURVE25519_SIGN_API_TC001
* @title CURVE25519: CRYPT_EAL_PkeySign test.
* @precon Prepare data for signature.
* @brief
* 1. Create the context of the ed25519 algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeySign method, where all parameters are valid, expected result 2.
* 3. Call the CRYPT_EAL_PkeySetPrv method to set private key, expected result 3.
* 4. Call the CRYPT_EAL_PkeySign method, where other parameters are valid, but :
* (1) hashId != CRYPT_MD_SHA512, expected result 4
* (2) data = NULL, expected result 4
* (3) sign = NULL, expected result 4
* (4) signLen = NULL, expected result 4
* (5) signLen = 0 | 63, expected result 5
* (6) signLen = 64 | 65, expected result 6
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_CURVE25519_NO_PRVKEY
* 3. CRYPT_SUCCESS
* 4. CRYPT_EAL_ERR_ALGID
* 5. CRYPT_NULL_INPUT
* 6. CRYPT_CURVE25519_SIGNLEN_ERROR
* 7. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CURVE25519_SIGN_API_TC001(int isProvider)
{
uint8_t key[CRYPT_CURVE25519_KEYLEN] = {0};
uint8_t data[CRYPT_CURVE25519_KEYLEN] = {0};
uint8_t sign[CRYPT_CURVE25519_SIGNLEN] = {0};
uint32_t signLen = sizeof(sign);
CRYPT_EAL_PkeyPrv prv = {0};
Set_Curve25519_Prv(&prv, CRYPT_PKEY_ED25519, key, CRYPT_CURVE25519_KEYLEN);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ED25519,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SHA512, data, sizeof(data), sign, &signLen), CRYPT_CURVE25519_NO_PRVKEY);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SHA256, data, sizeof(data), sign, &signLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SHA512, NULL, sizeof(data), sign, &signLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SHA512, data, sizeof(data), NULL, &signLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SHA512, data, sizeof(data), (uint8_t *)sign, NULL), CRYPT_NULL_INPUT);
signLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SHA512, data, sizeof(data), sign, &signLen), CRYPT_CURVE25519_SIGNLEN_ERROR);
signLen = CRYPT_CURVE25519_SIGNLEN - 1;
ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SHA512, data, sizeof(data), sign, &signLen), CRYPT_CURVE25519_SIGNLEN_ERROR);
signLen = CRYPT_CURVE25519_SIGNLEN;
ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SHA512, data, sizeof(data), sign, &signLen), CRYPT_SUCCESS);
signLen = CRYPT_CURVE25519_SIGNLEN + 1;
ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SHA512, data, sizeof(data), sign, &signLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CURVE25519_VERIFY_API_TC001
* @title CURVE25519: CRYPT_EAL_PkeyVerify test.
* @precon Prepare data for verify.
* @brief
* 1. Create the context of the ed25519 algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeySetPrv method to set private key, expected result 2.
* 3. Call the CRYPT_EAL_PkeySign method to sign, expected result 2.
* 4. Call the CRYPT_EAL_PkeyVerify method, where all parameters are valid, expected result 2
* 5. Call the CRYPT_EAL_PkeyVerify method, where other parameters are valid, but :
* (1) hashId != CRYPT_MD_SHA512, expected result 3
* (2) data = NULL, expected result 4
* (3) sign = NULL, expected result 4
* (4) signLen = 0 | 63 | 65, expected result 5
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_EAL_ERR_ALGID
* 4. CRYPT_NULL_INPUT
* 5. CRYPT_CURVE25519_SIGNLEN_ERROR
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CURVE25519_VERIFY_API_TC001(int isProvider)
{
uint8_t data[CRYPT_CURVE25519_KEYLEN] = {0};
uint8_t sign[CRYPT_CURVE25519_SIGNLEN] = {0};
uint32_t signLen = sizeof(sign);
uint8_t key[CRYPT_CURVE25519_KEYLEN] = {0};
CRYPT_EAL_PkeyPrv prv = {0};
Set_Curve25519_Prv(&prv, CRYPT_PKEY_ED25519, key, CRYPT_CURVE25519_KEYLEN);
CRYPT_EAL_PkeyPub pub = {0};
Set_Curve25519_Pub(&pub, CRYPT_PKEY_ED25519, key, CRYPT_CURVE25519_KEYLEN);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ED25519,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SHA512, data, sizeof(data), sign, &signLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA256, data, sizeof(data), sign, signLen), CRYPT_EAL_ERR_ALGID);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA512, data, sizeof(data), sign, signLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA512, NULL, sizeof(data), sign, signLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA512, data, sizeof(data), NULL, signLen), CRYPT_NULL_INPUT);
signLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA512, data, sizeof(data), sign, signLen), CRYPT_CURVE25519_SIGNLEN_ERROR);
signLen = CRYPT_CURVE25519_SIGNLEN - 1;
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA512, data, sizeof(data), sign, signLen), CRYPT_CURVE25519_SIGNLEN_ERROR);
signLen = CRYPT_CURVE25519_SIGNLEN + 1;
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA512, data, sizeof(data), sign, signLen), CRYPT_CURVE25519_SIGNLEN_ERROR);
EXIT:
CRYPT_EAL_RandDeinit();
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CURVE25519_DUP_CTX_API_TC001
* @title CURVE25519: CRYPT_EAL_PkeyDupCtx test.
* @precon nan
* @brief
* 1. Create the context of the ed25519 algorithm, expected result 1.
* 2. Init the drbg, expected result 2.
* 3. Generate a key pair, expected result 2.
* 4. Call the CRYPT_EAL_PkeyDupCtx method to dup ed25519 context, expected result 2.
* 5. Call the CRYPT_EAL_PkeyGetPub method to obtain the public key from the contexts, expected result 2.
* 6. Compare public keys, expected result 3.
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. The two public keys are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CURVE25519_DUP_CTX_API_TC001(int id)
{
uint8_t key1[CRYPT_CURVE25519_KEYLEN] = {0};
uint8_t key2[CRYPT_CURVE25519_KEYLEN] = {0};
CRYPT_EAL_PkeyPub pub = {0};
Set_Curve25519_Pub(&pub, id, key1, CRYPT_CURVE25519_KEYLEN);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = CRYPT_EAL_PkeyNewCtx(id);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
CRYPT_EAL_PkeyCtx *newPkey = CRYPT_EAL_PkeyDupCtx(pkey);
ASSERT_TRUE(newPkey != NULL);
ASSERT_EQ(newPkey->references.count, 1);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pub), CRYPT_SUCCESS);
pub.key.curve25519Pub.data = key2;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(newPkey, &pub), CRYPT_SUCCESS);
ASSERT_COMPARE("curve25519 copy ctx", key1, CRYPT_CURVE25519_KEYLEN, key2, CRYPT_CURVE25519_KEYLEN);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(newPkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ED25519_SIGN_FUNC_TC001
* @title ED25519 signature test: set the key and sign.
* @precon Test Vectors for Ed25519: SECRET KEY, MESSAGE(different length), SIGNATURE
* @brief
* 1. Create the context of the ed25519 algorithm, expected result 1.
* 2. Set the private key for ed25519, expected result 2.
* 3. Compute the signature of ed25519, expected result 2.
* 4. Compare the signature computed by step 3 and the signature vector, expected result 3.
* @expect
* 1. Success, and context is not NULL.
* 2. Success.
* 3. The signature calculation result is the same as the signature vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ED25519_SIGN_FUNC_TC001(Hex *key, Hex *msg, Hex *sign, int isProvider)
{
uint8_t *out = NULL;
uint32_t outLen = sizeof(out);
CRYPT_EAL_PkeyPrv prv = {0};
Set_Curve25519_Prv(&prv, CRYPT_PKEY_ED25519, key->x, key->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_ED25519,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &prv), CRYPT_SUCCESS);
outLen = CRYPT_EAL_PkeyGetSignLen(ctx);
out = calloc(1u, outLen);
ASSERT_TRUE(out != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SHA512, msg->x, msg->len, out, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(memcmp(out, sign->x, sign->len), 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
free(out);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ED25519_VERIFY_FUNC_TC001
* @title ED25519 signature verification test: set the public key and verify the signature.
* @precon Test Vectors for Ed25519: PUBLIC KEY, MESSAGE(different length), SIGNATURE
* @brief
* 1. Create the context of the ed25519 algorithm, expected result 1.
* 2. Set the public key for ed25519, expected result 2.
* 3. Verify the signature of ed25519, expected result 2.
* @expect
* 1. Success, and context is not NULL.
* 2. Success.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ED25519_VERIFY_FUNC_TC001(Hex *key, Hex *msg, Hex *sign, int isProvider)
{
CRYPT_EAL_PkeyPub pub = {0};
Set_Curve25519_Pub(&pub, CRYPT_PKEY_ED25519, key->x, key->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ED25519,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA512, msg->x, msg->len, sign->x, sign->len), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ED25519_SIGN_VERIFY_FUNC_TC001
* @title ED25519: Set(or copy) the key, sign, and verify the signature.
* @precon Test Vectors for Ed25519: SECRET KEY, PUBLIC KEY, MESSAGE(different length), SIGNATURE
* @brief
* 1. Create the context of the ed25519 algorithm, expected result 1
* 2. Set the private key for ed25519, expected result 2
* 3. Set the public key for ed25519(Public key and private key can coexist.), expected result 2
* 4. Compute the signature of ed25519, expected result 2
* 5. Compare Signatures, expected result 3.
* 6. Verify the signature of ed25519, expected result 2.
* 7. Copy the context of ed25519, expected result 2.
* 8. Repeat steps 4 through 6 above.
* @expect
* 1. Success, and context is not NULL.
* 2. Success.
* 3. The signature calculation result is the same as the signature vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ED25519_SIGN_VERIFY_FUNC_TC001(Hex *prvKey, Hex *pubKey, Hex *msg, Hex *sign, int isProvider)
{
#ifndef HITLS_CRYPTO_ED25519
SKIP_TEST();
#endif
uint8_t out[CRYPT_CURVE25519_SIGNLEN] = {0};
uint32_t outLen = sizeof(out);
CRYPT_EAL_PkeyCtx *cpyCtx = NULL;
CRYPT_EAL_PkeyPub pub = {0};
CRYPT_EAL_PkeyPrv prv = {0};
Set_Curve25519_Pub(&pub, CRYPT_PKEY_ED25519, pubKey->x, pubKey->len);
Set_Curve25519_Prv(&prv, CRYPT_PKEY_ED25519, prvKey->x, prvKey->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ED25519,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SHA512, msg->x, msg->len, out, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(memcmp(out, sign->x, sign->len), 0);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA512, msg->x, msg->len, sign->x, sign->len), CRYPT_SUCCESS);
cpyCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_ED25519,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(cpyCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCopyCtx(cpyCtx, pkey), CRYPT_SUCCESS);
outLen = sizeof(out);
ASSERT_EQ(CRYPT_EAL_PkeySign(cpyCtx, CRYPT_MD_SHA512, msg->x, msg->len, out, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(memcmp(out, sign->x, sign->len), 0);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(cpyCtx, CRYPT_MD_SHA512, msg->x, msg->len, sign->x, sign->len), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(cpyCtx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_X25519_EXCH_FUNC_TC001
* @title X25519 key exchange test: generate key pair and key exchange.
* @precon nan
* @brief
* 1. Create two contexts(pkey1, pkey2) of the ed25519 algorithm, expected result 1.
* 2. Init the drbg, expected result 2.
* 3. Generate a key pair, expected result 2.
* 4. Compute the shared key from the privite value in pkey1 and the public vlaue in pkey2, expected result 2.
* 5. Compute the shared key from the privite value in pkey2 and the public vlaue in pkey1, expected result 2.
* 6. Compare the shared keys computed in the preceding two steps, expected result 3.
* @expect
* 1. Success, and two contexts are not NULL.
* 2. Success.
* 3. The two shared keys are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_X25519_EXCH_FUNC_TC001(int isProvider)
{
#ifndef HITLS_CRYPTO_X25519
SKIP_TEST();
#endif
uint8_t share1[CRYPT_CURVE25519_KEYLEN] = {0};
uint8_t share2[CRYPT_CURVE25519_KEYLEN] = {0};
uint32_t share1Len = sizeof(share1);
uint32_t share2Len = sizeof(share2);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_X25519,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_X25519,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey1 != NULL && pkey2 != NULL);
// Sets the entropy source.
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey2), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, share1, &share1Len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(pkey2, pkey1, share2, &share2Len), CRYPT_SUCCESS);
ASSERT_EQ(share1Len, share2Len);
ASSERT_EQ(memcmp(share1, share2, share1Len), 0);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_X25519_EXCH_FUNC_TC002
* @title X25519 key exchange test: set the key or copy the context, and exchange the key.
* @precon Test Vectors for X25519: One's public key, The other's private key, Their shared key
* @brief
* 1. Create two contexts(pkey1, pkey2) of the X25519 algorithm, expected result 1.
* 2. Set the public key and private key for pkey1 and pkey2, expected result 2.
* 3. Compute the shared key from the privite value in pkey1 and the public vlaue in pkey2, expected result 2.
* 4. Compare the shared key computed by step 5 and the share secret vector, expected result 3.
* 5. Copy the two contexts, expected result 2.
* 6. Repeat steps 3 and 4 above.
* @expect
* 1. Success, and two contexts are not NULL.
* 2. Success.
* 3. The two shared keys are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_X25519_EXCH_FUNC_TC002(Hex *pubkey, Hex *prvkey, Hex *share, int isProvider)
{
#ifndef HITLS_CRYPTO_X25519
SKIP_TEST();
#endif
uint8_t shareKey[CRYPT_CURVE25519_KEYLEN];
uint32_t shareLen = sizeof(shareKey);
CRYPT_EAL_PkeyCtx *cpyCtx1 = NULL;
CRYPT_EAL_PkeyCtx *cpyCtx2 = NULL;
CRYPT_EAL_PkeyPub pub = {0};
CRYPT_EAL_PkeyPrv prv = {0};
Set_Curve25519_Pub(&pub, CRYPT_PKEY_X25519, pubkey->x, pubkey->len);
Set_Curve25519_Prv(&prv, CRYPT_PKEY_X25519, prvkey->x, prvkey->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_X25519,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_X25519,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey1 != NULL && pkey2 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey1, &prv), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey1, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey2, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey2, &prv), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, shareKey, &shareLen), CRYPT_SUCCESS);
ASSERT_EQ(shareLen, share->len);
ASSERT_EQ(memcmp(shareKey, share->x, shareLen), 0);
cpyCtx1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_X25519,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
cpyCtx2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_X25519,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(cpyCtx1 != NULL && cpyCtx2 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCopyCtx(cpyCtx1, pkey1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCopyCtx(cpyCtx2, pkey2), CRYPT_SUCCESS);
shareLen = sizeof(shareKey);
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(cpyCtx1, cpyCtx2, shareKey, &shareLen), CRYPT_SUCCESS);
ASSERT_EQ(shareLen, share->len);
ASSERT_EQ(memcmp(shareKey, share->x, shareLen), 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
CRYPT_EAL_PkeyFreeCtx(cpyCtx1);
CRYPT_EAL_PkeyFreeCtx(cpyCtx2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CURVE25519_CMP_FUNC_TC001
* @title Curve25519: The input and output parameters address are the same.
* @precon Vector: private key and public key.
* @brief
* 1. Create the contexts(ctx1, ctx2) of the curve25519 algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 2
* 3. Set public key for ctx1, expected result 3
* 4. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 4
* 5. Set public key for ctx2, expected result 5
* 6. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 6
* @expect
* 1. Success, and contexts are not NULL.
* 2. CRYPT_ECC_KEY_PUBKEY_NOT_EQUAL
* 3. CRYPT_SUCCESS
* 4. CRYPT_ECC_KEY_PUBKEY_NOT_EQUAL
* 5-6. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CURVE25519_CMP_FUNC_TC001(int algId, Hex *pubKey, int isProvider)
{
CRYPT_EAL_PkeyPub pub = {0};
Set_Curve25519_Pub(&pub, algId, pubKey->x, pubKey->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx1 = TestPkeyNewCtx(NULL, algId, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default",
isProvider);
CRYPT_EAL_PkeyCtx *ctx2 = TestPkeyNewCtx(NULL, algId, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default",
isProvider);
ASSERT_TRUE(ctx1 != NULL && ctx2 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_CURVE25519_NO_PUBKEY);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx1, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_CURVE25519_NO_PUBKEY);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx2, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ED25519_KEY_PAIR_CHECK_FUNC_TC001
* @title Ed25519: key pair check.
* @precon Registering memory-related functions.
* @brief
* 1. Create two contexts(pubCtx, prvCtx) of the ed25519 algorithm, expected result 1
* 2. Set public key for pubCtx, expected result 2
* 3. Set private key for prvCtx, expected result 3
* 4. Check whether the public key matches the private key, expected result 4
* @expect
* 1. Success, and contexts are not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_SUCCESS
* 4. Return CRYPT_SUCCESS when expect is 1, CRYPT_CURVE25519_VERIFY_FAIL otherwise.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ED25519_KEY_PAIR_CHECK_FUNC_TC001(Hex *pubkey, Hex *prvkey, int expect, int isProvider)
{
#if !defined(HITLS_CRYPTO_ED25519_CHECK)
(void)prvkey;
(void)pubkey;
(void)expect;
(void)isProvider;
SKIP_TEST();
#else
CRYPT_EAL_PkeyCtx *pubCtx = NULL;
CRYPT_EAL_PkeyCtx *prvCtx = NULL;
CRYPT_EAL_PkeyPub pub = {0};
CRYPT_EAL_PkeyPrv prv = {0};
int expectRet = expect == 1 ? CRYPT_SUCCESS : CRYPT_CURVE25519_PAIRWISE_CHECK_FAIL;
Set_Curve25519_Prv(&prv, CRYPT_PKEY_ED25519, prvkey->x, prvkey->len);
Set_Curve25519_Pub(&pub, CRYPT_PKEY_ED25519, pubkey->x, pubkey->len);
TestMemInit();
pubCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_ED25519, CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE,
"provider=default", isProvider);
prvCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_ED25519, CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pubCtx != NULL && prvCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubCtx, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prv), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), expectRet);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pubCtx);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CURVE25519_GET_KEY_BITS_FUNC_TC001
* @title CURVE25519: get key bits.
* @brief
* 1. Create a context of the Curve25519 algorithm, expected result 1
* 2. Get key bits, expected result 2
* @expect
* 1. Success, and context is not NULL.
* 2. Equal to keyBits.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CURVE25519_GET_KEY_BITS_FUNC_TC001(int id, int keyBits, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, id, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyGetKeyBits(pkey) == (uint32_t)keyBits);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CURVE25519_GET_SECURITY_BITS_FUNC_TC001
* @title CURVE25519 CRYPT_EAL_PkeyGetSecurityBits test.
* @precon nan
* @brief
* 1. Create the context of the X25519 algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyGetSecurityBits Obtains secbits, expected result 2
* @expect
* 1. Success, and the context is not null.
* 2. The return value is secBits.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CURVE25519_GET_SECURITY_BITS_FUNC_TC001(int id, int secBits)
{
CRYPT_EAL_PkeyCtx *pkey = CRYPT_EAL_PkeyNewCtx(id);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyGetSecurityBits(pkey) == (uint32_t)secBits);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CURVE25519_KEY_PAIR_CHECK_FUNC_TC001
* @brief CURVE25519: key pair check.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CURVE25519_KEY_PAIR_CHECK_FUNC_TC001(int id, int isProvider)
{
#if !defined(HITLS_CRYPTO_ED25519_CHECK) && !defined(HITLS_CRYPTO_X25519_CHECK)
(void)id;
(void)isProvider;
SKIP_TEST();
#else
CRYPT_EAL_PkeyCtx *pubCtx = NULL;
CRYPT_EAL_PkeyCtx *prvCtx = NULL;
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
pubCtx = TestPkeyNewCtx(NULL, id, CRYPT_EAL_PKEY_KEYMGMT_OPERATE,
"provider=default", isProvider);
prvCtx = TestPkeyNewCtx(NULL, id, CRYPT_EAL_PKEY_KEYMGMT_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pubCtx != NULL && prvCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(NULL, NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_CURVE25519_NO_PRVKEY); // no prv key and pub key.
ASSERT_EQ(CRYPT_EAL_PkeyGen(prvCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_CURVE25519_NO_PUBKEY); // no pub key
ASSERT_EQ(CRYPT_EAL_PkeyGen(pubCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_CURVE25519_PAIRWISE_CHECK_FAIL);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(prvCtx, prvCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, pubCtx), CRYPT_SUCCESS);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pubCtx);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CURVE25519_PRV_KEY_CHECK_FUNC_TC001
* @brief CURE25519: private key check.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CURVE25519_PRV_KEY_CHECK_FUNC_TC001(int id, int isProvider)
{
#if !defined(HITLS_CRYPTO_ED25519_CHECK) && !defined(HITLS_CRYPTO_X25519_CHECK)
(void)id;
(void)isProvider;
SKIP_TEST();
#else
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_CURVE25519_Ctx *ctx = NULL;
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, id, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_CURVE25519_NO_PRVKEY);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SUCCESS);
ctx = (CRYPT_CURVE25519_Ctx *)pkey->key;
(void)memset_s(ctx->prvKey, CRYPT_CURVE25519_KEYLEN, 0, CRYPT_CURVE25519_KEYLEN);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_CURVE25519_INVALID_PRVKEY);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
#endif
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/curve25519/test_suite_sdv_eal_curve25519.c | C | unknown | 40,616 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdint.h>
#include <stdbool.h>
#include "securec.h"
#include "bsl_sal.h"
#include "crypt_algid.h"
#include "crypt_types.h"
#include "crypt_eal_pkey.h"
#include "crypt_errno.h"
#include "crypt_eal_rand.h"
#include "crypt_util_rand.h"
#include "crypt_bn.h"
#include "dh_local.h"
#include "crypt_dh.h"
#include "eal_pkey_local.h"
#define UINT8_MAX_NUM 255
#define CRYPT_EAL_PKEY_KEYMGMT_OPERATE 0
static int32_t RandFunc(uint8_t *randNum, uint32_t randLen)
{
for (uint32_t i = 0; i < randLen; i++) {
randNum[i] = (uint8_t)(rand() % UINT8_MAX_NUM);
}
return 0;
}
static int32_t RandFuncEx(void *libCtx, uint8_t *randNum, uint32_t randLen)
{
(void)libCtx;
for (uint32_t i = 0; i < randLen; i++) {
randNum[i] = (uint8_t)(rand() % UINT8_MAX_NUM);
}
return 0;
}
static void Set_DH_Para(
CRYPT_EAL_PkeyPara *para, uint8_t *p, uint8_t *q, uint8_t *g, uint32_t pLen, uint32_t qLen, uint32_t gLen)
{
para->id = CRYPT_PKEY_DH;
para->para.dhPara.p = p;
para->para.dhPara.q = q;
para->para.dhPara.g = g;
para->para.dhPara.pLen = pLen;
para->para.dhPara.qLen = qLen;
para->para.dhPara.gLen = gLen;
}
static void Set_DH_Prv(CRYPT_EAL_PkeyPrv *prv, uint8_t *key, uint32_t keyLen)
{
prv->id = CRYPT_PKEY_DH;
prv->key.dhPrv.data = key;
prv->key.dhPrv.len = keyLen;
}
static void Set_DH_Pub(CRYPT_EAL_PkeyPub *pub, uint8_t *key, uint32_t keyLen)
{
pub->id = CRYPT_PKEY_DH;
pub->key.dhPub.data = key;
pub->key.dhPub.len = keyLen;
}
/* END_HEADER */
/**
* @test SDV_CRYPTO_DH_FUNC_TC001
* @title DH Key exchange vector test.
* @precon Registering memory-related functions.
* NIST test vectors.
* @brief
* 1. Create the contexts(pkey1, pkey2) of the dh algorithm, expected result 1
* 2. Set parameters for pkey1, expected result 2
* 3. Call the CRYPT_EAL_PkeyComputeShareKey method: pkey1(A.prvKey) and pkey2(B.pubKey), expected result 3
* 4. Check whether the generated key is consistent with the vector, expected result 4
* 5. Call the CRYPT_EAL_PkeyComputeShareKey method: pkey1(B.prvKey) and pkey2(A.pubKey), expected result 5
* 6. Check whether the generated key is consistent with the vector, expected result 6
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_SUCCESS
* 4. Both are consistent.
* 5. CRYPT_SUCCESS
* 6. Both are consistent.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_FUNC_TC001(
Hex *p, Hex *g, Hex *q, Hex *prv1, Hex *pub1, Hex *prv2, Hex *pub2, Hex *share, int isProvider)
{
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
uint8_t shareLocal[1030];
uint32_t shareLen = sizeof(shareLocal);
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
Set_DH_Para(¶, p->x, q->x, g->x, p->len, q->len, g->len);
Set_DH_Prv(&prv, prv1->x, prv1->len);
Set_DH_Pub(&pub, pub2->x, pub2->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey1 != NULL && pkey2 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey1, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey1, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey2, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, shareLocal, &shareLen) == CRYPT_SUCCESS);
ASSERT_TRUE(shareLen == share->len);
ASSERT_TRUE(memcmp(shareLocal, share->x, shareLen) == 0);
Set_DH_Prv(&prv, prv2->x, prv2->len);
Set_DH_Pub(&pub, pub1->x, pub1->len);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey1, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey2, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, shareLocal, &shareLen) == CRYPT_SUCCESS);
ASSERT_TRUE(shareLen == share->len);
ASSERT_TRUE(memcmp(shareLocal, share->x, shareLen) == 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_FUNC_TC002
* @title DH Key exchange test: Generate key pairs.
* @precon Registering memory-related functions.
* Nist test vectors: DH parameters.
* @brief
* 1. Create the contexts(pkey1, pkey2) of the dh algorithm, expected result 1
* 2. Set parameters for pkey1 and pkey2, expected result 2
* 3. Generate key pairs, expected result 2
* 4. Compute the shared key from the privite value in pkey1 and the public vlaue in peky2, expected result 2.
* 5. Compute the shared key from the privite value in pkey2 and the public vlaue in pkey1, expected result 2.
* 6. Compare the shared keys computed in the preceding two steps, expected result 3.
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. The two shared keys are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_FUNC_TC002(Hex *p, Hex *g, Hex *q, int isProvider)
{
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
uint8_t share1[1030];
uint8_t share2[1030];
uint32_t share1Len = sizeof(share1);
uint32_t share2Len = sizeof(share2);
CRYPT_EAL_PkeyPara para = {0};
Set_DH_Para(¶, p->x, q->x, g->x, p->len, q->len, g->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey1 != NULL && pkey2 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey1, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey2, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey2) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, share1, &share1Len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey2, pkey1, share2, &share2Len) == CRYPT_SUCCESS);
ASSERT_TRUE(share1Len == share2Len);
ASSERT_TRUE(memcmp(share1, share2, share1Len) == 0);
EXIT:
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_FUNC_TC003
* @title DH Key exchange test: Set parameters based on the ID to generate key pairs.
* @precon Registering memory-related functions.
* @brief
* 1. Create the contexts(pkey1, pkey2) of the dh algorithm, expected result 1
* 2. Set parameters byt id for pkey1 and pkey2, expected result 2
* 3. Generate key pairs, expected result 2
* 4. Compute the shared key from the privite value in pkey1 and the public vlaue in peky2, expected result 2.
* 5. Compute the shared key from the privite value in pkey2 and the public vlaue in pkey1, expected result 2.
* 6. Compare the shared keys computed in the preceding two steps, expected result 3.
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. The two shared keys are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_FUNC_TC003(int id, int isProvider)
{
uint8_t share1[1030];
uint8_t share2[1030];
uint32_t share1Len = sizeof(share1);
uint32_t share2Len = sizeof(share2);
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey1 != NULL && pkey2 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetParaById(pkey1, id) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetParaById(pkey2, id) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey2) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, share1, &share1Len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey2, pkey1, share2, &share2Len) == CRYPT_SUCCESS);
ASSERT_TRUE(share1Len == share2Len);
ASSERT_TRUE(memcmp(share1, share2, share1Len) == 0);
EXIT:
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_FUNC_TC004
* @title DH Key exchange test: Generate a key pair repeatedly.
* @precon Registering memory-related functions.
* Nist test vectors: DH parameters.
* @brief
* 1. Create the contexts(pkey1, pkey2) of the dh algorithm, expected result 1
* 2. Set parameters for pkey1 and pkey2, expected result 2
* 3. Generate a key pair repeatedly, expected result 2
* 4. Compute the shared key from the privite value in pkey1 and the public vlaue in peky2, expected result 2.
* 5. Compute the shared key from the privite value in pkey2 and the public vlaue in pkey1, expected result 2.
* 6. Compare the shared keys computed in the preceding two steps, expected result 3.
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. The two shared keys are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_FUNC_TC004(Hex *p, Hex *g, Hex *q, int isProvider)
{
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
uint8_t share1[1030];
uint8_t share2[1030];
uint32_t share1Len = sizeof(share1);
uint32_t share2Len = sizeof(share2);
CRYPT_EAL_PkeyPara para = {0};
Set_DH_Para(¶, p->x, q->x, g->x, p->len, q->len, g->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey1 != NULL && pkey2 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey1, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey2, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey2) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey2) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, share1, &share1Len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey2, pkey1, share2, &share2Len) == CRYPT_SUCCESS);
ASSERT_TRUE(share1Len == share2Len);
ASSERT_TRUE(memcmp(share1, share2, share1Len) == 0);
EXIT:
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_FUNC_TC005
* @title DH Key exchange failed. The public key is invalid.
* @precon Registering memory-related functions.
* Nist test vectors: DH parameters, private key, public key.
* @brief
* 1. Create the contexts(pkey1, pkey2) of the dh algorithm, expected result 1.
* 2. Set parameters for pkey1, expected result 2
* 3. Call the CRYPT_EAL_PkeyComputeShareKey method:
* (1) pkey1(valid prvKey), pkey2(pubKey = p - 1), expected result 3
* (2) pkey1(valid prvKey), pkey2(pubKey ^ q mod p != 1), expected result 3
* (3) pkey1(valid prvKey), pkey2(pubKey = 0), expected result 3
* (4) pkey1(valid prvKey), pkey2(pubKey = 1), expected result 3
* @expect
* 1. Success, and contexts are not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_DH_KEYINFO_ERROR
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_FUNC_TC005(Hex *p, Hex *g, Hex *q, Hex *prv1, int isProvider)
{
uint8_t shareLocal[1030];
uint32_t shareLen = sizeof(shareLocal);
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
uint8_t *tmpPub = (uint8_t *)malloc(sizeof(uint8_t) * p->len);
ASSERT_TRUE(tmpPub != NULL);
ASSERT_TRUE(memcpy_s(tmpPub, p->len, p->x, p->len) == 0);
int last = p->len - 1;
tmpPub[last] -= 1; // pubKey = p - 1
Set_DH_Prv(&prv, prv1->x, prv1->len);
Set_DH_Pub(&pub, tmpPub, p->len);
Set_DH_Para(¶, p->x, q->x, g->x, p->len, q->len, g->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey1 != NULL && pkey2 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey1, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey1, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey2, &pub) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, shareLocal, &shareLen), CRYPT_DH_KEYINFO_ERROR);
ASSERT_TRUE(memset_s(tmpPub, p->len, 0, p->len) == 0); // pubKey = 0;
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey2, &pub) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, shareLocal, &shareLen), CRYPT_DH_KEYINFO_ERROR);
tmpPub[last] = 1; // pubKey = 1
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey2, &pub) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, shareLocal, &shareLen), CRYPT_DH_KEYINFO_ERROR);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
if (tmpPub != NULL) {
free(tmpPub);
}
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_FUNC_TC006
* @title Key exchange failure vector test, invalid vector.
* @precon Registering memory-related functions.
* NIST test vectors.
* @brief
* 1. Create the contexts(pkey1, pkey2) of the dh algorithm, expected result 1.
* 2. Set parameters for pkey1, expected result 2
* 3. Call the CRYPT_EAL_PkeyComputeShareKey method: pkey1(A.prvKey) and pkey2(B.pubKey)
* 4. Check whether the generated shared key is consistent with the vector
* 5. Call the CRYPT_EAL_PkeyComputeShareKey method: pkey1(B.prvKey) and pkey2(A.pubKey)
* 6. Check whether the generated key is consistent with the vector
* 7. Check the values returned in steps 3 to 6, expected result 3
* @expect
* 1. Success, and contexts are not NULL.
* 2. CRYPT_SUCCESS
* 3. At least one failure or the generated key and vector are not equal.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_FUNC_TC006(
Hex *p, Hex *g, Hex *q, Hex *prv1, Hex *pub1, Hex *prv2, Hex *pub2, Hex *share, int isProvider)
{
uint8_t shareLocal[1030];
uint32_t shareLen = sizeof(shareLocal);
int ret1, ret2;
int cmpRet1, cmpRet2;
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
Set_DH_Para(¶, p->x, q->x, g->x, p->len, q->len, g->len);
Set_DH_Prv(&prv, prv1->x, prv1->len);
Set_DH_Pub(&pub, pub2->x, pub2->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey1 != NULL && pkey2 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey1, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey1, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey2, &pub) == CRYPT_SUCCESS);
ret1 = CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, shareLocal, &shareLen);
cmpRet1 = memcmp(shareLocal, share->x, share->len);
Set_DH_Prv(&prv, prv2->x, prv2->len);
Set_DH_Pub(&pub, pub1->x, pub1->len);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey1, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey2, &pub) == CRYPT_SUCCESS);
ret2 = CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, shareLocal, &shareLen);
ret2 = CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, shareLocal, &shareLen);
cmpRet2 = memcmp(shareLocal, share->x, share->len);
ASSERT_TRUE(ret1 != CRYPT_SUCCESS || cmpRet1 != 0 || ret2 != CRYPT_SUCCESS || cmpRet2 != 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_SET_PARA_API_TC001
* @title DH CRYPT_EAL_PkeySetPara: Invalid parameter (NULL).
* @precon Registering memory-related functions.
* DH parameters.
* @brief
* 1. Create the context(pkey) of the dh algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeySetPara method: p = null, expected result 2
* 3. Call the CRYPT_EAL_PkeySetPara method: pLen = 0, expected result 2
* 4. Call the CRYPT_EAL_PkeySetPara method: g = null, expected result 2
* 5. Call the CRYPT_EAL_PkeySetPara method: gLen = 0, expected result 2
* 6. Call the CRYPT_EAL_PkeySetPara method: q = null, qLen != 0, expected result 2
* 7. Call the CRYPT_EAL_PkeySetPara method: ctx = null, expected result 3
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_EAL_ERR_NEW_PARA_FAIL
* 3. CRYPT_NULL_INPUT
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_SET_PARA_API_TC001(Hex *p, Hex *g, Hex *q, int isProvider)
{
CRYPT_EAL_PkeyPara para = {0};
Set_DH_Para(¶, NULL, q->x, g->x, p->len, q->len, g->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE_AND_LOG("p is null", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_EAL_ERR_NEW_PARA_FAIL);
para.para.dhPara.p = p->x;
para.para.dhPara.pLen = 0;
ASSERT_TRUE_AND_LOG("pLen is zero", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_EAL_ERR_NEW_PARA_FAIL);
para.para.dhPara.pLen = p->len;
para.para.dhPara.g = NULL;
ASSERT_TRUE_AND_LOG("g is null", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_EAL_ERR_NEW_PARA_FAIL);
para.para.dhPara.g = g->x;
para.para.dhPara.gLen = 0;
ASSERT_TRUE_AND_LOG("gLen is zero", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_EAL_ERR_NEW_PARA_FAIL);
para.para.dhPara.gLen = g->len;
para.para.dhPara.q = NULL;
ASSERT_TRUE_AND_LOG("q is null but qLen != 0", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_EAL_ERR_NEW_PARA_FAIL);
para.para.dhPara.q = q->x;
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(NULL, ¶) == CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_SET_PARA_API_TC002
* @title DH CRYPT_EAL_PkeySetPara: Invalid parameter(length).
* @precon Registering memory-related functions.
* DH parameters.
* @brief
* 1. Create the context(pkey) of the dh algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeySetPara method: pLen > 8192, expected result 2
* 3. Call the CRYPT_EAL_PkeySetPara method: pLen < 768, expected result 2
* 4. Call the CRYPT_EAL_PkeySetPara method: pLen > 768, but actual data Len < 768, expected result 3
* 5. Call the CRYPT_EAL_PkeySetPara method: qLen < 160, expected result 3
* 6. Call the CRYPT_EAL_PkeySetPara method: qLen > pLen, expected result 2
* 7. Call the CRYPT_EAL_PkeySetPara method: qLen > 160, but actual data Len < 160, expected result 3
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_EAL_ERR_NEW_PARA_FAIL
* 3. CRYPT_DH_PARA_ERROR
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_SET_PARA_API_TC002(Hex *p, Hex *g, Hex *q, int isProvider)
{
uint8_t longBuf[1030] = {0};
uint32_t bufLen = sizeof(longBuf);
CRYPT_EAL_PkeyPara para = {0};
Set_DH_Para(¶, longBuf, q->x, g->x, bufLen, q->len, g->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
longBuf[0] = 1;
longBuf[1024] = 1;
ASSERT_TRUE_AND_LOG("p greater than 8192", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_EAL_ERR_NEW_PARA_FAIL);
para.para.dhPara.p = p->x;
para.para.dhPara.pLen = 95; // 768 / 8 = 96, 96 - 1 = 95
ASSERT_TRUE_AND_LOG("p smaller than 768", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_EAL_ERR_NEW_PARA_FAIL);
(void)memset_s(longBuf, sizeof(longBuf), 0, sizeof(longBuf));
longBuf[p->len - 1] = 1;
para.para.dhPara.p = longBuf;
para.para.dhPara.pLen = p->len;
ASSERT_TRUE_AND_LOG("p greater than 768 but value smaller than 768 bits",
CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_DH_PARA_ERROR);
para.para.dhPara.p = p->x;
para.para.dhPara.pLen = p->len;
para.para.dhPara.qLen = 19; // 160 / 8 = 20, 19 < 20
para.para.dhPara.q = longBuf;
(void)memset_s(longBuf, sizeof(longBuf), 0, sizeof(longBuf));
longBuf[18] = 1;
ASSERT_TRUE_AND_LOG("q smaller than 160", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_DH_PARA_ERROR);
para.para.dhPara.qLen = p->len + 1;
ASSERT_TRUE_AND_LOG("q longer than p", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_EAL_ERR_NEW_PARA_FAIL);
(void)memset_s(longBuf, sizeof(longBuf), 0, sizeof(longBuf));
longBuf[20] = 1;
para.para.dhPara.qLen = 21;
ASSERT_TRUE_AND_LOG("q greater than 160 but value smaller than 160 bits",
CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_DH_PARA_ERROR);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_SET_PARA_API_TC003
* @title DH CRYPT_EAL_PkeySetPara: Invalid parameter (value).
* @precon Registering memory-related functions.
* DH parameters.
* @brief
* 1. Create the context(pkey) of the dh algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeySetPara method: p is an even number, expected result 2
* 3. Call the CRYPT_EAL_PkeySetPara method: q is an even number, expected result 2
* 4. Call the CRYPT_EAL_PkeySetPara method: g=0, expected result 2
* 5. Call the CRYPT_EAL_PkeySetPara method: g=1, expected result 2
* 6. Call the CRYPT_EAL_PkeySetPara method: g=p-1, expected result 2
* 7. Call the CRYPT_EAL_PkeySetPara method: q=p-1, expected result 2
* 8. Call the CRYPT_EAL_PkeySetPara method: q=p-2, expected result 2
* 9. Call the CRYPT_EAL_PkeySetPara method: q=p+2>p, expected result 2
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_DH_PARA_ERROR
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_SET_PARA_API_TC003(Hex *p, Hex *g, Hex *q, int isProvider)
{
uint8_t buf[1030];
uint32_t bufLen = sizeof(buf);
CRYPT_EAL_PkeyPara para = {0};
Set_DH_Para(¶, NULL, q->x, g->x, 0, q->len, g->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
int last = p->len - 1;
ASSERT_TRUE(memcpy_s(buf, bufLen, p->x, p->len) == 0);
buf[last] += 1; // p is even
para.para.dhPara.p = buf;
para.para.dhPara.pLen = p->len;
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_DH_PARA_ERROR);
ASSERT_TRUE(memcpy_s(buf, bufLen, q->x, q->len) == 0);
last = q->len - 1;
buf[last] += 1; // q is even
para.para.dhPara.p = p->x;
para.para.dhPara.q = buf;
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_DH_PARA_ERROR);
(void)memset_s(buf, sizeof(buf), 0, sizeof(buf)); // g = 0
para.para.dhPara.q = q->x;
para.para.dhPara.g = buf;
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_DH_PARA_ERROR);
last = g->len - 1;
buf[last] = 1; // g = 1
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_DH_PARA_ERROR);
last = p->len - 1;
para.para.dhPara.gLen = p->len;
ASSERT_TRUE(memcpy_s(buf, bufLen, p->x, p->len) == 0);
buf[last] -= 1; // g = p - 1
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_DH_PARA_ERROR);
// q = p - 1
para.para.dhPara.g = g->x;
para.para.dhPara.gLen = g->len;
para.para.dhPara.q = buf;
para.para.dhPara.qLen = p->len;
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_DH_PARA_ERROR);
buf[last] -= 1; // q = p - 2
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_DH_PARA_ERROR);
buf[last] += 4; // q = p - 2 + 4 = p + 2 > p
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_DH_PARA_ERROR);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_SET_PARA_API_TC004
* @title DH CRYPT_EAL_PkeySetPara: Repeated call.
* @precon Registering memory-related functions.
* DH parameters.
* @brief
* 1. Create the context(pkey) of the dh algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeySetPara method with normal parameters, expected result 2
* 3. Call the CRYPT_EAL_PkeySetPara method with normal parameters again, expected result 3
* 4. Call the CRYPT_EAL_PkeySetPara method: pLen < 768, expected result 4
* 5. Call the CRYPT_EAL_PkeySetPara method with normal parameters again, expected result 5
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_SUCCESS
* 4. CRYPT_EAL_ERR_NEW_PARA_FAIL
* 5. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_SET_PARA_API_TC004(Hex *p, Hex *g, Hex *q, int isProvider)
{
CRYPT_EAL_PkeyPara para = {0};
Set_DH_Para(¶, p->x, q->x, g->x, p->len, q->len, g->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
para.para.dhPara.pLen = 95; // 768 / 8 = 96, 95 < 96
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_EAL_ERR_NEW_PARA_FAIL);
para.para.dhPara.pLen = p->len;
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_SET_PRV_API_TC001
* @title DH: CRYPT_EAL_PkeySetPrv test.
* @precon Registering memory-related functions.
* DH parameters and private key.
* @brief
* 1. Create the context(pkey) of the dh algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeySetPrv method before CRYPT_EAL_PkeySetPara, expected result 2
* 3. Call the CRYPT_EAL_PkeySetPara method to set para, expected result 3
* 4. Call the CRYPT_EAL_PkeySetPrv method:
* (1). pkey = NULL, expected result 4.
* (2). prv = NULL, expected result 4.
* (3). prv.data = NULL, expected result 4.
* (4). prv.len = 0, expected result 4.
* (5). prv.id != pkey.id, expected result 3.
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_DH_PARA_ERROR
* 3. CRYPT_SUCCESS
* 4. CRYPT_NULL_INPUT
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_SET_PRV_API_TC001(Hex *p, Hex *g, Hex *q, Hex *prvKey, int isProvider)
{
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPrv prv = {0};
Set_DH_Para(¶, p->x, q->x, g->x, p->len, q->len, g->len);
Set_DH_Prv(&prv, prvKey->x, prvKey->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey, &prv) == CRYPT_DH_PARA_ERROR);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(NULL, &prv) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey, NULL) == CRYPT_NULL_INPUT);
prv.key.dhPrv.data = NULL;
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey, &prv) == CRYPT_NULL_INPUT);
prv.key.dhPrv.data = prvKey->x;
prv.key.dhPrv.len = 0;
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey, &prv) == CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_SET_PRV_API_TC002
* @title DH: CRYPT_EAL_PkeySetPrv test. Boundary value test for the private key.
* @precon Registering memory-related functions.
* DH parameters.
* @brief
* 1. Create the context(pkey) of the dh algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeySetPara method to set para(q = NULL), expected result 2
* 3. Call the CRYPT_EAL_PkeySetPrv method:
* (1) prvKey = p - 1, expected result 3
* (2) prvKey = p - 2, expected result 4
* 4. Call the CRYPT_EAL_PkeySetPara method to set para(q != NULL), expected result 5
* 5. Call the CRYPT_EAL_PkeySetPrv method:
* (1) prvKey = q, expected result 6
* (1) prvKey = 0, expected result 7
* (1) prvKey = 1, expected result 8
* (1) prvKey = q - 1, expected result 9
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_DH_KEYINFO_ERROR
* 4. CRYPT_SUCCESS
* 5. CRYPT_SUCCESS
* 6. CRYPT_DH_KEYINFO_ERROR
* 7. CRYPT_SUCCESS
* 8. CRYPT_DH_KEYINFO_ERROR
* 9. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_SET_PRV_API_TC002(Hex *p, Hex *g, Hex *q, int isProvider)
{
uint8_t *tmpPrv = NULL;
int last;
CRYPT_EAL_PkeyPara para = {0};
Set_DH_Para(¶, p->x, NULL, g->x, p->len, 0, g->len);
CRYPT_EAL_PkeyPrv prv = {0};
prv.id = CRYPT_PKEY_DH;
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
tmpPrv = (uint8_t *)malloc(sizeof(uint8_t) * p->len);
ASSERT_TRUE(memcpy_s(tmpPrv, p->len, p->x, p->len) == 0);
last = p->len - 1;
tmpPrv[last] -= 1; // tmpPrv = p - 1, Vectors are guaranteed not to wrap around.
prv.key.dhPrv.data = tmpPrv;
prv.key.dhPrv.len = p->len;
ASSERT_TRUE_AND_LOG("prvKey = p - 1", CRYPT_EAL_PkeySetPrv(pkey, &prv) == CRYPT_DH_KEYINFO_ERROR);
tmpPrv[last] -= 1; // tmpPrv = p - 2, Vectors are guaranteed not to wrap around.
ASSERT_TRUE_AND_LOG("prvKey = p - 2", CRYPT_EAL_PkeySetPrv(pkey, &prv) == CRYPT_SUCCESS);
para.para.dhPara.q = q->x;
para.para.dhPara.qLen = q->len;
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
/* In normal para, p>q does not exceed the threshold. */
ASSERT_TRUE(memcpy_s(tmpPrv, p->len, q->x, q->len) == 0);
prv.key.dhPrv.len = q->len;
ASSERT_TRUE_AND_LOG("prvKey = q", CRYPT_EAL_PkeySetPrv(pkey, &prv) == CRYPT_DH_KEYINFO_ERROR);
last = q->len - 1;
tmpPrv[last] -= 1;
ASSERT_TRUE_AND_LOG("prvKey = q - 1", CRYPT_EAL_PkeySetPrv(pkey, &prv) == CRYPT_SUCCESS);
(void)memset_s(tmpPrv, p->len, 0, p->len);
ASSERT_TRUE_AND_LOG("prvKey = 0", CRYPT_EAL_PkeySetPrv(pkey, &prv) == CRYPT_DH_KEYINFO_ERROR);
last = q->len - 1;
tmpPrv[last] = 1;
ASSERT_TRUE_AND_LOG("prvKey = 1", CRYPT_EAL_PkeySetPrv(pkey, &prv) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
if (tmpPrv != NULL) {
free(tmpPrv);
}
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_SET_PUB_API_TC001
* @title DH CRYPT_EAL_PkeySetPub: Invalid parameter(NULL).
* @precon Registering memory-related functions.
* Public key.
* @brief
* 1. Create the context(pkey) of the dh algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeySetPub method:
* (1) pkey = null, expected result 2
* (2) pubKey = null, expected result 2
* (3) pubKeyLen = 0, expected result 2
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_NULL_INPUT
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_SET_PUB_API_TC001(Hex *pubKey, int isProvider)
{
CRYPT_EAL_PkeyPub pub = {0};
Set_DH_Pub(&pub, pubKey->x, pubKey->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(NULL, &pub) == CRYPT_NULL_INPUT);
pub.key.dhPub.data = NULL;
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey, &pub) == CRYPT_NULL_INPUT);
pub.key.dhPub.data = pubKey->x;
pub.key.dhPub.len = 0;
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey, &pub) == CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_SET_PUB_API_TC002
* @title DH CRYPT_EAL_PkeySetPub: Invalid parameter(Overlong public key).
* @precon Registering memory-related functions.
* @brief
* 1. Create the context(pkey) of the dh algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeySetPub method:
* (1) pub array Len > 8192, actual Len > 8192, expected result 2
* (2) pub array Len > 8192, actual Len < 8192, expected result 2
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_DH_KEYINFO_ERROR
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_SET_PUB_API_TC002(int isProvider)
{
uint8_t pubKey[1025] = {0}; // 8192/8 + 1 = 1025
uint32_t pubLen = sizeof(pubKey);
pubKey[0] = 1;
pubKey[1024] = 5; // 1024 is last block
CRYPT_EAL_PkeyPub pub = {0};
Set_DH_Pub(&pub, pubKey, pubLen);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey, &pub) == CRYPT_DH_KEYINFO_ERROR);
pubKey[0] = 0;
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey, &pub) == CRYPT_DH_KEYINFO_ERROR);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_GET_PRV_API_TC001
* @title DH CRYPT_EAL_PkeyGetPrv: Invalid parameter.
* @precon Registering memory-related functions.
* DH parameters and private key.
* @brief
* 1. Create the context(pkey) of the dh algorithm, expected result 1.
* 2. Set para, expected result 2
* 3. Call the CRYPT_EAL_PkeyGetPrv method: all parameters are valid, expected result 3
* 4. Call the CRYPT_EAL_PkeySetPrv method: all parameters are valid, expected result 4
* 5. Call the CRYPT_EAL_PkeyGetPrv method: prv.data=NULL, expected result 5
* 6. Call the CRYPT_EAL_PkeyGetPrv method: prv.len < prvKeyLen, expected result 6
* 7. Compare the setted public key with the obtained public key, expected result 7
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_DH_KEYINFO_ERROR
* 4. CRYPT_SUCCESS
* 5. CRYPT_NULL_INPUT
* 6. CRYPT_DH_BUFF_LEN_NOT_ENOUGH
* 7. The two private keys are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_GET_PRV_API_TC001(Hex *p, Hex *g, Hex *q, Hex *prvKey, int isProvider)
{
uint8_t output[1030];
uint32_t outLen = sizeof(output);
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPrv prv = {0};
Set_DH_Para(¶, p->x, q->x, g->x, p->len, q->len, g->len);
Set_DH_Prv(&prv, output, outLen);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prv) == CRYPT_DH_KEYINFO_ERROR);
prv.key.dhPrv.data = prvKey->x;
prv.key.dhPrv.len = prvKey->len;
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey, &prv) == CRYPT_SUCCESS);
prv.key.dhPrv.data = NULL;
prv.key.dhPrv.len = outLen;
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prv) == CRYPT_NULL_INPUT);
prv.key.dhPrv.data = output;
prv.key.dhPrv.len = prvKey->len - 1;
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prv) == CRYPT_DH_BUFF_LEN_NOT_ENOUGH);
prv.key.dhPrv.len = p->len > q->len ? p->len : q->len;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prv), CRYPT_SUCCESS);
ASSERT_TRUE(prv.key.dhPrv.len == prvKey->len);
ASSERT_TRUE(memcmp(output, prvKey->x, prvKey->len) == 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_GET_PUB_API_TC001
* @title DH CRYPT_EAL_PkeyGetPub: Invalid parameter.
* @precon Registering memory-related functions.
* Public key.
* @brief
* 1. Create the context(pkey) of the dh algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeyGetPub method: all parameters are valid, expected result 2
* 3. Call the CRYPT_EAL_PkeySetPub method: all parameters are valid, expected result 3
* 4. Call the CRYPT_EAL_PkeyGetPub method: pub.data=NULL, expected result 4
* 5. Call the CRYPT_EAL_PkeyGetPub method: pub.len < pubKeyLen, expected result 5
* 6. Compare the setted public key with the obtained public key, expected result 6.
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_DH_KEYINFO_ERROR
* 3. CRYPT_SUCCESS
* 4. CRYPT_NULL_INPUT
* 5. CRYPT_DH_BUFF_LEN_NOT_ENOUGH
* 6. The two public keys are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_GET_PUB_API_TC001(Hex *p, Hex *g, Hex *q, Hex *pubKey, int isProvider)
{
uint8_t output[1030];
uint32_t outLen = sizeof(output);
CRYPT_EAL_PkeyPub pub = {0};
CRYPT_EAL_PkeyPara para = {0};
Set_DH_Pub(&pub, output, outLen);
Set_DH_Para(¶, p->x, q->x, g->x, p->len, q->len, g->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pub) == CRYPT_DH_PARA_ERROR);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pub) == CRYPT_DH_KEYINFO_ERROR);
pub.key.dhPub.data = pubKey->x;
pub.key.dhPub.len = pubKey->len;
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey, &pub) == CRYPT_SUCCESS);
pub.key.dhPub.data = NULL;
pub.key.dhPub.len = outLen;
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pub) == CRYPT_NULL_INPUT);
pub.key.dhPub.data = output;
pub.key.dhPub.len = pubKey->len - 1;
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pub) == CRYPT_DH_BUFF_LEN_NOT_ENOUGH);
pub.key.dhPub.len = pubKey->len;
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(pub.key.dhPub.len == pubKey->len);
ASSERT_TRUE(memcmp(output, pubKey->x, pubKey->len) == 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_GET_KEY_LEN_API_TC001
* @title CRYPT_EAL_PkeyGetKeyLen test.
* @precon Registering memory-related functions.
* DH parameters.
* @brief
* 1. Create the context(pkey) of the dh algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeyGetKeyLen, expected result 2
* 3. Set para, expected result 3
* 4. Call the CRYPT_EAL_PkeyGetKeyLen, expected result 4
* @expect
* 1. Success, and context is not NULL.
* 2. 0 is returned because the parameter is not set.
* 3. CRYPT_SUCCESS
* 4. The obtained length is equal to p->len.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_GET_KEY_LEN_API_TC001(Hex *p, Hex *g, Hex *q, int isProvider)
{
CRYPT_EAL_PkeyPara para = {0};
Set_DH_Para(¶, p->x, q->x, g->x, p->len, q->len, g->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyGetKeyLen(pkey), 0);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetKeyLen(pkey), p->len);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_GEN_API_TC001
* @title DH CRYPT_EAL_PkeyGen test.
* @precon Registering memory-related functions.
* DH parameters.
* @brief
* 1. Create the context(pkey) of the dh algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeyGen method: pkey = NULL, expected result 2
* 3. Call the CRYPT_EAL_PkeyGen method: pkey != NULL, expected result 3
* 4. Set para, expected result 4
* 5. Call the CRYPT_EAL_PkeyGen method: pkey != NULL, expected result 5
* 6. Initializes the random number, expected result 6
* 7. Call the CRYPT_EAL_PkeyGen method: pkey != NULL, expected result 6
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_NULL_INPUT
* 3. CRYPT_DH_PARA_ERROR
* 4. CRYPT_SUCCESS
* 5. CRYPT_NO_REGIST_RAND
* 6. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_GEN_API_TC001(Hex *p, Hex *g, Hex *q)
{
CRYPT_EAL_PkeyPara para = {0};
Set_DH_Para(¶, p->x, q->x, g->x, p->len, q->len, g->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_DH);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(NULL) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_DH_PARA_ERROR);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_NO_REGIST_RAND);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_SET_PARA_BY_ID_API_TC001
* @title DH CRYPT_EAL_PkeySetParaById test: invalid pkey or wrong ID.
* @precon Registering memory-related functions.
* @brief
* 1. Create the context(pkey) of the dh algorithm, expected result 1
* 2. Call the PkeySetParaById method: pkey = NULL, expected result 2
* 3. Call the PkeySetParaById method: invalid id, expected result 3
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_NULL_INPUT
* 3. CRYPT_EAL_ERR_NEW_PARA_FAIL
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_SET_PARA_BY_ID_API_TC001(int isProvider)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetParaById(NULL, CRYPT_DH_RFC3526_2048) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeySetParaById(pkey, 100) == CRYPT_EAL_ERR_NEW_PARA_FAIL);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_EXCH_API_TC001
* @title DH CRYPT_EAL_PkeyComputeShareKey test: Invalid parameter(NULL).
* @precon Registering memory-related functions.
* DH vectors.
* @brief
* 1. Create two contexts(pkey1, pkey2) of the dh algorithm, expected result 1
* 2. Set the correct public key for pkey2, expected result 2
* 3. Call the CRYPT_EAL_PkeyComputeShareKey method, expected result 3
* 4. Set the correct para and private key for pkey1, expected result 4
* 5. Call the CRYPT_EAL_PkeyComputeShareKey method: pkey=null, expected result 5
* 6. Call the CRYPT_EAL_PkeyComputeShareKey method: pubKey=null, expected result 5
* 7. Call the CRYPT_EAL_PkeyComputeShareKey method: share=null, expected result 5
* 8. Call the CRYPT_EAL_PkeyComputeShareKey method: shareLen=null, expected result 5
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_DH_PARA_ERROR
* 4. CRYPT_SUCCESS
* 5. CRYPT_NULL_INPUT
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_EXCH_API_TC001(Hex *p, Hex *g, Hex *q, Hex *pubKey, Hex *prvKey, int isProvider)
{
uint8_t share[1030];
uint32_t shareLen = sizeof(share);
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
Set_DH_Para(¶, p->x, q->x, g->x, p->len, q->len, g->len);
Set_DH_Prv(&prv, prvKey->x, prvKey->len);
Set_DH_Pub(&pub, pubKey->x, pubKey->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey1 != NULL && pkey2 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey2, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, share, &shareLen) == CRYPT_DH_PARA_ERROR);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey1, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey1, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(NULL, pkey2, share, &shareLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey1, NULL, share, &shareLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, NULL, &shareLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, (uint8_t *)share, NULL) == CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_EXCH_API_TC002
* @title DH CRYPT_EAL_PkeyComputeShareKey test: Invalid parameter(The public key or private key is missing).
* @precon Registering memory-related functions.
* DH vectors.
* @brief
* 1. Create the contexts of the dh algorithm, expected result 1.
* 2. Set the correct para, expected result 2
* 3. Call the CRYPT_EAL_PkeyComputeShareKey method: no private key, expected result 3
* 4. Call the CRYPT_EAL_PkeyComputeShareKey method: no public key, expected result 4
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_DH_KEYINFO_ERROR
* 4. CRYPT_DH_KEYINFO_ERROR
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_EXCH_API_TC002(Hex *p, Hex *g, Hex *q, Hex *pubKey, Hex *prvKey, int isProvider)
{
uint8_t share[1030];
uint32_t shareLen = sizeof(share);
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
Set_DH_Para(¶, p->x, q->x, g->x, p->len, q->len, g->len);
Set_DH_Prv(&prv, prvKey->x, prvKey->len);
Set_DH_Pub(&pub, pubKey->x, pubKey->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pkey3 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey1 != NULL && pkey2 != NULL && pkey3 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey1, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey3, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey1, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, share, &shareLen) == CRYPT_DH_KEYINFO_ERROR);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey2, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey3, pkey2, share, &shareLen) == CRYPT_DH_KEYINFO_ERROR);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
CRYPT_EAL_PkeyFreeCtx(pkey3);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_EXCH_API_TC003
* @title DH CRYPT_EAL_PkeyComputeShareKey test: Invalid parameter(The length of the output parameter is insufficient).
* @precon Registering memory-related functions.
* DH vectors.
* @brief
* 1. Create the contexts of the dh algorithm, expected result 1.
* 2. Set the correct para and keys, expected result 2
* 3. Call the CRYPT_EAL_PkeyComputeShareKey method: shareLen=keyLen-1, expected result 3
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_DH_BUFF_LEN_NOT_ENOUGH
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_EXCH_API_TC003(Hex *p, Hex *g, Hex *q, Hex *pubKey, Hex *prvKey, int isProvider)
{
uint8_t share[1030];
uint32_t shareLen;
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
Set_DH_Para(¶, p->x, q->x, g->x, p->len, q->len, g->len);
Set_DH_Prv(&prv, prvKey->x, prvKey->len);
Set_DH_Pub(&pub, pubKey->x, pubKey->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey1 != NULL && pkey2 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey1, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey1, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey2, &pub) == CRYPT_SUCCESS);
shareLen = CRYPT_EAL_PkeyGetKeyLen(pkey1) - 1;
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, (uint8_t *)share, &shareLen), CRYPT_DH_BUFF_LEN_NOT_ENOUGH);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_GET_PARA_API_TC001
* @title DH CRYPT_EAL_PkeyGetPara test.
* @precon Registering memory-related functions.
* DH parameters.
* @brief
* 1. Create the contexts of the dh algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeySetPara method with correct parameters, expected result 2
* 3. Call the CRYPT_EAL_PkeySetPara method: para.id != pkey.id, expected result 3
* 4. Call the CRYPT_EAL_PkeySetPara method: pkey=NULL or para=NULL, expected result 4
* 5. Call the CRYPT_EAL_PkeySetPara method with correct parameters, expected result 5
* 6. Check whether the configured parameters are the same as the obtained parameters, expected result 6
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_EAL_ERR_ALGID
* 4. CRYPT_NULL_INPUT
* 5. CRYPT_SUCCESS
* 6. Parameters are equal.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_GET_PARA_API_TC001(Hex *p, Hex *q, Hex *g, int isProvider)
{
uint8_t buf_p[1030] = {0};
uint32_t bufLen = sizeof(buf_p);
uint8_t buf_q[1030] = {0};
uint8_t buf_g[1030] = {0};
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPara para2 = {0};
Set_DH_Para(¶, p->x, q->x, g->x, p->len, q->len, g->len);
Set_DH_Para(¶2, buf_p, buf_q, buf_g, bufLen, bufLen, bufLen);
para2.id = CRYPT_PKEY_RSA;
TestMemInit();
CRYPT_EAL_PkeyCtx *pKey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pKey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pKey, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPara(pKey, ¶2) == CRYPT_EAL_ERR_ALGID);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPara(NULL, ¶2) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPara(pKey, NULL) == CRYPT_NULL_INPUT);
para2.id = CRYPT_PKEY_DH;
ASSERT_TRUE(CRYPT_EAL_PkeyGetPara(pKey, ¶2) == CRYPT_SUCCESS);
ASSERT_TRUE(para.para.dhPara.pLen == para2.para.dhPara.pLen);
ASSERT_TRUE(memcmp(para.para.dhPara.p, para2.para.dhPara.p, para.para.dhPara.pLen) == 0);
ASSERT_TRUE(para.para.dhPara.qLen == para2.para.dhPara.qLen);
ASSERT_TRUE(memcmp(para.para.dhPara.q, para2.para.dhPara.q, para.para.dhPara.qLen) == 0);
ASSERT_TRUE(para.para.dhPara.gLen == para2.para.dhPara.gLen);
ASSERT_TRUE(memcmp(para.para.dhPara.g, para2.para.dhPara.g, para.para.dhPara.gLen) == 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pKey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_CMP_API_TC001
* @title DH: CRYPT_EAL_PkeyCmp invalid parameter test.
* @precon Registering memory-related functions.
* para id and public key.
* @brief
* 1. Create the contexts(ctx1, ctx2) of the dh algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 2
* 3. Set public key for ctx1, expected result 3
* 4. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 4
* 5. Set public key for ctx2, expected result 5
* 6. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 6
* @expect
* 1. Success, and contexts are not NULL.
* 2. CRYPT_ECC_KEY_PUBKEY_NOT_EQUAL
* 3. CRYPT_SUCCESS
* 4. CRYPT_ECC_KEY_PUBKEY_NOT_EQUAL
* 5-6. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_CMP_API_TC001(int paraId, Hex *pubKey, int isProvider)
{
CRYPT_EAL_PkeyPub pub = {0};
Set_DH_Pub(&pub, pubKey->x, pubKey->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *ctx2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx1 != NULL && ctx2 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_DH_KEYINFO_ERROR); // no key and no para
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx1, paraId), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx1, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_DH_KEYINFO_ERROR); // ctx2 no pubkey
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx2, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_DH_PARA_ERROR); // ctx2 no para
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_CTRL_API_TC001
* @title DH: CRYPT_EAL_PkeyCtrl test.
* @precon Registering memory-related functions.
* @brief
* 1. Create the context(ctx) of the dh algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyCtrl method:
* (1) val = NULL, expected result 2
* (2) len = 0, expected result 3
* (3) opt = CRYPT_CTRL_SET_RSA_PADDING, expected result 4
* @expect
* 1. Success, and contexts are not NULL.
* 2. CRYPT_NULL_INPUT
* 3. CRYPT_DH_UNSUPPORTED_CTRL_OPTION
* 4. CRYPT_DH_UNSUPPORTED_CTRL_OPTION
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_CTRL_API_TC001(int isProvider)
{
int32_t ref = 1;
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_UP_REFERENCES, NULL, sizeof(uint32_t)), CRYPT_INVALID_ARG);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_UP_REFERENCES, &ref, 0), CRYPT_INVALID_ARG);
ASSERT_EQ(
CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_RSA_PADDING, &ref, sizeof(int32_t)), CRYPT_DH_UNSUPPORTED_CTRL_OPTION);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_DUP_CTX_FUNC_TC001
* @title DH: CRYPT_EAL_PkeyDupCtx test.
* @precon Registering memory-related functions.
* @brief
* 1. Create the context of the dh algorithm, expected result 1.
* 2. Init the drbg, expected result 2.
* 3. Set para by CRYPT_DH_RFC7919_8192 and, generate a key pair, expected result 3.
* 4. Call the CRYPT_EAL_PkeyDupCtx method to dup dh context, expected result 4.
* 5. Call the CRYPT_EAL_PkeyCmp method to compare public key, expected result 5.
* 6. Call the CRYPT_EAL_PkeyGetKeyBits to get keyLen from contexts, expected result 6.
* 7. Call the CRYPT_EAL_PkeyGetPub method to obtain the public key from the contexts, expected result 7.
* 8. Compare public keys, expected result 8.
* 9. Get para id from dupCtx, expected result 9.
* @expect
* 1. Success, and context is not NULL.
* 2-5. CRYPT_SUCCESS
* 6. The key length obtained from both contexts is the same.
* 7. CRYPT_SUCCESS
* 8. The two public keys are the same.
* 9. Para id is CRYPT_DH_RFC7919_8192.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_DUP_CTX_FUNC_TC001(int isProvider)
{
uint8_t *pubKey1 = NULL;
uint8_t *pubKey2 = NULL;
uint32_t keyLen1;
uint32_t keyLen2;
CRYPT_PKEY_ParaId paraId = CRYPT_DH_RFC7919_8192;
CRYPT_EAL_PkeyPub pub = {0};
CRYPT_EAL_PkeyCtx *ctx = NULL;
CRYPT_EAL_PkeyCtx *dupCtx = NULL;
TestMemInit();
ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx, paraId), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx), CRYPT_SUCCESS);
dupCtx = CRYPT_EAL_PkeyDupCtx(ctx);
ASSERT_TRUE(dupCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx, dupCtx), CRYPT_SUCCESS);
keyLen1 = CRYPT_EAL_PkeyGetKeyBits(ctx);
keyLen2 = CRYPT_EAL_PkeyGetKeyBits(dupCtx);
ASSERT_EQ(keyLen1, keyLen2);
pubKey1 = calloc(1u, keyLen1);
pubKey2 = calloc(1u, keyLen2);
ASSERT_TRUE(pubKey1 != NULL && pubKey2 != NULL);
Set_DH_Pub(&pub, pubKey1, keyLen1);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctx, &pub), CRYPT_SUCCESS);
Set_DH_Pub(&pub, pubKey2, keyLen2);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(dupCtx, &pub), CRYPT_SUCCESS);
ASSERT_COMPARE("Compare dup key", pubKey1, keyLen1, pubKey2, keyLen2);
ASSERT_TRUE(CRYPT_EAL_PkeyGetParaId(dupCtx) == paraId);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_EAL_PkeyFreeCtx(dupCtx);
BSL_SAL_Free(pubKey1);
BSL_SAL_Free(pubKey2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_GET_KEY_BITS_FUNC_TC001
* @title DH: get key bits.
* @brief
* 1. Create a context of the DH algorithm, expected result 1
* 2. Get key bits, expected result 2
* @expect
* 1. Success, and context is not NULL.
* 2. Equal to keyBits.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_GET_KEY_BITS_FUNC_TC001(int id, int keyBits, Hex *p, Hex *g, Hex *q, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, id,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
CRYPT_EAL_PkeyPara para;
para.id = id;
para.para.dhPara.p = p->x;
para.para.dhPara.pLen = p->len;
para.para.dhPara.q = q->x;
para.para.dhPara.qLen = q->len;
para.para.dhPara.g = g->x;
para.para.dhPara.gLen = g->len;
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetKeyBits(pkey) == (uint32_t)keyBits);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_TEST_FLAG_SET_TC002
* @title for test dh flag setting no leading flag.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_TEST_FLAG_SET_TC001(Hex *p, Hex *g, Hex *q, Hex *prv1, Hex *pub2, Hex *share, int isProvider)
{
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
uint8_t shareLocal[1030];
uint32_t shareLen = sizeof(shareLocal);
uint32_t flag = CRYPT_DH_NO_PADZERO;
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
Set_DH_Para(¶, p->x, q->x, g->x, p->len, q->len, g->len);
Set_DH_Prv(&prv, prv1->x, prv1->len);
Set_DH_Pub(&pub, pub2->x, pub2->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey1 != NULL && pkey2 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey1, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey1, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey2, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey1, CRYPT_CTRL_SET_DH_FLAG, (void *)&flag, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(pkey1, pkey2, shareLocal, &shareLen) == CRYPT_SUCCESS);
ASSERT_TRUE(shareLen == share->len - 1); // The highest bit of this vector is 0
ASSERT_TRUE(memcmp(shareLocal, share->x + 1, shareLen) == 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_CHECK_KEYPAIR_TC001
* @brief
* Create a dh key pairs to check the key pair consistency.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_CHECK_KEYPAIR_TC001(Hex *p, Hex *g, Hex *q, int isProvider)
{
#if !defined(HITLS_CRYPTO_DH_CHECK)
(void)p;
(void)g;
(void)q;
(void)isProvider;
SKIP_TEST();
#else
CRYPT_EAL_PkeyPara para = {0};
Set_DH_Para(¶, p->x, q->x, g->x, p->len, q->len, g->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(pkey, pkey) == CRYPT_SUCCESS);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_CHECK_KEYPAIR_TC002
* @brief
* Create a dh key pairs to check the key pair consistency.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_CHECK_KEYPAIR_TC002(int id, int isProvider)
{
#if !defined(HITLS_CRYPTO_DH_CHECK)
(void)id;
(void)isProvider;
SKIP_TEST();
#else
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetParaById(pkey, id) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(pkey, pkey) == CRYPT_SUCCESS);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_CHECK_KEYPAIR_INVALIED_TC001
* @brief
* Create a dh key pairs to check the key pair consistency.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_CHECK_KEYPAIR_INVALIED_TC001(Hex *p, Hex *g, Hex *q, int isProvider)
{
#if !defined(HITLS_CRYPTO_DH_CHECK)
(void)p;
(void)g;
(void)q;
(void)isProvider;
SKIP_TEST();
#else
TestMemInit();
uint8_t pubKey[1030];
uint32_t pubKeyLen = sizeof(pubKey);
uint8_t prvKey[1030];
uint32_t prvKeyLen = sizeof(prvKey);
CRYPT_EAL_PkeyPub pub = {0};
CRYPT_EAL_PkeyPrv prv = {0};
Set_DH_Pub(&pub, pubKey, pubKeyLen);
Set_DH_Prv(&prv, prvKey, prvKeyLen);
CRYPT_EAL_PkeyPara para = {0};
Set_DH_Para(¶, p->x, q->x, g->x, p->len, q->len, g->len);
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pubCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *prvCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(prvCtx != NULL);
ASSERT_TRUE(pubCtx != NULL);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pubCtx, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(prvCtx, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS); // get prv and pub
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(NULL, NULL) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pubCtx, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx) == CRYPT_NULL_INPUT); // no prv key
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(prvCtx, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pubCtx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx) == CRYPT_DH_PAIRWISE_CHECK_FAIL);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(pubCtx);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DH_CHECK_PRV_TC001
* @brief
* Create a dh key pairs to check the prv key.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DH_CHECK_PRV_TC001(Hex *p, Hex *g, Hex *q, int isProvider)
{
#if !defined(HITLS_CRYPTO_DH_CHECK)
(void)p;
(void)g;
(void)q;
(void)isProvider;
SKIP_TEST();
#else
TestMemInit();
int32_t bits;
CRYPT_EAL_PkeyPara para = {0};
Set_DH_Para(¶, p->x, q->x, g->x, p->len, q->len, g->len);
BN_BigNum *x = NULL;
CRYPT_DH_Ctx *ctx = NULL;
BN_BigNum *maxValue = NULL;
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS); // get prv and pub
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SUCCESS);
ctx = (CRYPT_DH_Ctx *)pkey->key;
x = ctx->x;
if (q->len != 0) {
ctx->x = ctx->para->q;
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_DH_INVALID_PRVKEY);
} else {
maxValue = BN_Create(0);
bits = BN_Bits(ctx->para->p);
ASSERT_EQ(BN_SetLimb(maxValue, 1), CRYPT_SUCCESS);
BN_Lshift(maxValue, maxValue, bits);
ctx->x = maxValue;
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_DH_INVALID_PRVKEY);
}
ctx->x = x;
EXIT:
BN_Destroy(maxValue);
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
#endif
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/dh/test_suite_sdv_eal_dh.c | C | unknown | 68,146 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
#include <pthread.h>
#include "crypt_eal_init.h"
#include "securec.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "crypt_algid.h"
#include "crypt_types.h"
#include "crypt_eal_rand.h"
#include "crypt_eal_implprovider.h"
#include "drbg_local.h"
#include "eal_md_local.h"
#include "crypt_drbg_local.h"
#include "bsl_err_internal.h"
#include "bsl_err.h"
#include "bsl_params.h"
#include "crypt_params_key.h"
#include "crypt_provider.h"
/* END_HEADER */
#define CTR_AES128_SEEDLEN (32)
#define AES_BLOCK_LEN (16)
#define TEST_DRBG_DATA_SIZE (256)
#define DRBG_OUTPUT_SIZE (1024)
#define DRBG_MAX_OUTPUT_SIZE (65536)
#define DRBG_MAX_ADIN_SIZE (65536)
typedef struct {
bool entropyState;
bool nonceState;
} CallBackCtl_t;
typedef enum {
RAND_AES128_KEYLEN = 16,
RAND_AES192_KEYLEN = 24,
RAND_AES256_KEYLEN = 32,
} RAND_AES_KeyLen;
CallBackCtl_t g_callBackCtl = { 0 };
typedef struct {
CRYPT_Data *entropy;
CRYPT_Data *nonce;
CRYPT_Data *pers;
CRYPT_Data *addin1;
CRYPT_Data *entropyPR1;
CRYPT_Data *addin2;
CRYPT_Data *entropyPR2;
CRYPT_Data *retBits;
} DRBG_Vec_t;
#define DRBG_FREE(ptr) \
do { \
if ((ptr) != NULL) { \
free(ptr); \
} \
} while (0)
static int32_t PthreadRWLockNew(BSL_SAL_ThreadLockHandle *lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
pthread_rwlock_t *newLock;
newLock = (pthread_rwlock_t *)malloc(sizeof(pthread_rwlock_t));
if (newLock == NULL) {
return BSL_MALLOC_FAIL;
}
if (pthread_rwlock_init(newLock, NULL) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
*lock = newLock;
return BSL_SUCCESS;
}
static void PthreadRWLockFree(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return;
}
pthread_rwlock_destroy((pthread_rwlock_t *)lock);
DRBG_FREE(lock);
}
static int32_t PthreadRWLockReadLock(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
if (pthread_rwlock_rdlock((pthread_rwlock_t *)lock) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
return BSL_SUCCESS;
}
static int32_t PthreadRWLockWriteLock(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
if (pthread_rwlock_wrlock((pthread_rwlock_t *)lock) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
return BSL_SUCCESS;
}
static int32_t PthreadRWLockUnlock(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
if (pthread_rwlock_unlock((pthread_rwlock_t *)lock) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
return BSL_SUCCESS;
}
static uint64_t PthreadGetId(void)
{
return (uint64_t)pthread_self();
}
static void RegThreadFunc(void)
{
BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_NEW_CB_FUNC, PthreadRWLockNew);
BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_FREE_CB_FUNC, PthreadRWLockFree);
BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_READ_LOCK_CB_FUNC, PthreadRWLockReadLock);
BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_WRITE_LOCK_CB_FUNC, PthreadRWLockWriteLock);
BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_UNLOCK_CB_FUNC, PthreadRWLockUnlock);
BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_GET_ID_CB_FUNC, PthreadGetId);
}
static void seedCtxFree(DRBG_Vec_t *seedCtx)
{
if (seedCtx != NULL) {
DRBG_FREE(seedCtx->entropy);
DRBG_FREE(seedCtx->entropyPR1);
DRBG_FREE(seedCtx->entropyPR2);
DRBG_FREE(seedCtx->addin1);
DRBG_FREE(seedCtx->addin2);
DRBG_FREE(seedCtx->nonce);
DRBG_FREE(seedCtx->retBits);
DRBG_FREE(seedCtx->pers);
}
free(seedCtx);
}
static DRBG_Vec_t *seedCtxMem(void)
{
DRBG_Vec_t *seedCtx;
seedCtx = calloc(1u, sizeof(DRBG_Vec_t));
ASSERT_TRUE(seedCtx != NULL);
seedCtx->entropy = calloc(1u, sizeof(CRYPT_Data));
ASSERT_TRUE(seedCtx->entropy != NULL);
seedCtx->entropyPR1 = calloc(1u, sizeof(CRYPT_Data));
ASSERT_TRUE(seedCtx->entropyPR1 != NULL);
seedCtx->entropyPR2 = calloc(1u, sizeof(CRYPT_Data));
ASSERT_TRUE(seedCtx->entropyPR2 != NULL);
seedCtx->addin1 = calloc(1u, sizeof(CRYPT_Data));
ASSERT_TRUE(seedCtx->addin1 != NULL);
seedCtx->addin2 = calloc(1u, sizeof(CRYPT_Data));
ASSERT_TRUE(seedCtx->addin2 != NULL);
seedCtx->nonce = calloc(1u, sizeof(CRYPT_Data));
ASSERT_TRUE(seedCtx->nonce != NULL);
seedCtx->retBits = calloc(1u, sizeof(CRYPT_Data));
ASSERT_TRUE(seedCtx->retBits != NULL);
seedCtx->pers = calloc(1u, sizeof(CRYPT_Data));
ASSERT_TRUE(seedCtx->pers != NULL);
return seedCtx;
EXIT:
seedCtxFree(seedCtx);
return NULL;
}
/* Initializes the drbg context seed. Internally, ensure that the parameters are correct. */
static void seedCtxCfg(DRBG_Vec_t *seedCtx, Hex *entropy, Hex *nonce, Hex *pers, Hex *addin1, Hex *entropyPR1,
Hex *addin2, Hex *entropyPR2, Hex *retBits)
{
seedCtx->entropy->data = entropy->x;
seedCtx->entropy->len = entropy->len;
seedCtx->nonce->data = nonce->x;
seedCtx->nonce->len = nonce->len;
seedCtx->pers->data = pers->x;
seedCtx->pers->len = pers->len;
seedCtx->addin1->data = addin1->x;
seedCtx->addin1->len = addin1->len;
seedCtx->entropyPR1->data = entropyPR1->x;
seedCtx->entropyPR1->len = entropyPR1->len;
seedCtx->addin2->data = addin2->x;
seedCtx->addin2->len = addin2->len;
seedCtx->entropyPR2->data = entropyPR2->x;
seedCtx->entropyPR2->len = entropyPR2->len;
seedCtx->retBits->data = retBits->x;
seedCtx->retBits->len = retBits->len;
}
static int32_t getEntropyError(void *ctx, CRYPT_Data *entropy, uint32_t strength, CRYPT_Range *lenRange)
{
(void)strength;
(void)lenRange;
CallBackCtl_t *state = (CallBackCtl_t *)ctx;
if (state->entropyState != 0) {
entropy = NULL;
return CRYPT_DRBG_FAIL_GET_ENTROPY;
}
uint32_t entroyLen = sizeof(uint8_t) * TEST_DRBG_DATA_SIZE;
entropy->data = calloc(1u, entroyLen);
entropy->len = entroyLen;
return CRYPT_SUCCESS;
}
static void cleanEntropyError(void *ctx, CRYPT_Data *entropy)
{
(void)ctx;
if (entropy != NULL && entropy->data != NULL) {
free(entropy->data);
}
return;
}
static int32_t getNonceError(void *ctx, CRYPT_Data *nonce, uint32_t strength, CRYPT_Range *lenRange)
{
(void)strength;
(void)lenRange;
CallBackCtl_t *state = (CallBackCtl_t *)ctx;
if (state->nonceState != 0) {
nonce = NULL;
return CRYPT_DRBG_FAIL_GET_NONCE;
}
uint32_t nonceLen = sizeof(uint8_t) * TEST_DRBG_DATA_SIZE;
nonce->data = calloc(1u, nonceLen);
nonce->len = nonceLen;
return CRYPT_SUCCESS;
}
static void cleanNonceError(void *ctx, CRYPT_Data *nonce)
{
(void)ctx;
if (nonce != NULL && nonce->data != NULL) {
free(nonce->data);
}
return;
}
static int32_t getEntropy(void *ctx, CRYPT_Data *entropy, uint32_t strength, CRYPT_Range *lenRange)
{
(void)strength;
if (ctx == NULL || entropy == NULL || lenRange == NULL) {
return CRYPT_NULL_INPUT;
}
DRBG_Vec_t *seedCtx = (DRBG_Vec_t *)ctx;
if (seedCtx->entropy->len > lenRange->max || seedCtx->entropy->len < lenRange->min) {
return CRYPT_DRBG_INVALID_LEN;
}
entropy->data = seedCtx->entropy->data;
entropy->len = seedCtx->entropy->len;
return CRYPT_SUCCESS;
}
static void cleanEntropy(void *ctx, CRYPT_Data *entropy)
{
if (ctx == NULL || entropy == NULL) {
return;
}
return;
}
static int32_t getNonce(void *ctx, CRYPT_Data *nonce, uint32_t strength, CRYPT_Range *lenRange)
{
(void)strength;
if (ctx == NULL || nonce == NULL || lenRange == NULL) {
return CRYPT_NULL_INPUT;
}
DRBG_Vec_t *seedCtx = (DRBG_Vec_t *)ctx;
if (seedCtx->nonce->len > lenRange->max || seedCtx->nonce->len < lenRange->min) {
return CRYPT_DRBG_INVALID_LEN;
}
nonce->data = seedCtx->nonce->data;
nonce->len = seedCtx->nonce->len;
return CRYPT_SUCCESS;
}
static void cleanNonce(void *ctx, CRYPT_Data *nonce)
{
if (ctx == NULL || nonce == NULL) {
return;
}
return;
}
static int32_t getEntropyUnCheckPara(void *ctx, CRYPT_Data *entropy, uint32_t strength, CRYPT_Range *lenRange)
{
(void)strength;
(void)lenRange;
DRBG_Vec_t *seedCtx = (DRBG_Vec_t *)ctx;
entropy->data = seedCtx->entropy->data;
entropy->len = seedCtx->entropy->len;
return CRYPT_SUCCESS;
}
static int32_t getNonceUnCheckPara(void *ctx, CRYPT_Data *nonce, uint32_t strength, CRYPT_Range *lenRange)
{
(void)strength;
(void)lenRange;
DRBG_Vec_t *seedCtx = (DRBG_Vec_t *)ctx;
nonce->data = seedCtx->nonce->data;
nonce->len = seedCtx->nonce->len;
return CRYPT_SUCCESS;
}
static void regSeedMeth(CRYPT_RandSeedMethod *seedMeth)
{
seedMeth->getEntropy = getEntropy;
seedMeth->cleanEntropy = cleanEntropy;
seedMeth->getNonce = getNonce;
seedMeth->cleanNonce = cleanNonce;
}
static void drbgDataInit(CRYPT_Data *data, uint32_t size)
{
uint8_t *dataTmp = NULL;
if (size != 0) {
dataTmp = malloc(sizeof(uint8_t) * size);
if (dataTmp == NULL) {
return;
}
(void)memset_s(dataTmp, size, 0, size);
}
data->data = dataTmp;
data->len = size;
}
static void drbgDataFree(CRYPT_Data *data)
{
if (data != NULL) {
if (data->data != NULL) {
free(data->data);
}
}
}
/* Mapping between RAND and specific random number generation algorithms */
static const int g_drbgMethodMap[] = {
CRYPT_MD_SHA1,
CRYPT_MD_SHA224,
CRYPT_MD_SHA256,
CRYPT_MD_SHA384,
CRYPT_MD_SHA512,
CRYPT_MD_SM3,
CRYPT_MAC_HMAC_SHA1,
CRYPT_MAC_HMAC_SHA224,
CRYPT_MAC_HMAC_SHA256,
CRYPT_MAC_HMAC_SHA384,
CRYPT_MAC_HMAC_SHA512,
CRYPT_SYM_AES128,
CRYPT_SYM_AES192,
CRYPT_SYM_AES256,
CRYPT_SYM_AES128,
CRYPT_SYM_AES192,
CRYPT_SYM_AES256
};
static uint32_t GetAesKeyLen(int id, uint32_t *keyLen)
{
switch (id) {
case CRYPT_SYM_AES128:
*keyLen = RAND_AES128_KEYLEN;
break;
case CRYPT_SYM_AES192:
*keyLen = RAND_AES192_KEYLEN;
break;
case CRYPT_SYM_AES256:
*keyLen = RAND_AES256_KEYLEN;
break;
default:
return CRYPT_DRBG_ALG_NOT_SUPPORT;
}
return CRYPT_SUCCESS;
}
static void InitSeedCtx(CRYPT_RAND_AlgId id, DRBG_Vec_t *seedCtx, CRYPT_Data *data)
{
if (id < CRYPT_RAND_AES128_CTR || id > CRYPT_RAND_AES256_CTR) {
drbgDataInit(data, TEST_DRBG_DATA_SIZE);
seedCtx->entropy = data;
seedCtx->nonce = data;
} else {
uint32_t keyLen = 0;
GetAesKeyLen(g_drbgMethodMap[id - CRYPT_RAND_SHA1], &keyLen);
drbgDataInit(data, (AES_BLOCK_LEN + keyLen));
seedCtx->entropy = data;
}
return;
}
static int sdvCryptEalRandSeedAdinApiTest(uint8_t *addin, uint32_t addinLen)
{
int ret;
uint8_t *output = NULL;
CRYPT_Data data = { 0 };
CRYPT_RandSeedMethod seedMeth = { 0 };
DRBG_Vec_t seedCtx = { 0 };
TestMemInit();
regSeedMeth(&seedMeth);
drbgDataInit(&data, TEST_DRBG_DATA_SIZE);
seedCtx.entropy = &data;
seedCtx.nonce = &data;
ASSERT_EQ(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, &seedMeth, &seedCtx, NULL, 0), CRYPT_SUCCESS);
output = malloc(sizeof(uint8_t) * DRBG_OUTPUT_SIZE);
ASSERT_TRUE(output != NULL);
(void)memset_s(output, sizeof(uint8_t) * DRBG_OUTPUT_SIZE, 0, sizeof(uint8_t) * DRBG_OUTPUT_SIZE);
ret = CRYPT_EAL_RandbytesWithAdin(output, DRBG_OUTPUT_SIZE, NULL, 0);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_RandSeedWithAdin(addin, addinLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_RandSeed();
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_RandDeinit();
drbgDataFree(&data);
free(output);
return ret;
}
static int sdvCryptEalDrbgSeedAdinApiTest(uint8_t *addin, uint32_t addinLen)
{
int ret;
uint8_t *output = NULL;
CRYPT_Data data = { 0 };
CRYPT_RandSeedMethod seedMeth = { 0 };
DRBG_Vec_t seedCtx = { 0 };
void *drbgCtx = NULL;
TestMemInit();
regSeedMeth(&seedMeth);
drbgDataInit(&data, TEST_DRBG_DATA_SIZE);
seedCtx.entropy = &data;
seedCtx.nonce = &data;
drbgCtx = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA256, &seedMeth, &seedCtx);
ASSERT_TRUE(drbgCtx != NULL);
ASSERT_TRUE(CRYPT_EAL_DrbgInstantiate(drbgCtx, NULL, 0) == CRYPT_SUCCESS);
output = malloc(sizeof(uint8_t) * DRBG_OUTPUT_SIZE);
ASSERT_TRUE(output != NULL);
(void)memset_s(output, sizeof(uint8_t) * DRBG_OUTPUT_SIZE, 0, sizeof(uint8_t) * DRBG_OUTPUT_SIZE);
ret = CRYPT_EAL_DrbgbytesWithAdin(drbgCtx, output, DRBG_OUTPUT_SIZE, NULL, 0);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_DrbgSeedWithAdin(drbgCtx, addin, addinLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_DrbgSeed(drbgCtx);
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_DrbgDeinit(drbgCtx);
drbgDataFree(&data);
free(output);
return ret;
}
static void sdvCryptEalThreadTest(void *drbgCtx)
{
int i = 0;
int ret;
uint8_t *output = NULL;
output = malloc(sizeof(uint8_t) * DRBG_OUTPUT_SIZE);
ASSERT_TRUE(output != NULL);
for (i = 0; i < 100; i++) { // Perform 100 * 2 times random number generation in the thread.
ret = CRYPT_EAL_DrbgbytesWithAdin(drbgCtx, output, sizeof(uint8_t) * DRBG_OUTPUT_SIZE, NULL, 0);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_DrbgSeedWithAdin(drbgCtx, NULL, 0);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_DrbgbytesWithAdin(drbgCtx, output, sizeof(uint8_t) * DRBG_OUTPUT_SIZE, NULL, 0);
ASSERT_EQ(ret, CRYPT_SUCCESS);
}
EXIT:
DRBG_FREE(output);
return;
}
static void sdvCryptGlobalThreadTest(void)
{
int i = 0;
uint8_t *output = NULL;
output = malloc(sizeof(uint8_t) * DRBG_OUTPUT_SIZE);
ASSERT_TRUE(output != NULL);
for (i = 0; i < 100; i++) { // Perform 100 times random number generation in the thread.
ASSERT_EQ(CRYPT_EAL_Randbytes(output, sizeof(uint8_t) * DRBG_OUTPUT_SIZE), CRYPT_SUCCESS);
}
EXIT:
DRBG_FREE(output);
return;
}
/**
* @test SDV_CRYPT_DRBG_RAND_INIT_API_TC001
* @title Use different algorithm ID to initialize the DRBG.
* @precon nan
* @brief
* 1.Initialize the random number seed, expected result 1.
* 2.Call CRYPT_EAL_RandInit, expected result 2.
* 3.Call CRYPT_EAL_DrbgNew, expected result 3.
* @expect
* 1.successful.
* 2.Success with or without a random number seed.
* 3.successful.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_RAND_INIT_API_TC001(int algId)
{
if (IsRandAlgDisabled(algId)) {
SKIP_TEST();
}
void *drbg = NULL;
CRYPT_RandSeedMethod seedMeth = { 0 };
CRYPT_Data data = { 0 };
DRBG_Vec_t seedCtx = { 0 };
TestMemInit();
seedMeth.getEntropy = getEntropy;
seedMeth.cleanEntropy = cleanEntropy;
InitSeedCtx(algId, &seedCtx, &data);
ASSERT_EQ(CRYPT_EAL_RandInit(algId, &seedMeth, (void *)&seedCtx, NULL, 0), CRYPT_SUCCESS);
CRYPT_EAL_RandDeinit();
ASSERT_EQ(CRYPT_EAL_RandInit(algId, NULL, NULL, NULL, 0), CRYPT_SUCCESS);
CRYPT_EAL_RandDeinit();
drbg = CRYPT_EAL_DrbgNew(algId, &seedMeth, &seedCtx);
ASSERT_TRUE(drbg != NULL);
ASSERT_TRUE(CRYPT_EAL_DrbgInstantiate(drbg, NULL, 0) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_RandDeinit();
CRYPT_EAL_DrbgDeinit(drbg);
drbgDataFree(&data);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_RAND_INIT_API_TC002
* @title DRBG initialization test,the value of data is 0 or 255.
* @precon nan
* @brief
* 1.Initialize the random number seed, expected result 1.
* 2.Call CRYPT_EAL_RandInit, expected result 2.
* 3.Call CRYPT_EAL_DrbgNew, expected result 3.
* @expect
* 1.successful.
* 2.successful.
* 3.successful.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_RAND_INIT_API_TC002(int agId, int value, int size)
{
uint8_t *pers = malloc(size);
ASSERT_TRUE(pers != NULL);
ASSERT_EQ(memset_s(pers, size, value, size), 0);
void *drbg = NULL;
CRYPT_RandSeedMethod seedMeth = { 0 };
CRYPT_Data data = { 0 };
DRBG_Vec_t seedCtx = { 0 };
TestMemInit();
regSeedMeth(&seedMeth);
drbgDataInit(&data, size);
seedCtx.entropy = &data;
seedCtx.nonce = &data;
ASSERT_EQ(CRYPT_EAL_RandInit(agId, &seedMeth, (void *)&seedCtx, pers, size), CRYPT_SUCCESS);
CRYPT_EAL_RandDeinit();
drbg = CRYPT_EAL_DrbgNew(agId, &seedMeth, &seedCtx);
ASSERT_TRUE(drbg != NULL);
CRYPT_EAL_DrbgDeinit(drbg);
EXIT:
CRYPT_EAL_RandDeinit();
drbgDataFree(&data);
free(pers);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_RAND_INIT_API_TC003
* @title Test the impact of persLen on DRGB initialization.
* @precon nan
* @brief
* 1.Initialize the random number seed, expected result 1.
* 2.Call CRYPT_EAL_RandInit, expected result 2.
* 3.Call CRYPT_EAL_DrbgNew, expected result 3.
* @expect
* 1.successful.
* 2.successful.
* 3.successful.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_RAND_INIT_API_TC003(int agId, int size)
{
uint8_t *pers = malloc(TEST_DRBG_DATA_SIZE);
ASSERT_TRUE(pers != NULL);
void *drbg = NULL;
CRYPT_RandSeedMethod seedMeth = { 0 };
CRYPT_Data data = { 0 };
DRBG_Vec_t seedCtx = { 0 };
TestMemInit();
regSeedMeth(&seedMeth);
drbgDataInit(&data, size);
seedCtx.entropy = &data;
seedCtx.nonce = &data;
ASSERT_EQ(CRYPT_EAL_RandInit(agId, &seedMeth, (void *)&seedCtx, pers, size), CRYPT_SUCCESS);
CRYPT_EAL_RandDeinit();
drbg = CRYPT_EAL_DrbgNew(agId, &seedMeth, &seedCtx);
ASSERT_TRUE(drbg != NULL);
CRYPT_EAL_DrbgDeinit(drbg);
EXIT:
CRYPT_EAL_RandDeinit();
drbgDataFree(&data);
free(pers);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_RAND_INIT_API_TC004
* @title DRBG is initialized repeatedly.
* @precon nan
* @brief
* 1.Initialize the random number seed, expected result 1.
* 2.Call CRYPT_EAL_RandInit, expected result 2.
* 3.Call CRYPT_EAL_RandInit again, expected result 3.
* @expect
* 1.successful.
* 2.successful.
* 3.return failed.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_RAND_INIT_API_TC004(int algId)
{
CRYPT_Data data = { 0 };
CRYPT_RandSeedMethod seedMeth = { 0 };
DRBG_Vec_t seedCtx = { 0 };
TestMemInit();
regSeedMeth(&seedMeth);
drbgDataInit(&data, TEST_DRBG_DATA_SIZE);
seedCtx.entropy = &data;
seedCtx.nonce = &data;
ASSERT_EQ(CRYPT_EAL_RandInit(algId, &seedMeth, (void *)&seedCtx, NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_RandInit(algId, &seedMeth, (void *)&seedCtx, NULL, 0), CRYPT_EAL_ERR_DRBG_REPEAT_INIT);
EXIT:
CRYPT_EAL_RandDeinit();
drbgDataFree(&data);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_RAND_INIT_API_TC005
* @title DRBG initialization test,the configuration context parameter is empty.
* @precon nan
* @brief
* 1.Initialize the random number seed, expected result 1.
* 2.Call CRYPT_EAL_RandInit, expected result 2.
* 3.Call CRYPT_EAL_DrbgNew, expected result 3.
* @expect
* 1.successful.
* 2.successful.
* 3.return NULL.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_RAND_INIT_API_TC005(int algId)
{
DRBG_Vec_t seedCtx = { 0 };
void *drbg = NULL;
ASSERT_EQ(CRYPT_EAL_RandInit(algId, NULL, NULL, NULL, 0), CRYPT_SUCCESS);
CRYPT_EAL_RandDeinit();
ASSERT_NE(CRYPT_EAL_RandInit(algId, NULL, &seedCtx, NULL, 0), CRYPT_SUCCESS);
drbg = CRYPT_EAL_DrbgNew(algId, NULL, NULL);
ASSERT_TRUE(drbg != NULL);
CRYPT_EAL_DrbgDeinit(drbg);
drbg = CRYPT_EAL_DrbgNew(algId, NULL, &seedCtx);
ASSERT_TRUE(drbg == NULL);
EXIT:
CRYPT_EAL_RandDeinit();
CRYPT_EAL_DrbgDeinit(drbg);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_RAND_INIT_API_TC006
* @title DRBG initialization test,use the abnormal persLen.
* @precon nan
* @brief
* 1.Initialize the random number seed, expected result 1.
* 2.Call CRYPT_EAL_RandInit, expected result 2.
* 3.Call CRYPT_EAL_DrbgNew, expected result 3.
* @expect
* 1.successful.
* 2.return failed.
* 3.return NULL.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_RAND_INIT_API_TC006(int algId, int keyLen)
{
CRYPT_Data data = { 0 };
CRYPT_RandSeedMethod seedMeth = { 0 };
DRBG_Vec_t seedCtx = { 0 };
uint8_t *pers = NULL;
void *drbg = NULL;
pers = malloc(TEST_DRBG_DATA_SIZE + keyLen);
ASSERT_TRUE(pers != NULL);
TestMemInit();
regSeedMeth(&seedMeth);
drbgDataInit(&data, keyLen + 16);
seedCtx.entropy = &data;
seedCtx.nonce = &data;
ASSERT_NE(CRYPT_EAL_RandInit(algId, &seedMeth, (void *)&seedCtx, pers, keyLen + 16 + 1), CRYPT_SUCCESS);
CRYPT_EAL_RandDeinit();
drbg = CRYPT_EAL_DrbgNew(algId, &seedMeth, &seedCtx);
ASSERT_TRUE(drbg != NULL);
ASSERT_NE(CRYPT_EAL_DrbgInstantiate(drbg, pers, keyLen + 16 + 1), CRYPT_SUCCESS);
CRYPT_EAL_DrbgDeinit(drbg);
ASSERT_EQ(CRYPT_EAL_RandInit(algId, &seedMeth, (void *)&seedCtx, pers, keyLen + 16), CRYPT_SUCCESS);
drbg = CRYPT_EAL_DrbgNew(algId, &seedMeth, &seedCtx);
ASSERT_TRUE(drbg != NULL);
EXIT:
CRYPT_EAL_DrbgDeinit(drbg);
CRYPT_EAL_RandDeinit();
free(data.data);
free(pers);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_RAND_SEED_ADIN_API_TC001
* @title When the RAND is initialized and a random number has been generated,
the counter is reset when the random number is obtained from personal data.
* @precon nan
* @brief
* 1.Call sdvCryptEalRandSeedAdinApiTest,addinData is NULL, expected result 1.
* 2.Call sdvCryptEalRandSeedAdinApiTest,addinData not NULL, expected result 2.
* @expect
* 1.All operations succeeded.
* 2.All operations succeeded.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_RAND_SEED_ADIN_API_TC001(void)
{
uint8_t *addinData = NULL;
ASSERT_EQ(sdvCryptEalRandSeedAdinApiTest(NULL, 0), CRYPT_SUCCESS);
addinData = malloc(sizeof(uint8_t) * DRBG_MAX_ADIN_SIZE);
ASSERT_TRUE(addinData != NULL);
ASSERT_EQ(sdvCryptEalRandSeedAdinApiTest(addinData, sizeof(uint8_t) * DRBG_MAX_ADIN_SIZE), CRYPT_SUCCESS);
EXIT:
free(addinData);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_DRBG_SEED_ADIN_API_TC001
* @title When the DRBG is initialized and a random number has been generated,
the counter is reset when the random number is obtained from personal data.
* @precon nan
* @brief
* 1.Call sdvCryptEalDrbgSeedAdinApiTest,addinData is NULL, expected result 1.
* 2.Call sdvCryptEalDrbgSeedAdinApiTest,addinData not NULL, expected result 2.
* @expect
* 1.All operations succeeded.
* 2.All operations succeeded.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_DRBG_SEED_ADIN_API_TC001(void)
{
uint8_t *addinData = NULL;
ASSERT_EQ(sdvCryptEalDrbgSeedAdinApiTest(NULL, 0), CRYPT_SUCCESS);
addinData = malloc(sizeof(uint8_t) * DRBG_MAX_ADIN_SIZE);
ASSERT_TRUE(addinData != NULL);
ASSERT_EQ(sdvCryptEalDrbgSeedAdinApiTest(addinData, sizeof(uint8_t) * DRBG_MAX_ADIN_SIZE), CRYPT_SUCCESS);
EXIT:
free(addinData);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_RAND_SEED_ADIN_API_TC002
* @title Call random interface before CRYPT_EAL_RandInit.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_RandbytesWithAdin, expected result 1.
* 2.Call CRYPT_EAL_Randbytes, expected result 2.
* 3.Call CRYPT_EAL_RandSeedWithAdin, expected result 3.
* 4.Call CRYPT_EAL_RandSeed, expected result 4.
* @expect
* 1.return CRYPT_EAL_ERR_GLOBAL_DRBG_NULL.
* 2.return CRYPT_EAL_ERR_GLOBAL_DRBG_NULL.
* 3.return CRYPT_EAL_ERR_GLOBAL_DRBG_NULL.
* 4.return CRYPT_EAL_ERR_GLOBAL_DRBG_NULL.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_RAND_SEED_ADIN_API_TC002(void)
{
uint8_t data[TEST_DRBG_DATA_SIZE] = {0};
ASSERT_EQ(CRYPT_EAL_RandbytesWithAdin(data, TEST_DRBG_DATA_SIZE, NULL, 0), CRYPT_EAL_ERR_GLOBAL_DRBG_NULL);
ASSERT_EQ(CRYPT_EAL_Randbytes(data, TEST_DRBG_DATA_SIZE), CRYPT_EAL_ERR_GLOBAL_DRBG_NULL);
ASSERT_EQ(CRYPT_EAL_RandSeedWithAdin(NULL, 0), CRYPT_EAL_ERR_GLOBAL_DRBG_NULL);
ASSERT_EQ(CRYPT_EAL_RandSeed(), CRYPT_EAL_ERR_GLOBAL_DRBG_NULL);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_RAND_BYTES_ADIN_ERR_PARA_API_TC001
* @title CRYPT_EAL_RandbytesWithAdin abnormal parameter test.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_DrbgbytesWithAdin,use normal parameters, expected result 1.
* 2.Call CRYPT_EAL_DrbgbytesWithAdin,the array length is abnormal, expected result 2.
* @expect
* 1.All interface succeeded.
* 2.The interface returns an exception.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_RAND_BYTES_ADIN_ERR_PARA_API_TC001(int algId)
{
uint8_t *output = malloc(sizeof(uint8_t) * (DRBG_MAX_OUTPUT_SIZE + 1));
ASSERT_TRUE(output != NULL);
uint8_t *addin = malloc(sizeof(uint8_t) * DRBG_MAX_ADIN_SIZE);
ASSERT_TRUE(addin != NULL);
CRYPT_RandSeedMethod seedMeth = { 0 };
CRYPT_Data data = { 0 };
DRBG_Vec_t seedCtx = { 0 };
regSeedMeth(&seedMeth);
drbgDataInit(&data, TEST_DRBG_DATA_SIZE);
seedCtx.entropy = &data;
seedCtx.nonce = &data;
TestMemInit();
CRYPT_EAL_RndCtx *drbgCtx = CRYPT_EAL_DrbgNew(algId, &seedMeth, &seedCtx);
ASSERT_TRUE(drbgCtx != NULL);
ASSERT_TRUE(CRYPT_EAL_DrbgInstantiate(drbgCtx, NULL, 0) == CRYPT_SUCCESS);
memset_s(addin, DRBG_MAX_ADIN_SIZE, 0, DRBG_MAX_ADIN_SIZE);
ASSERT_EQ(CRYPT_EAL_DrbgbytesWithAdin(drbgCtx, output, DRBG_MAX_OUTPUT_SIZE, addin, DRBG_MAX_ADIN_SIZE),
CRYPT_SUCCESS);
memset_s(addin, DRBG_MAX_ADIN_SIZE, 'F', DRBG_MAX_ADIN_SIZE);
ASSERT_EQ(CRYPT_EAL_DrbgbytesWithAdin(drbgCtx, output, DRBG_MAX_OUTPUT_SIZE, addin, DRBG_MAX_ADIN_SIZE),
CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_DrbgbytesWithAdin(drbgCtx, output, DRBG_MAX_OUTPUT_SIZE, NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_DrbgbytesWithAdin(drbgCtx, output, DRBG_MAX_OUTPUT_SIZE, addin, 0), CRYPT_SUCCESS);
memset_s(addin, DRBG_MAX_ADIN_SIZE, 0, DRBG_MAX_ADIN_SIZE);
ASSERT_NE(CRYPT_EAL_DrbgbytesWithAdin(drbgCtx, output, 0, addin, DRBG_MAX_ADIN_SIZE), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_DrbgbytesWithAdin(drbgCtx, output, DRBG_MAX_OUTPUT_SIZE + 1, addin, DRBG_MAX_ADIN_SIZE),
CRYPT_SUCCESS);
ASSERT_NE(CRYPT_EAL_DrbgbytesWithAdin(drbgCtx, NULL, 0, addin, DRBG_MAX_ADIN_SIZE), CRYPT_SUCCESS);
EXIT:
free(addin);
free(output);
CRYPT_EAL_DrbgDeinit(drbgCtx);
drbgDataFree(&data);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_RAND_BYTES_ERR_PARA_API_TC001
* @title Test the CRYPT_EAL_Randbytes interface for generating random numbers.
* @precon nan
* @brief
* 1.Initialize the random number seed, expected result 1.
* 2.Call CRYPT_EAL_Randbytes,use normal parameters, expected result 2.
* 3.Call CRYPT_EAL_Randbytes,the array length is abnormal, expected result 3.
* @expect
* 1.successful.
* 2.All interface succeeded.
* 3.The interface returns an exception.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_RAND_BYTES_ERR_PARA_API_TC001(void)
{
uint8_t *output = malloc(DRBG_MAX_OUTPUT_SIZE + 1);
ASSERT_TRUE(output != NULL);
CRYPT_RandSeedMethod seedMeth = { 0 };
CRYPT_Data data = { 0 };
DRBG_Vec_t seedCtx = { 0 };
TestMemInit();
regSeedMeth(&seedMeth);
drbgDataInit(&data, TEST_DRBG_DATA_SIZE);
seedCtx.nonce = &data;
seedCtx.entropy = &data;
ASSERT_EQ(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, &seedMeth, (void *)&seedCtx, NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_Randbytes(output, DRBG_OUTPUT_SIZE), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_Randbytes(output, DRBG_MAX_OUTPUT_SIZE), CRYPT_SUCCESS);
ASSERT_NE(CRYPT_EAL_Randbytes(output, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_Randbytes(output, DRBG_MAX_OUTPUT_SIZE + 1), CRYPT_SUCCESS); // MAX SIZE + 1
ASSERT_EQ(CRYPT_EAL_Randbytes(NULL, 0), CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_RandDeinit();
drbgDataFree(&data);
free(output);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_BYTES_ERR_PARA_API_TC001
* @title Test the CRYPT_EAL_Drbgbytes interface for generating random numbers.
* @precon nan
* @brief
* 1.Initialize the random number seed, expected result 1.
* 2.Call CRYPT_EAL_Drbgbytes,use normal parameters, expected result 2.
* 3.Call CRYPT_EAL_Drbgbytes,the array length is abnormal, expected result 3.
* @expect
* 1.successful.
* 2.All interface succeeded.
* 3.The interface returns an exception.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_BYTES_ERR_PARA_API_TC001(void)
{
uint8_t *output = malloc(DRBG_MAX_OUTPUT_SIZE + 1);
ASSERT_TRUE(output != NULL);
CRYPT_RandSeedMethod seedMeth = { 0 };
CRYPT_Data data = { 0 };
DRBG_Vec_t seedCtx = { 0 };
void *drbg = NULL;
TestMemInit();
regSeedMeth(&seedMeth);
drbgDataInit(&data, TEST_DRBG_DATA_SIZE);
seedCtx.nonce = &data;
seedCtx.entropy = &data;
drbg = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA256, &seedMeth, &seedCtx);
ASSERT_TRUE(drbg != NULL);
ASSERT_TRUE(CRYPT_EAL_DrbgInstantiate(drbg, NULL, 0) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_Drbgbytes(drbg, output, DRBG_OUTPUT_SIZE), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_Drbgbytes(drbg, output, DRBG_MAX_OUTPUT_SIZE), CRYPT_SUCCESS);
ASSERT_NE(CRYPT_EAL_Drbgbytes(drbg, output, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_Drbgbytes(drbg, output, DRBG_MAX_OUTPUT_SIZE + 1), CRYPT_SUCCESS); // MAX SIZE + 1
ASSERT_NE(CRYPT_EAL_Drbgbytes(drbg, NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_Drbgbytes(NULL, output, DRBG_OUTPUT_SIZE), CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_DrbgDeinit(drbg);
drbgDataFree(&data);
free(output);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_RAND_SEED_ADIN_ERR_PARA_API_TC001
* @title Test the CRYPT_EAL_RandSeedWithAdin interface.
* @precon nan
* @brief
* 1.Initialize the random number seed, expected result 1.
* 2.Call CRYPT_EAL_RandSeedWithAdin,use exception parameters, expected result 2.
* @expect
* 1.successful.
* 2.The interface returns an exception.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_RAND_SEED_ADIN_ERR_PARA_API_TC001(void)
{
uint32_t addinLen = sizeof(uint8_t) * DRBG_MAX_ADIN_SIZE;
uint8_t *addin = malloc(addinLen);
ASSERT_TRUE(addin != NULL);
memset_s(addin, addinLen, 0, addinLen);
TestMemInit();
ASSERT_NE(CRYPT_EAL_RandSeedWithAdin(addin, 0), CRYPT_SUCCESS);
ASSERT_NE(CRYPT_EAL_RandSeedWithAdin(addin, addinLen), CRYPT_SUCCESS);
ASSERT_NE(CRYPT_EAL_RandSeedWithAdin(NULL, addinLen), CRYPT_SUCCESS);
ASSERT_NE(CRYPT_EAL_RandSeedWithAdin(NULL, 0), CRYPT_SUCCESS);
EXIT:
free(addin);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_SEED_ADIN_ERR_PARA_API_TC001
* @title Test the CRYPT_EAL_DrbgSeedWithAdin interface.
* @precon nan
* @brief
* 1.Initialize the random number seed, expected result 1.
* 2.Call CRYPT_EAL_DrbgSeedWithAdin,use normal parameters, expected result 2.
* 3.Call CRYPT_EAL_DrbgSeedWithAdin,the array length is abnormal, expected result 3.
* @expect
* 1.successful.
* 2.All interface succeeded.
* 3.The interface returns an exception.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_SEED_ADIN_ERR_PARA_API_TC001(void)
{
uint8_t *addin;
uint32_t addinLen = sizeof(uint8_t) * DRBG_MAX_ADIN_SIZE;
CRYPT_RandSeedMethod seedMeth = { 0 };
CRYPT_Data data = { 0 };
DRBG_Vec_t seedCtx = { 0 };
void *drbg = NULL;
addin = malloc(addinLen);
ASSERT_TRUE(addin != NULL);
memset_s(addin, addinLen, 0, addinLen);
TestMemInit();
regSeedMeth(&seedMeth);
drbgDataInit(&data, TEST_DRBG_DATA_SIZE);
seedCtx.nonce = &data;
seedCtx.entropy = &data;
drbg = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA256, &seedMeth, &seedCtx);
ASSERT_TRUE(drbg != NULL);
ASSERT_TRUE(CRYPT_EAL_DrbgInstantiate(drbg, NULL, 0) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_DrbgSeedWithAdin(drbg, addin, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_DrbgSeedWithAdin(drbg, addin, addinLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_DrbgSeedWithAdin(drbg, NULL, 0), CRYPT_SUCCESS);
ASSERT_NE(CRYPT_EAL_DrbgSeedWithAdin(NULL, addin, addinLen), CRYPT_SUCCESS);
ASSERT_NE(CRYPT_EAL_DrbgSeedWithAdin(drbg, NULL, addinLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_DrbgDeinit(drbg);
free(addin);
free(data.data);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_SEED_ADIN_ERR_PARA_API_TC001
* @title Random number generation test.
* @precon nan
* @brief
* 1.Initialize the random number seed, expected result 1.
* 2.Call CRYPT_EAL_RandbytesWithAdin num times, expected result 2.
* @expect
* 1.successful.
* 2.All interface succeeded.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_RAND_NUM_FUNC_TC001(int agId, int num, int dataSize)
{
if (IsRandAlgDisabled(agId)) {
SKIP_TEST();
}
int i;
uint8_t *output = NULL;
CRYPT_RandSeedMethod seedMeth = { 0 };
DRBG_Vec_t seedCtx = { 0 };
CRYPT_Data data = { 0 };
TestMemInit();
regSeedMeth(&seedMeth);
drbgDataInit(&data, dataSize);
seedCtx.entropy = &data;
seedCtx.nonce = &data;
ASSERT_EQ(CRYPT_EAL_RandInit(agId, &seedMeth, (void *)&seedCtx, NULL, 0), CRYPT_SUCCESS);
output = malloc(sizeof(uint8_t) * DRBG_OUTPUT_SIZE);
ASSERT_TRUE(output != NULL);
for (i = 0; i < num; i++) {
ASSERT_EQ(CRYPT_EAL_RandbytesWithAdin(output, sizeof(uint8_t) * DRBG_OUTPUT_SIZE, NULL, 0), CRYPT_SUCCESS);
}
EXIT:
CRYPT_EAL_RandDeinit();
drbgDataFree(&data);
free(output);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_NUM_FUNC_TC001
* @title Random number generation test.
* @precon nan
* @brief
* 1.Initialize the random number seed, expected result 1.
* 2.Call CRYPT_EAL_DrbgbytesWithAdin num times, expected result 2.
* @expect
* 1.successful.
* 2.All interface succeeded.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_NUM_FUNC_TC001(int agId, int num, int dataSize)
{
if (IsRandAlgDisabled(agId)) {
SKIP_TEST();
}
int i;
uint8_t *output = NULL;
CRYPT_RandSeedMethod seedMeth = { 0 };
DRBG_Vec_t seedCtx = { 0 };
CRYPT_Data data = { 0 };
void *drbgCtx = NULL;
TestMemInit();
regSeedMeth(&seedMeth);
drbgDataInit(&data, dataSize);
seedCtx.entropy = &data;
seedCtx.nonce = &data;
drbgCtx = CRYPT_EAL_DrbgNew(agId, &seedMeth, &seedCtx);
ASSERT_TRUE(drbgCtx != NULL);
ASSERT_TRUE(CRYPT_EAL_DrbgInstantiate(drbgCtx, NULL, 0) == CRYPT_SUCCESS);
output = malloc(sizeof(uint8_t) * DRBG_OUTPUT_SIZE);
ASSERT_TRUE(output != NULL);
for (i = 0; i < num; i++) {
ASSERT_EQ(CRYPT_EAL_DrbgbytesWithAdin(drbgCtx, output, sizeof(uint8_t) * DRBG_OUTPUT_SIZE, NULL, 0), CRYPT_SUCCESS);
}
EXIT:
CRYPT_EAL_DrbgDeinit(drbgCtx);
drbgDataFree(&data);
free(output);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_PTHREAD_FUNC_TC001
* @title DRGB multi-thread function test.
* @precon nan
* @brief
* 1.Initialize the random number seed, expected result 1.
* 2.Create 10 threads for execute CRYPT_EAL_Randbytes, expected result 2.
* @expect
* 1.init successful.
* 2.All threads are executed successfully..
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_PTHREAD_FUNC_TC001(int agId)
{
CRYPT_Data data = { 0 };
CRYPT_RandSeedMethod seedMeth = { 0 };
DRBG_Vec_t seedCtx = { 0 };
TestMemInit();
RegThreadFunc();
regSeedMeth(&seedMeth);
drbgDataInit(&data, TEST_DRBG_DATA_SIZE);
seedCtx.entropy = &data;
seedCtx.nonce = &data;
ASSERT_EQ(CRYPT_EAL_RandInit(agId, &seedMeth, &seedCtx, NULL, 0), CRYPT_SUCCESS);
for(uint32_t iter = 0; iter < 10; iter++) {
pthread_t thrd;
ASSERT_EQ(pthread_create(&thrd, NULL, (void *)sdvCryptGlobalThreadTest, NULL), 0);
pthread_join(thrd, NULL);
}
EXIT:
CRYPT_EAL_RandDeinit();
drbgDataFree(&data);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_CLEANENTROPY_FUNC_TC001
* @title Failed to obtain the entropy source test.
* @precon nan
* @brief
* 1.Register the interface that fails to obtain the entropy source, expected result 1.
* 2.Initialize the random number seed, expected result 2.
* @expect
* 1.register successful.
* 2.Failed to initialize the random number seed.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_CLEANENTROPY_FUNC_TC001(int agId)
{
CallBackCtl_t seedCtx = { 0 };
CRYPT_RandSeedMethod seedMeth = {
.getEntropy = getEntropyError,
.cleanEntropy = cleanEntropyError,
.getNonce = getNonceError,
.cleanNonce = cleanNonceError,
};
void *drbg = NULL;
TestMemInit();
seedCtx.entropyState = 1;
ASSERT_NE(CRYPT_EAL_RandInit(agId, &seedMeth, (void *)&seedCtx, NULL, 0), CRYPT_SUCCESS);
drbg = CRYPT_EAL_DrbgNew(agId, &seedMeth, (void *)&seedCtx);
ASSERT_TRUE(drbg != NULL);
ASSERT_NE(CRYPT_EAL_DrbgInstantiate(drbg, NULL, 0), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_DrbgDeinit(drbg);
CRYPT_EAL_RandDeinit();
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_GETENTROPY_FUNC_TC001
* @title Failed to obtain the entropy source test.
* @precon nan
* @brief
* 1.Do not register the entropy source obtaining function., expected result 1.
* 2.Initialize the random number seed, expected result 2.
* @expect
* 1.register successful.
* 2.Failed to initialize the random number seed.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_GETENTROPY_FUNC_TC001(int agId)
{
CallBackCtl_t seedCtx = { 0 };
CRYPT_RandSeedMethod seedMeth = {
.getEntropy = NULL,
.cleanEntropy = cleanEntropyError,
.getNonce = getNonceError,
.cleanNonce = cleanNonceError,
};
void *drbg = NULL;
TestMemInit();
ASSERT_NE(CRYPT_EAL_RandInit(agId, &seedMeth, (void *)&seedCtx, NULL, 0), CRYPT_SUCCESS);
drbg = CRYPT_EAL_DrbgNew(agId, &seedMeth, (void *)&seedCtx);
ASSERT_TRUE(drbg != NULL);
ASSERT_EQ(CRYPT_EAL_DrbgInstantiate(drbg, NULL, 0), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_DrbgDeinit(drbg);
CRYPT_EAL_RandDeinit();
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_GETENTROPY_FUNC_TC002
* @title To verify that the entropy data is empty and the length is 0 or a non-zero value.
* @precon nan
* @brief
* 1.Registering the callback function, expected result 1.
* 2.The entropy->data is empty and the length is 0,initialize the random number seed, expected result 2.
* 2.The entropy->data is empty and the length not 0,initialize the random number seed, expected result 3.
* @expect
* 1.Register successful.
* 2.Failed to initialize the random number seed.
* 3.Failed to initialize the random number seed.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_GETENTROPY_FUNC_TC002(void)
{
DRBG_Vec_t seedCtx = { 0 };
CRYPT_RandSeedMethod seedMeth = {
.getEntropy = getEntropyUnCheckPara,
.cleanEntropy = cleanEntropy,
.getNonce = NULL,
.cleanNonce = NULL,
};
void *drbg = NULL;
TestMemInit();
seedCtx.entropy = calloc(1u, sizeof(CRYPT_Data));
ASSERT_NE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, &seedMeth, (void *)&seedCtx, NULL, 0), CRYPT_SUCCESS);
CRYPT_EAL_RandDeinit();
drbg = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA256, &seedMeth, (void *)&seedCtx);
ASSERT_TRUE(drbg != NULL);
ASSERT_NE(CRYPT_EAL_DrbgInstantiate(drbg, NULL, 0), CRYPT_SUCCESS);
CRYPT_EAL_DrbgDeinit(drbg);
seedCtx.entropy->len = 1; // Set the entropy length to 1 verify that the data is empty but the data length is not 0.
ASSERT_NE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, &seedMeth, (void *)&seedCtx, NULL, 0), CRYPT_SUCCESS);
drbg = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA256, &seedMeth, (void *)&seedCtx);
ASSERT_TRUE(drbg != NULL);
ASSERT_NE(CRYPT_EAL_DrbgInstantiate(drbg, NULL, 0), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_DrbgDeinit(drbg);
CRYPT_EAL_RandDeinit();
DRBG_FREE(seedCtx.entropy);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_GETNONCE_FUNC_TC001
* @title Test that the nonce data is empty and the length is 0 or a non-zero value.
* @precon nan
* @brief
* 1.Registering the callback function, expected result 1.
* 2.The nonce->data is empty and the length is 0,initialize the random number seed, expected result 2.
* 2.The nonce->data is empty and the length not 0,initialize the random number seed, expected result 3.
* @expect
* 1.Register successful.
* 2.Failed to initialize the random number seed.
* 3.Failed to initialize the random number seed.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_GETNONCE_FUNC_TC001(void)
{
DRBG_Vec_t seedCtx = { 0 };
CRYPT_RandSeedMethod seedMeth = {
.getEntropy = getEntropyError,
.cleanEntropy = cleanEntropyError,
.getNonce = getNonceUnCheckPara,
.cleanNonce = cleanNonceError,
};
void *drbg = NULL;
TestMemInit();
seedCtx.nonce = calloc(1u, sizeof(CRYPT_Data));
ASSERT_NE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, &seedMeth, (void *)&seedCtx, NULL, 0), CRYPT_SUCCESS);
CRYPT_EAL_RandDeinit();
drbg = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA256, &seedMeth, (void *)&seedCtx);
ASSERT_TRUE(drbg != NULL);
ASSERT_NE(CRYPT_EAL_DrbgInstantiate(drbg, NULL, 0), CRYPT_SUCCESS);
CRYPT_EAL_DrbgDeinit(drbg);
seedCtx.nonce->len = 1; // Set the nonce length to 1 verify that the data is empty but the data length is not 0.
ASSERT_NE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, &seedMeth, (void *)&seedCtx, NULL, 0), CRYPT_SUCCESS);
drbg = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA256, &seedMeth, (void *)&seedCtx);
ASSERT_TRUE(drbg != NULL);
ASSERT_NE(CRYPT_EAL_DrbgInstantiate(drbg, NULL, 0), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_DrbgDeinit(drbg);
CRYPT_EAL_RandDeinit();
DRBG_FREE(seedCtx.nonce);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_GETNONCE_FUNC_TC002
* @title Failed to obtain nonce during DRBG initialization.
* @precon nan
* @brief
* 1.Registering the interface for failed to obtain the nonce, expected result 1.
* 2.Initializing the DRBG, expected result 2.
* @expect
* 1.Register successful.
* 2.Failed to initialize the random number seed.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_GETNONCE_FUNC_TC002(void)
{
DRBG_Vec_t seedCtx = { 0 };
CRYPT_RandSeedMethod seedMeth = {
.getEntropy = getEntropyError,
.cleanEntropy = cleanEntropyError,
.getNonce = getNonce,
.cleanNonce = cleanNonce,
};
void *drbg = NULL;
TestMemInit();
seedCtx.nonce = calloc(1u, sizeof(CRYPT_Data));
ASSERT_NE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, &seedMeth, (void *)&seedCtx, NULL, 0), CRYPT_SUCCESS);
drbg = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA256, &seedMeth, (void *)&seedCtx);
ASSERT_TRUE(drbg != NULL);
ASSERT_NE(CRYPT_EAL_DrbgInstantiate(drbg, NULL, 0), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_DrbgDeinit(drbg);
CRYPT_EAL_RandDeinit();
DRBG_FREE(seedCtx.nonce);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_GETNONCE_FUNC_TC003
* @title Failed to obtain nonce during DRBG instantiation.
* @precon nan
* @brief
* 1.Registering the interface for failed to obtain the nonce, expected result 1.
* 2.Initializing the DRBG, expected result 2.
* @expect
* 1.Register successful.
* 2.Failed to initialize the random number seed.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_GETNONCE_FUNC_TC003(void)
{
CallBackCtl_t seedCtx = { 0 };
CRYPT_RandSeedMethod seedMeth = {
.getNonce = getNonceError,
.cleanNonce = cleanNonceError,
.getEntropy = getEntropyError,
.cleanEntropy = cleanEntropyError,
};
void *drbg = NULL;
TestMemInit();
seedCtx.nonceState = 1;
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA224, &seedMeth, (void *)&seedCtx, NULL, 0) != CRYPT_SUCCESS);
drbg = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA224, &seedMeth, (void *)&seedCtx);
ASSERT_TRUE(drbg != NULL);
ASSERT_NE(CRYPT_EAL_DrbgInstantiate(drbg, NULL, 0), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_DrbgDeinit(drbg);
CRYPT_EAL_RandDeinit();
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_INSTANTIATE_FUNC_TC001
* @title The personal data provided during DRBG instantiation is empty.
* @precon nan
* @brief
* 1.set the personal data is empty.
* 2.Initializing the DRBG, expected result 1.
* 3.Uninitializing the DRBG, expected result 2.
* @expect
* 1.The DRBG is successfully initialized regardless of whether the data field is empty.
* 2.The DRBG is successfully uninitialized.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_INSTANTIATE_FUNC_TC001(void)
{
CRYPT_Data *pers = NULL;
DRBG_Vec_t seedCtx = { 0 };
CRYPT_RandSeedMethod seedMeth = {
.getEntropy = getEntropyError,
.cleanEntropy = cleanEntropyError,
.getNonce = getNonceError,
.cleanNonce = cleanNonceError,
};
TestMemInit();
pers = calloc(1u, sizeof(CRYPT_Data));
ASSERT_EQ(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, &seedMeth, (void *)&seedCtx, pers->data, pers->len),
CRYPT_SUCCESS);
CRYPT_EAL_RandDeinit();
void *drbg = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA256, &seedMeth, (void *)&seedCtx);
ASSERT_TRUE(drbg != NULL);
ASSERT_EQ(CRYPT_EAL_DrbgInstantiate(drbg, pers->data, pers->len), CRYPT_SUCCESS);
CRYPT_EAL_DrbgDeinit(drbg);
drbg = NULL;
pers->data = calloc(DRBG_MAX_ADIN_SIZE + 1, sizeof(uint8_t));
pers->len = DRBG_MAX_ADIN_SIZE + 1;
ASSERT_EQ(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, &seedMeth, (void *)&seedCtx, pers->data, pers->len),
CRYPT_SUCCESS);
drbg = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA256, &seedMeth, (void *)&seedCtx);
ASSERT_TRUE(drbg != NULL);
ASSERT_EQ(CRYPT_EAL_DrbgInstantiate(drbg, pers->data, pers->len), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_DrbgDeinit(drbg);
CRYPT_EAL_RandDeinit();
DRBG_FREE(pers->data);
DRBG_FREE(pers);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_DUP_API_TC001
* @title Test the DRBG dup interface.
* @precon nan
* @brief
* 1.Call DRBG_NewHashCtx create ctx, expected result 1.
* 2.Call dup function,give an empty input parameter, expected result 2.
* 3.Call dup function,give the correct DRBG context, expected result 3.
* @expect
* 1.successful.
* 2.The interface returns a null pointer.
* 3.The interface returns new ctx.
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_DUP_API_TC001(int algId)
{
CRYPT_RandSeedMethod seedMeth = { 0 };
CRYPT_Data data = { 0 };
DRBG_Vec_t seedCtx = { 0 };
TestMemInit();
regSeedMeth(&seedMeth);
drbgDataInit(&data, TEST_DRBG_DATA_SIZE);
seedCtx.nonce = &data;
seedCtx.entropy = &data;
CRYPT_EAL_RndCtx *drbg = CRYPT_EAL_DrbgNew(algId, &seedMeth, &seedCtx);
ASSERT_TRUE(drbg != NULL);
DRBG_Ctx *ctx = (DRBG_Ctx*)(drbg->ctx);
DRBG_Ctx *newCtx = ctx->meth->dup(ctx);
ASSERT_TRUE(newCtx != NULL);
ASSERT_TRUE(ctx->meth->dup(NULL) == NULL);
EXIT:
CRYPT_EAL_DrbgDeinit(drbg);
DRBG_Free(newCtx);
drbgDataFree(&data);
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_PTHREAD_FUNC_TC002
* @title DRGB multi-thread function test.
* @precon nan
* @brief
* 1.Initialize 10 drbgCtx, expected result 1.
* 2.Create 10 threads for execute CRYPT_EAL_DrbgbytesWithAdin, expected result 2.
* @expect
* 1.init successful.
* 2.All threads are executed successfully..
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_PTHREAD_FUNC_TC002(int agId)
{
if (IsRandAlgDisabled(agId)) {
SKIP_TEST();
}
CRYPT_Data data = { 0 };
CRYPT_RandSeedMethod seedMeth = { 0 };
DRBG_Vec_t seedCtx = { 0 };
TestMemInit();
RegThreadFunc();
regSeedMeth(&seedMeth);
drbgDataInit(&data, TEST_DRBG_DATA_SIZE);
seedCtx.entropy = &data;
seedCtx.nonce = &data;
for (uint32_t iter = 0; iter < 10; iter++) {
pthread_t thrd;
void *drbgCtx = CRYPT_EAL_DrbgNew(agId, &seedMeth, &seedCtx);
ASSERT_TRUE(drbgCtx != NULL);
ASSERT_TRUE(CRYPT_EAL_DrbgInstantiate(drbgCtx, NULL, 0) == CRYPT_SUCCESS);
ASSERT_EQ(pthread_create(&thrd, NULL, (void *)sdvCryptEalThreadTest, drbgCtx), 0);
pthread_join(thrd, NULL);
CRYPT_EAL_DrbgDeinit(drbgCtx);
drbgCtx = NULL;
}
EXIT:
drbgDataFree(&data);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_DRBG_PTHREAD_FUNC_TC003
* @title DRGB multi-thread function test.
* @precon nan
* @brief
* 1.Initialize drbgCtx, expected result 1.
* 2.Create 10 threads for execute CRYPT_EAL_DrbgbytesWithAdin, expected result 2.
* @expect
* 1.init successful.
* 2.All threads are executed successfully..
*/
/* BEGIN_CASE */
void SDV_CRYPT_DRBG_PTHREAD_FUNC_TC003(int agId)
{
CRYPT_Data data = { 0 };
CRYPT_RandSeedMethod seedMeth = { 0 };
DRBG_Vec_t seedCtx = { 0 };
TestMemInit();
RegThreadFunc();
regSeedMeth(&seedMeth);
drbgDataInit(&data, TEST_DRBG_DATA_SIZE);
seedCtx.entropy = &data;
seedCtx.nonce = &data;
void *drbgCtx = CRYPT_EAL_DrbgNew(agId, &seedMeth, &seedCtx);
ASSERT_TRUE(drbgCtx != NULL);
ASSERT_TRUE(CRYPT_EAL_DrbgInstantiate(drbgCtx, NULL, 0) == CRYPT_SUCCESS);
for (uint32_t iter = 0; iter < 10; iter++) {
pthread_t thrd;
ASSERT_EQ(pthread_create(&thrd, NULL, (void *)sdvCryptEalThreadTest, drbgCtx), 0);
pthread_join(thrd, NULL);
}
EXIT:
CRYPT_EAL_DrbgDeinit(drbgCtx);
drbgDataFree(&data);
return;
}
/* END_CASE */
static int32_t getEntropyWithoutSeedCtx(void *ctx, CRYPT_Data *entropy, uint32_t strength, CRYPT_Range *lenRange)
{
(void)ctx;
(void)strength;
(void)lenRange;
uint32_t entroyLen = sizeof(uint8_t) * TEST_DRBG_DATA_SIZE;
entropy->data = calloc(1u, entroyLen);
entropy->len = entroyLen;
return CRYPT_SUCCESS;
}
static int32_t getEntropyWithoutSeedCtxSpecial(void *ctx, CRYPT_Data *entropy, uint32_t strength, CRYPT_Range *lenRange)
{
(void)ctx;
(void)strength;
(void)lenRange;
uint32_t entroyLen = sizeof(uint8_t) * CTR_AES128_SEEDLEN;
entropy->data = calloc(1u, entroyLen);
entropy->len = entroyLen;
return CRYPT_SUCCESS;
}
static int32_t getNonceWithoutSeedCtx(void *ctx, CRYPT_Data *nonce, uint32_t strength, CRYPT_Range *lenRange)
{
(void)ctx;
(void)strength;
(void)lenRange;
uint32_t nonceLen = sizeof(uint8_t) * TEST_DRBG_DATA_SIZE;
nonce->data = calloc(1u, nonceLen);
nonce->len = nonceLen;
return CRYPT_SUCCESS;
}
/**
* @test SDV_CRYPT_EAL_RAND_BYTES_FUNC_TC001
* @title Generating random numbers based on entropy sources.
* @precon nan
* @brief
* 1.Initialize the random number seed, expected result 1.
* 2.Call CRYPT_EAL_RandbytesWithAdin, expected result 2.
* 3.Call CRYPT_EAL_Randbytes get random numbers, expected result 3.
* @expect
* 1.init successful.
* 2.successful.
* 3.Random number generated successfully.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_RAND_BYTES_FUNC_TC001(int id, Hex *entropy, Hex *nonce, Hex *pers, Hex *addin1, Hex *entropyPR1,
Hex *addin2, Hex *entropyPR2, Hex *retBits)
{
if (IsRandAlgDisabled(id)){
SKIP_TEST();
}
uint8_t output[DRBG_MAX_OUTPUT_SIZE];
CRYPT_RandSeedMethod seedMeth = { 0 };
DRBG_Vec_t *seedCtx;
regSeedMeth(&seedMeth);
TestMemInit();
seedCtx = seedCtxMem();
ASSERT_TRUE(seedCtx != NULL);
seedCtxCfg(seedCtx, entropy, nonce, pers, addin1, entropyPR1, addin2, entropyPR2, retBits);
ASSERT_EQ(CRYPT_EAL_RandInit((CRYPT_RAND_AlgId)id, &seedMeth, (void *)seedCtx, seedCtx->pers->data,
seedCtx->pers->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_RandbytesWithAdin(output, sizeof(uint8_t) * retBits->len, addin1->x, addin1->len),
CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_Randbytes(output, sizeof(uint8_t) * retBits->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_RandIsValidAlgId(id), true);
EXIT:
CRYPT_EAL_RandDeinit();
seedCtxFree(seedCtx);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_DRBG_BYTES_FUNC_TC001
* @title Generating random numbers based on entropy sources.
* @precon nan
* @brief
* 1.Initialize the random number seed, expected result 1.
* 2.Call CRYPT_EAL_DrbgbytesWithAdin, expected result 2.
* 3.Call CRYPT_EAL_Drbgbytes get random numbers, expected result 3.
* @expect
* 1.Init successful.
* 2.Successful.
* 3.Random number generated successfully.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_DRBG_BYTES_FUNC_TC001(int id, Hex *entropy, Hex *nonce, Hex *pers, Hex *addin1, Hex *entropyPR1,
Hex *addin2, Hex *entropyPR2, Hex *retBits)
{
if (IsRandAlgDisabled(id)){
SKIP_TEST();
}
uint8_t *output = NULL;
CRYPT_RandSeedMethod seedMeth = { 0 };
DRBG_Vec_t *seedCtx;
void *drbgCtx = NULL;
regSeedMeth(&seedMeth);
TestMemInit();
seedCtx = seedCtxMem();
ASSERT_TRUE(seedCtx != NULL);
seedCtxCfg(seedCtx, entropy, nonce, pers, addin1, entropyPR1, addin2, entropyPR2, retBits);
drbgCtx = CRYPT_EAL_DrbgNew(id, &seedMeth, seedCtx);
ASSERT_TRUE(drbgCtx != NULL);
ASSERT_TRUE(CRYPT_EAL_DrbgInstantiate(drbgCtx, NULL, 0) == CRYPT_SUCCESS);
output = malloc(sizeof(uint8_t) * retBits->len);
ASSERT_TRUE(output != NULL);
ASSERT_EQ(CRYPT_EAL_DrbgbytesWithAdin(drbgCtx, output, sizeof(uint8_t) * retBits->len, addin1->x, addin1->len),
CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_Drbgbytes(drbgCtx, output, sizeof(uint8_t) * retBits->len), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_DrbgDeinit(drbgCtx);
seedCtxFree(seedCtx);
free(output);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_RAND_BYTES_FUNC_TC002
* @title Generating random numbers based on entropy sources,the user only provides the seed method,
not the seed context.
* @precon nan
* @brief
* 1.Initialize the random number seed, expected result 1.
* 2.Call CRYPT_EAL_RandSeed, expected result 2.
* 3.Call CRYPT_EAL_Randbytes get random numbers, expected result 3.
* @expect
* 1.init successful.
* 2.successful.
* 3.Random number generated successfully.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_RAND_BYTES_FUNC_TC002(int id)
{
if (IsRandAlgDisabled(id)){
SKIP_TEST();
}
uint8_t output[DRBG_MAX_OUTPUT_SIZE];
CRYPT_RandSeedMethod seedMeth = {
.getEntropy = getEntropyWithoutSeedCtx,
.cleanEntropy = cleanEntropyError,
.getNonce = getNonceWithoutSeedCtx,
.cleanNonce = cleanNonceError,
};
TestMemInit();
/* The DRBG-CTR mode requires the entropy source length of a specific length, and seedMeth needs to generate
entropy of the corresponding length.(DRBG-CTR AES128/AES192/AES256 length is 32, 40, 48).
*/
if (id == CRYPT_RAND_AES128_CTR || id == CRYPT_RAND_AES192_CTR || id == CRYPT_RAND_AES256_CTR) {
seedMeth.getEntropy = getEntropyWithoutSeedCtxSpecial;
seedMeth.getNonce = NULL;
seedMeth.cleanNonce = NULL;
}
ASSERT_EQ(CRYPT_EAL_RandInit((CRYPT_RAND_AlgId)id, &seedMeth, NULL, NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_RandSeed(), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_Randbytes(output, DRBG_MAX_OUTPUT_SIZE), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_RandDeinit();
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_RAND_DEFAULT_PROVIDER_BYTES_FUNC_TC001
* @title Default provider testing
* @precon nan
* @brief
* Load the default provider and use the test vector to test its correctness
* Generating random numbers based on entropy sources
* 1.Initialize the random number seed, expected result 1.
* 2.Call CRYPT_EAL_RandbytesWithAdin, expected result 2.
* 3.Call CRYPT_EAL_Randbytes get random numbers, expected result 3.
* @expect
* 1.init successful.
* 2.successful.
* 3.Random number generated successfully.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_RAND_DEFAULT_PROVIDER_BYTES_FUNC_TC001(int id, Hex *entropy, Hex *nonce, Hex *pers,
Hex *addin1, Hex *entropyPR1, Hex *addin2, Hex *entropyPR2, Hex *retBits)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)id;
(void)entropy;
(void)nonce;
(void)pers;
(void)addin1;
(void)entropyPR1;
(void)addin2;
(void)entropyPR2;
(void)retBits;
SKIP_TEST();
#else
if (IsRandAlgDisabled(id)) {
SKIP_TEST();
}
uint8_t output[DRBG_MAX_OUTPUT_SIZE];
CRYPT_RandSeedMethod seedMeth = { 0 };
DRBG_Vec_t *seedCtx;
regSeedMeth(&seedMeth);
TestMemInit();
seedCtx = seedCtxMem();
ASSERT_TRUE(seedCtx != NULL);
seedCtxCfg(seedCtx, entropy, nonce, pers, addin1, entropyPR1, addin2, entropyPR2, retBits);
BSL_Param param[6] = {0};
ASSERT_EQ(BSL_PARAM_InitValue(¶m[0],
CRYPT_PARAM_RAND_SEEDCTX, BSL_PARAM_TYPE_CTX_PTR, seedCtx, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[1],
CRYPT_PARAM_RAND_SEED_GETENTROPY, BSL_PARAM_TYPE_FUNC_PTR, seedMeth.getEntropy, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[2],
CRYPT_PARAM_RAND_SEED_CLEANENTROPY, BSL_PARAM_TYPE_FUNC_PTR, seedMeth.cleanEntropy, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[3],
CRYPT_PARAM_RAND_SEED_GETNONCE, BSL_PARAM_TYPE_FUNC_PTR, seedMeth.getNonce, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[4],
CRYPT_PARAM_RAND_SEED_CLEANNONCE, BSL_PARAM_TYPE_FUNC_PTR, seedMeth.cleanNonce, 0), BSL_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderRandInitCtx(NULL, (CRYPT_RAND_AlgId)id, "provider=default",
seedCtx->pers->data, seedCtx->pers->len, param), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_RandbytesWithAdinEx(NULL, output, sizeof(uint8_t) * retBits->len, addin1->x, addin1->len),
CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_RandbytesEx(NULL, output, sizeof(uint8_t) * retBits->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_RandIsValidAlgId(id), true);
EXIT:
CRYPT_EAL_RandDeinitEx(NULL);
seedCtxFree(seedCtx);
return;
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_DRBG_DEFAULT_PROVIDER_BYTES_FUNC_TC001
* @title Default provider testing
* @precon nan
* @brief
* Load the default provider and use the test vector to test its correctness
* Generating random numbers based on entropy sources.
* 1.Initialize the random number seed, expected result 1.
* 2.Call CRYPT_EAL_DrbgbytesWithAdin, expected result 2.
* 3.Call CRYPT_EAL_Drbgbytes get random numbers, expected result 3.
* @expect
* 1.Init successful.
* 2.Successful.
* 3.Random number generated successfully.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_DRBG_DEFAULT_PROVIDER_BYTES_FUNC_TC001(int id, Hex *entropy, Hex *nonce, Hex *pers,
Hex *addin1, Hex *entropyPR1, Hex *addin2, Hex *entropyPR2, Hex *retBits)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)id;
(void)entropy;
(void)nonce;
(void)pers;
(void)addin1;
(void)entropyPR1;
(void)addin2;
(void)entropyPR2;
(void)retBits;
SKIP_TEST();
#else
if (IsRandAlgDisabled(id)) {
SKIP_TEST();
}
uint8_t *output = NULL;
CRYPT_RandSeedMethod seedMeth = { 0 };
DRBG_Vec_t *seedCtx;
void *drbgCtx = NULL;
regSeedMeth(&seedMeth);
TestMemInit();
seedCtx = seedCtxMem();
ASSERT_TRUE(seedCtx != NULL);
seedCtxCfg(seedCtx, entropy, nonce, pers, addin1, entropyPR1, addin2, entropyPR2, retBits);
BSL_Param param[6] = {0};
ASSERT_EQ(BSL_PARAM_InitValue(¶m[0],
CRYPT_PARAM_RAND_SEEDCTX, BSL_PARAM_TYPE_CTX_PTR, seedCtx, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[1],
CRYPT_PARAM_RAND_SEED_GETENTROPY, BSL_PARAM_TYPE_FUNC_PTR, seedMeth.getEntropy, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[2],
CRYPT_PARAM_RAND_SEED_CLEANENTROPY, BSL_PARAM_TYPE_FUNC_PTR, seedMeth.cleanEntropy, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[3],
CRYPT_PARAM_RAND_SEED_GETNONCE, BSL_PARAM_TYPE_FUNC_PTR, seedMeth.getNonce, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[4],
CRYPT_PARAM_RAND_SEED_CLEANNONCE, BSL_PARAM_TYPE_FUNC_PTR, seedMeth.cleanNonce, 0), BSL_SUCCESS);
drbgCtx = CRYPT_EAL_ProviderDrbgNewCtx(NULL, (CRYPT_RAND_AlgId)id, "provider=default", param);
ASSERT_TRUE(drbgCtx != NULL);
ASSERT_TRUE(CRYPT_EAL_DrbgInstantiate(drbgCtx, NULL, 0) == CRYPT_SUCCESS);
output = malloc(sizeof(uint8_t) * retBits->len);
ASSERT_TRUE(output != NULL);
ASSERT_EQ(CRYPT_EAL_DrbgbytesWithAdin(drbgCtx, output, sizeof(uint8_t) * retBits->len, addin1->x, addin1->len),
CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_Drbgbytes(drbgCtx, output, sizeof(uint8_t) * retBits->len), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_DrbgDeinit(drbgCtx);
seedCtxFree(seedCtx);
free(output);
return;
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_RAND_DEFAULT_PROVIDER_BYTES_FUNC_TC002
* @title Default provider testing
* @precon nan
* @brief
* Load the default provider and use the test vector to test its correctness
* Generating random numbers based on entropy sources,the user only provides the seed method,
* not the seed context.
* 1.Initialize the random number seed, expected result 1.
* 2.Call CRYPT_EAL_RandSeed, expected result 2.
* 3.Call CRYPT_EAL_Randbytes get random numbers, expected result 3.
* 4.Initialize the random number without seedMeth, expected result 4.
* @expect
* 1.init successful.
* 2.successful.
* 3.Random number generated successfully.
* 4.init successful.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_RAND_DEFAULT_PROVIDER_BYTES_FUNC_TC002(int id)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)id;
SKIP_TEST();
#else
if (IsRandAlgDisabled(id)) {
SKIP_TEST();
}
uint8_t output[DRBG_MAX_OUTPUT_SIZE];
CRYPT_RandSeedMethod seedMeth = {
.getEntropy = getEntropyWithoutSeedCtx,
.cleanEntropy = cleanEntropyError,
.getNonce = getNonceWithoutSeedCtx,
.cleanNonce = cleanNonceError,
};
TestMemInit();
/* The DRBG-CTR mode requires the entropy source length of a specific length, and seedMeth needs to generate
entropy of the corresponding length.(DRBG-CTR AES128/AES192/AES256 length is 32, 40, 48).
*/
if (id == CRYPT_RAND_AES128_CTR || id == CRYPT_RAND_AES192_CTR || id == CRYPT_RAND_AES256_CTR) {
seedMeth.getEntropy = getEntropyWithoutSeedCtxSpecial;
seedMeth.getNonce = NULL;
seedMeth.cleanNonce = NULL;
}
BSL_Param param[6] = {0};
ASSERT_EQ(BSL_PARAM_InitValue(¶m[0],
CRYPT_PARAM_RAND_SEEDCTX, BSL_PARAM_TYPE_CTX_PTR, NULL, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[1],
CRYPT_PARAM_RAND_SEED_GETENTROPY, BSL_PARAM_TYPE_FUNC_PTR, seedMeth.getEntropy, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[2],
CRYPT_PARAM_RAND_SEED_CLEANENTROPY, BSL_PARAM_TYPE_FUNC_PTR, seedMeth.cleanEntropy, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[3],
CRYPT_PARAM_RAND_SEED_GETNONCE, BSL_PARAM_TYPE_FUNC_PTR, seedMeth.getNonce, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[4],
CRYPT_PARAM_RAND_SEED_CLEANNONCE, BSL_PARAM_TYPE_FUNC_PTR, seedMeth.cleanNonce, 0), BSL_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderRandInitCtx(NULL, (CRYPT_RAND_AlgId)id, "provider=default", NULL, 0, param), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_RandSeedEx(NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_RandbytesEx(NULL, output, DRBG_MAX_OUTPUT_SIZE), CRYPT_SUCCESS);
CRYPT_EAL_DrbgDeinit(CRYPT_EAL_GetGlobalLibCtx()->drbg);
CRYPT_EAL_GetGlobalLibCtx()->drbg = NULL;
param[1] = (BSL_Param){0, 0, NULL, 0, 0};
ASSERT_EQ(CRYPT_EAL_ProviderRandInitCtx(NULL, (CRYPT_RAND_AlgId)id, "provider=default", NULL, 0, param), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_RandSeedEx(NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_RandbytesEx(NULL, output, DRBG_MAX_OUTPUT_SIZE), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_RandDeinitEx(NULL);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_RAND_DEFAULT_PROVIDER_BYTES_FUNC_TC003(int id)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)id;
SKIP_TEST();
#else
if (IsRandAlgDisabled(id)) {
SKIP_TEST();
}
uint8_t output[DRBG_MAX_OUTPUT_SIZE];
CRYPT_RandSeedMethod seedMeth = {
.getEntropy = getEntropyWithoutSeedCtx,
.cleanEntropy = cleanEntropyError,
.getNonce = getNonceWithoutSeedCtx,
.cleanNonce = cleanNonceError,
};
TestMemInit();
BSL_Param param[6] = {0};
ASSERT_EQ(BSL_PARAM_InitValue(¶m[0],
CRYPT_PARAM_RAND_SEED_GETNONCE, BSL_PARAM_TYPE_FUNC_PTR, seedMeth.getNonce, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[1],
CRYPT_PARAM_RAND_SEED_CLEANNONCE, BSL_PARAM_TYPE_FUNC_PTR, seedMeth.cleanNonce, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[2],
CRYPT_PARAM_RAND_SEEDCTX, BSL_PARAM_TYPE_CTX_PTR, NULL, 0), BSL_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderRandInitCtx(NULL, (CRYPT_RAND_AlgId)id, "provider=default", NULL, 0, NULL),
CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_RandSeedEx(NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_RandbytesEx(NULL, output, DRBG_MAX_OUTPUT_SIZE), CRYPT_SUCCESS);
CRYPT_EAL_DrbgDeinit(CRYPT_EAL_GetGlobalLibCtx()->drbg);
CRYPT_EAL_GetGlobalLibCtx()->drbg = NULL;
ASSERT_EQ(CRYPT_EAL_ProviderRandInitCtx(NULL, (CRYPT_RAND_AlgId)id, "provider=default", NULL, 0, param),
CRYPT_EAL_ERR_DRBG_INIT_FAIL);
param[2] = (BSL_Param){0, 0, NULL, 0, 0};
ASSERT_EQ(CRYPT_EAL_ProviderRandInitCtx(NULL, (CRYPT_RAND_AlgId)id, "provider=default", NULL, 0, param),
CRYPT_EAL_ERR_DRBG_INIT_FAIL);
EXIT:
CRYPT_EAL_RandDeinitEx(NULL);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_DRBG_SET_PREDICTION_RESISTANCE_API_TC001()
{
uint8_t *output = NULL;
void *drbgCtx = NULL;
CRYPT_Data data = { 0 };
CRYPT_RandSeedMethod seedMeth = { 0 };
DRBG_Vec_t seedCtx = { 0 };
bool pr = true;
TestMemInit();
regSeedMeth(&seedMeth);
drbgDataInit(&data, TEST_DRBG_DATA_SIZE);
seedCtx.entropy = &data;
seedCtx.nonce = &data;
drbgCtx = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA256, &seedMeth, &seedCtx);
ASSERT_TRUE(drbgCtx != NULL);
ASSERT_TRUE(CRYPT_EAL_DrbgInstantiate(drbgCtx, NULL, 0) == CRYPT_SUCCESS);
output = malloc(sizeof(uint8_t) * DRBG_OUTPUT_SIZE);
ASSERT_TRUE(output != NULL);
(void)memset_s(output, sizeof(uint8_t) * DRBG_OUTPUT_SIZE, 0, sizeof(uint8_t) * DRBG_OUTPUT_SIZE);
ASSERT_EQ(CRYPT_EAL_DrbgbytesWithAdin(drbgCtx, output, DRBG_OUTPUT_SIZE, NULL, 0), CRYPT_SUCCESS);
CRYPT_EAL_DrbgDeinit(drbgCtx);
drbgCtx = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA256, &seedMeth, &seedCtx);
ASSERT_TRUE(drbgCtx != NULL);
ASSERT_EQ(CRYPT_EAL_DrbgCtrl(drbgCtx, CRYPT_CTRL_SET_PREDICTION_RESISTANCE, &pr, sizeof(pr)), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_DrbgInstantiate(drbgCtx, NULL, 0) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_DrbgbytesWithAdin(drbgCtx, output, DRBG_OUTPUT_SIZE, NULL, 0), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_DrbgDeinit(drbgCtx);
drbgDataFree(&data);
free(output);
}
/* END_CASE */
/**
* @test SDV_CRYPT_PRIMARY_DRBG_RESEED_FUNC_TC001
* @title DRGB get seed ctx and reseed test.
* @precon nan
* @brief
* 1.Initialize the random number and obtain the seed.
* 2.Call the reseed function and obtain a random number.
* @expect
* 1.successful.
* 2.successful.
*/
/* BEGIN_CASE */
void SDV_CRYPT_PRIMARY_DRBG_RESEED_FUNC_TC001(int algId)
{
#if (!defined(HITLS_CRYPTO_ENTROPY))
(void)algId;
#else
if (IsRandAlgDisabled(algId)) {
SKIP_TEST();
}
uint8_t addin[40] = {1, 2, 3, 4};
uint8_t randByte[64];
uint32_t working = 0;
TestMemInit();
ASSERT_TRUE(CRYPT_EAL_GetSeedCtx(true) == NULL);
ASSERT_EQ(CRYPT_EAL_DrbgCtrl(NULL, CRYPT_CTRL_GET_WORKING_STATUS, &working, sizeof(working)), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_RandInit(algId, NULL, NULL, NULL, 0), CRYPT_SUCCESS);
CRYPT_EAL_RndCtx *seedCtx = CRYPT_EAL_GetSeedCtx(true);
ASSERT_EQ(CRYPT_EAL_DrbgCtrl(seedCtx, CRYPT_CTRL_GET_WORKING_STATUS, &working, sizeof(working)), CRYPT_SUCCESS);
ASSERT_EQ(working, 1);
ASSERT_EQ(CRYPT_EAL_DrbgSeedWithAdin(seedCtx, addin, sizeof(addin)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_Randbytes(randByte, sizeof(randByte)), CRYPT_SUCCESS);
seedCtx = CRYPT_EAL_GetSeedCtx(false);
ASSERT_EQ(CRYPT_EAL_DrbgCtrl(seedCtx, CRYPT_CTRL_GET_WORKING_STATUS, &working, sizeof(working)), CRYPT_SUCCESS);
ASSERT_EQ(working, 1);
ASSERT_EQ(CRYPT_EAL_DrbgSeedWithAdin(seedCtx, addin, sizeof(addin)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_Randbytes(randByte, sizeof(randByte)), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_RandDeinit();
return;
#endif
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/drbg/test_suite_sdv_drbg.c | C | unknown | 69,937 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include "securec.h"
#include "bsl_err.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "crypt_dsa.h"
#include "dsa_local.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_rand.h"
#include "crypt_bn.h"
#include "eal_pkey_local.h"
#include "stub_replace.h"
#include "crypt_util_rand.h"
#include "crypt_encode_internal.h"
#include "crypt_eal_md.h"
/* END_HEADER */
#define SUCCESS 0
#define ERROR (-1)
#define BITS_OF_BYTE 8
#define CRYPT_EAL_PKEY_KEYMGMT_OPERATE 0
static uint8_t g_kRandBuf[64];
static uint32_t g_kRandBufLen = 0;
extern int32_t CryptDsaFips1864GenPq(CRYPT_DSA_Ctx *ctx, DSA_FIPS186_4_Para *fipsPara, uint32_t type,
BSL_Buffer *seed, uint32_t *counter);
extern int32_t CryptDsaFips1864ValidatePq(int32_t algId, void *libCtx, const char *mdAttr, uint32_t type,
BSL_Buffer *seed, CRYPT_DSA_Para *dsaPara, uint32_t counter);
extern int32_t CryptDsaFips1864GenUnverifiableG(CRYPT_DSA_Para *dsaPara);
extern int32_t CryptDsaFips1864GenVerifiableG(DSA_FIPS186_4_Para *fipsPara, BSL_Buffer *seed, CRYPT_DSA_Para *dsaPara);
extern int32_t CryptDsaFips1864PartialValidateG(const CRYPT_DSA_Para *dsaPara);
extern int32_t CryptDsaFips1864ValidateG(DSA_FIPS186_4_Para *fipsPara, BSL_Buffer *seed, CRYPT_DSA_Para *dsaPara);
int32_t STUB_RandRangeK(void *libCtx, BN_BigNum *r, const BN_BigNum *p)
{
(void)p;
(void)libCtx;
BN_Bin2Bn(r, g_kRandBuf, g_kRandBufLen);
return CRYPT_SUCCESS;
}
int Compute_Md(CRYPT_MD_AlgId mdId, Hex *msgIn, Hex *mdOut)
{
uint32_t outLen;
CRYPT_EAL_MdCTX *mdCtx = NULL;
uint32_t mdOutLen = CRYPT_EAL_MdGetDigestSize(mdId);
ASSERT_TRUE(mdOutLen != 0);
mdOut->x = (uint8_t *)malloc(mdOutLen);
ASSERT_TRUE(mdOut->x != NULL);
mdOut->len = mdOutLen;
outLen = mdOutLen;
mdCtx = CRYPT_EAL_MdNewCtx(mdId);
ASSERT_TRUE_AND_LOG("CRYPT_EAL_MdNewCtx", mdCtx != NULL);
ASSERT_TRUE_AND_LOG("CRYPT_EAL_MdInit", CRYPT_EAL_MdInit(mdCtx) == 0);
ASSERT_TRUE_AND_LOG("CRYPT_EAL_MdUpdate", CRYPT_EAL_MdUpdate(mdCtx, msgIn->x, msgIn->len) == 0);
ASSERT_TRUE_AND_LOG("CRYPT_EAL_MdFinal", CRYPT_EAL_MdFinal(mdCtx, mdOut->x, &outLen) == 0);
mdOut->len = outLen;
CRYPT_EAL_MdFreeCtx(mdCtx);
return SUCCESS;
EXIT:
CRYPT_EAL_MdFreeCtx(mdCtx);
free(mdOut->x);
mdOut->x = NULL;
return ERROR;
}
void Set_DSA_Para(
CRYPT_EAL_PkeyPara *para, CRYPT_EAL_PkeyPrv *prv, CRYPT_EAL_PkeyPub *pub, Hex *P, Hex *Q, Hex *G, Hex *X, Hex *Y)
{
para->id = CRYPT_PKEY_DSA;
para->para.dsaPara.p = P->x;
para->para.dsaPara.pLen = P->len;
para->para.dsaPara.q = Q->x;
para->para.dsaPara.qLen = Q->len;
para->para.dsaPara.g = G->x;
para->para.dsaPara.gLen = G->len;
if (prv && X) {
prv->id = CRYPT_PKEY_DSA;
prv->key.dsaPrv.data = X->x;
prv->key.dsaPrv.len = X->len;
}
if (pub && Y) {
pub->id = CRYPT_PKEY_DSA;
pub->key.dsaPub.data = Y->x;
pub->key.dsaPub.len = Y->len;
}
}
static void Set_DSA_Pub(CRYPT_EAL_PkeyPub *pub, uint8_t *key, uint32_t keyLen)
{
pub->id = CRYPT_PKEY_DSA;
pub->key.dsaPub.data = key;
pub->key.dsaPub.len = keyLen;
}
static void Set_DSA_Prv(CRYPT_EAL_PkeyPrv *prv, uint8_t *key, uint32_t keyLen)
{
prv->id = CRYPT_PKEY_DSA;
prv->key.dsaPrv.data = key;
prv->key.dsaPrv.len = keyLen;
}
int SignEncode(uint8_t *vectorSign, uint32_t *vectorSignLen, Hex *R, Hex *S, BN_BigNum **bnR, BN_BigNum **bnS)
{
*bnR = BN_Create(R->len * BITS_OF_BYTE);
*bnS = BN_Create(S->len * BITS_OF_BYTE);
ASSERT_EQ(BN_Bin2Bn(*bnR, R->x, R->len), CRYPT_SUCCESS);
ASSERT_EQ(BN_Bin2Bn(*bnS, S->x, S->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_EncodeSign(*bnR, *bnS, vectorSign, vectorSignLen), CRYPT_SUCCESS);
return CRYPT_SUCCESS;
EXIT:
return ERROR;
}
/**
* @test SDV_CRYPTO_DSA_SET_PARA_API_TC001
* @title DSA: CRYPT_EAL_PkeySetPara test.
* @precon Registering memory-related functions.
* Dsa para vertors.
* @brief
* 1. Create the context of the dsa algorithm, expected result 1.
* 2. CRYPT_EAL_PkeySetPara: para = NULL, expected result 2.
* 3. CRYPT_EAL_PkeySetPara, expected result 3, the parameters are as follows:
* (1) p != NULL, pLen = 0
* (2) p = NULL, pLen != 0
* (3) q != NULL, qLen = 0
* (4) q = NULL, qLen != 0
* (5) g != NULL, gLen = 0
* (6) g = NULL, gLen != 0
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_NULL_INPUT
* 3. CRYPT_EAL_ERR_NEW_PARA_FAIL
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_SET_PARA_API_TC001(Hex *p, Hex *q, Hex *g, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
uint8_t tmp[1];
CRYPT_EAL_PkeyPara para;
para.id = CRYPT_PKEY_DSA;
para.para.dsaPara.p = p->x;
para.para.dsaPara.pLen = p->len;
para.para.dsaPara.q = q->x;
para.para.dsaPara.qLen = q->len;
para.para.dsaPara.g = g->x;
para.para.dsaPara.gLen = g->len;
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, NULL), CRYPT_NULL_INPUT);
if (p->x == NULL) {
para.para.dsaPara.p = tmp;
ASSERT_TRUE_AND_LOG("p != NULL, pLen = 0", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_EAL_ERR_NEW_PARA_FAIL);
para.para.dsaPara.p = p->x;
para.para.dsaPara.pLen = 128;
ASSERT_TRUE_AND_LOG("p = NULL, pLen != 0", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_EAL_ERR_NEW_PARA_FAIL);
para.para.dsaPara.pLen = p->len;
}
if (q->x == NULL) {
para.para.dsaPara.q = tmp;
ASSERT_TRUE_AND_LOG("q != NULL, qLen = 0", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_EAL_ERR_NEW_PARA_FAIL);
para.para.dsaPara.q = q->x;
para.para.dsaPara.qLen = 20;
ASSERT_TRUE_AND_LOG("q == NULL, qLen != 0", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_EAL_ERR_NEW_PARA_FAIL);
para.para.dsaPara.qLen = q->len;
}
if (g->x == NULL) {
para.para.dsaPara.g = tmp;
ASSERT_TRUE_AND_LOG("g != NULL, gLen = 0", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_EAL_ERR_NEW_PARA_FAIL);
para.para.dsaPara.g = g->x;
para.para.dsaPara.gLen = 128;
ASSERT_TRUE_AND_LOG("g!= NULL, gLen != 0", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_EAL_ERR_NEW_PARA_FAIL);
}
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DSA_CMP_API_TC001
* @title DSA: CRYPT_EAL_PkeyCmp test.
* @precon Registering memory-related functions.
* Dsa para vertors.
* @brief
* 1. Create the contexts(ctx1, ctx2) of the dsa algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 2
* 3. Set public key and para for ctx1, expected result 3
* 4. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 4
* 5. Set public key and para for ctx2, expected result 5
* 6. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 6
* @expect
* 1. Success, and contexts are not NULL.
* 2. CRYPT_DSA_ERR_KEY_INFO
* 3. CRYPT_SUCCESS
* 4. CRYPT_DSA_ERR_KEY_INFO
* 5. CRYPT_SUCCESS
* 6. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_CMP_API_TC001(Hex *p, Hex *q, Hex *g, Hex *y, int isProvider)
{
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPub pub = {0};
Set_DSA_Para(¶, NULL, &pub, p, q, g, NULL, y);
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default",
isProvider);
CRYPT_EAL_PkeyCtx *ctx2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_DSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default",
isProvider);
ASSERT_TRUE(ctx1 != NULL && ctx2 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_DSA_ERR_KEY_INFO); // no key and no para
ASSERT_EQ(CRYPT_EAL_PkeySetPara(ctx1, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx1, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_DSA_ERR_KEY_INFO); // ctx2 no pubkey
ASSERT_EQ(CRYPT_EAL_PkeySetPara(ctx2, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx2, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DSA_CTRL_API_TC001
* @title DSA: CRYPT_EAL_PkeyCtrl test.
* @precon Registering memory-related functions.
* @brief
* 1. Create the context(ctx) of the dsa algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyCtrl method:
* (1) val = NULL, expected result 2
* (2) len = 0, expected result 3
* (3) opt = CRYPT_CTRL_SET_RSA_PADDING, expected result 4
* @expect
* 1. Success, and contexts are not NULL.
* 2. CRYPT_NULL_INPUT
* 3. CRYPT_DSA_UNSUPPORTED_CTRL_OPTION
* 4. CRYPT_DSA_UNSUPPORTED_CTRL_OPTION
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_CTRL_API_TC001(int isProvider)
{
int32_t ref = 1;
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_DSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default",
isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_UP_REFERENCES, NULL, sizeof(uint32_t)), CRYPT_INVALID_ARG);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_UP_REFERENCES, &ref, 0), CRYPT_INVALID_ARG);
ASSERT_EQ(
CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_RSA_PADDING, &ref, sizeof(int32_t)), CRYPT_DSA_UNSUPPORTED_CTRL_OPTION);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DSA_GET_PARA_API_TC001
* @title DSA: CRYPT_EAL_PkeyGetPara test.
* @precon Registering memory-related functions.
* Dsa para vertors.
* @brief
* 1. Create the contexts of the dsa algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeySetPara method with correct parameters, expected result 2
* 3. Call the CRYPT_EAL_PkeySetPara method: para.id != pkey.id, expected result 3
* 4. Call the CRYPT_EAL_PkeySetPara method: pkey=NULL or para=NULL, expected result 4
* 5. Call the CRYPT_EAL_PkeySetPara method with correct parameters, expected result 5
* 6. Check whether the configured parameters are the same as the obtained parameters, expected result 6
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_EAL_ERR_ALGID
* 4. CRYPT_NULL_INPUT
* 5. CRYPT_SUCCESS
* 6. Parameters are equal.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_GET_PARA_API_TC001(Hex *p, Hex *q, Hex *g, int isProvider)
{
uint8_t buf_p[1030] = {0};
uint32_t bufLen = sizeof(buf_p);
uint8_t buf_q[1030] = {0};
uint8_t buf_g[1030] = {0};
Hex getP = {buf_p, bufLen};
Hex getQ = {buf_q, bufLen};
Hex getG = {buf_g, bufLen};
CRYPT_EAL_PkeyPara para1 = {0};
CRYPT_EAL_PkeyPara para2 = {0};
Set_DSA_Para(¶1, NULL, NULL, p, q, g, NULL, NULL);
Set_DSA_Para(¶2, NULL, NULL, &getP, &getQ, &getG, NULL, NULL);
TestMemInit();
CRYPT_EAL_PkeyCtx *pKey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default",
isProvider);
ASSERT_TRUE(pKey != NULL);
para2.id = CRYPT_PKEY_RSA;
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pKey, ¶1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPara(pKey, ¶2) == CRYPT_EAL_ERR_ALGID);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPara(NULL, ¶2) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPara(pKey, NULL) == CRYPT_NULL_INPUT);
para2.id = CRYPT_PKEY_DSA;
ASSERT_TRUE(CRYPT_EAL_PkeyGetPara(pKey, ¶2) == CRYPT_SUCCESS);
ASSERT_TRUE(para1.para.dsaPara.pLen == para2.para.dsaPara.pLen);
ASSERT_TRUE(memcmp(para1.para.dsaPara.p, para2.para.dsaPara.p, para1.para.dsaPara.pLen) == 0);
ASSERT_TRUE(para1.para.dsaPara.qLen == para2.para.dsaPara.qLen);
ASSERT_TRUE(memcmp(para1.para.dsaPara.q, para2.para.dsaPara.q, para1.para.dsaPara.qLen) == 0);
ASSERT_TRUE(para1.para.dsaPara.gLen == para2.para.dsaPara.gLen);
ASSERT_TRUE(memcmp(para1.para.dsaPara.g, para2.para.dsaPara.g, para1.para.dsaPara.gLen) == 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pKey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DSA_SIGN_VERIFY_FUNC_TC001
* @title DSA: Set(or copy) the key, sign, and verify the signature.
* @precon Registering memory-related functions.
* Dsa vertors.
* @brief
* 1. Mock BN_RandRange method to generate vector K.
* 2. Create the context of the dsa algorithm, expected result 1.
* 3. Set para, private key and public key, expected result 2.
* 4. Call the CRYPT_EAL_PkeyGetSignLen method to get sign length, expected result 3.
* 5. Allocate the memory for the signature, expected result 4.
* 6. Encoding r and s vectors, expected result 5.
* 7. Sign and compare the signatures of hitls and vector, expected result 6.
* 8. Verify, expected result 7.
* 9. Copy the ctx and repeat steps 7 through 8.
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. signLen > 0
* 4. Success
* 5. Success
* 6. CRYPT_SUCCESS, the two signatures are the same.
* 7. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_SIGN_VERIFY_FUNC_TC001(
int hashId, Hex *P, Hex *Q, Hex *G, Hex *Msg, Hex *X, Hex *Y, Hex *K, Hex *R, Hex *S, int isProvider)
{
if (IsMdAlgDisabled(hashId)) {
SKIP_TEST();
}
uint32_t signLen;
uint8_t *vectorSign = NULL;
uint8_t *hitlsSign = NULL;
uint32_t vectorSignLen, hitlsSignOutLen;
BN_BigNum *bnR = NULL;
BN_BigNum *bnS = NULL;
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyCtx *cpyCtx = NULL;
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
Set_DSA_Para(¶, &prv, &pub, P, Q, G, X, Y);
FuncStubInfo tmpRpInfo;
ASSERT_EQ(memcpy_s(g_kRandBuf, sizeof(g_kRandBuf), K->x, K->len), 0);
g_kRandBufLen = K->len;
STUB_Init();
STUB_Replace(&tmpRpInfo, BN_RandRangeEx, STUB_RandRangeK);
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_SUCCESS);
signLen = CRYPT_EAL_PkeyGetSignLen(pkey);
ASSERT_TRUE(signLen > 0);
/* Encoding r and s vectors */
vectorSign = (uint8_t *)malloc(signLen);
vectorSignLen = signLen;
ASSERT_EQ(SignEncode(vectorSign, &vectorSignLen, R, S, &bnR, &bnS), CRYPT_SUCCESS);
/* Sign */
hitlsSign = (uint8_t *)malloc(signLen);
hitlsSignOutLen = signLen;
ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, hashId, Msg->x, Msg->len, hitlsSign, &hitlsSignOutLen), CRYPT_SUCCESS);
/* Compare the signatures of hitls and vector. */
ASSERT_EQ(hitlsSignOutLen, vectorSignLen);
ASSERT_EQ(memcmp(vectorSign, hitlsSign, hitlsSignOutLen), 0);
/* Verify */
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, hashId, Msg->x, Msg->len, hitlsSign, hitlsSignOutLen), CRYPT_SUCCESS);
/* Copy the ctx and verify the signature. */
cpyCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_DSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(cpyCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCopyCtx(cpyCtx, pkey), CRYPT_SUCCESS);
hitlsSignOutLen = signLen;
ASSERT_EQ(CRYPT_EAL_PkeySign(cpyCtx, hashId, Msg->x, Msg->len, hitlsSign, &hitlsSignOutLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(cpyCtx, hashId, Msg->x, Msg->len, hitlsSign, hitlsSignOutLen), CRYPT_SUCCESS);
EXIT:
STUB_Reset(&tmpRpInfo);
free(vectorSign);
free(hitlsSign);
BN_Destroy(bnR);
BN_Destroy(bnS);
BSL_ERR_RemoveErrorStack(true);
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(cpyCtx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DSA_SIGN_VERIFY_DATA_FUNC_TC001
* @title DSA sets the key and performs signature and signature verification tests on the hash data.
* @precon Registering memory-related functions.
* Dsa vertors.
* @brief
* 1. Mock BN_RandRange method to generate vector K.
* 2. Create the context of the dsa algorithm, expected result 1.
* 3. Set para, private key and public key, expected result 2.
* 4. Call the CRYPT_EAL_PkeyGetSignLen method to get sign length, expected result 3.
* 5. Allocate the memory for the signature, expected result 4.
* 6. Encoding r and s vectors, expected result 5.
* 7. Compute the hash of the msg, sign and compare the signatures of hitls and vector, expected result 6.
* 8. Verify, expected result 7.
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. signLen > 0
* 4. Success
* 5. Success
* 6. CRYPT_SUCCESS, the two signatures are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_SIGN_VERIFY_DATA_FUNC_TC001(
int hashId, Hex *P, Hex *Q, Hex *G, Hex *Msg, Hex *X, Hex *Y, Hex *K, Hex *R, Hex *S, int isProvider)
{
if (IsMdAlgDisabled(hashId)) {
SKIP_TEST();
}
uint32_t signLen;
uint8_t *vectorSign = NULL;
uint8_t *hitlsSign = NULL;
uint32_t vectorSignLen, hitlsSignOutLen;
BN_BigNum *bnR = NULL;
BN_BigNum *bnS = NULL;
CRYPT_EAL_PkeyCtx *pkey = NULL;
Hex mdOut = {0};
FuncStubInfo tmpRpInfo;
ASSERT_EQ(memcpy_s(g_kRandBuf, sizeof(g_kRandBuf), K->x, K->len), 0);
g_kRandBufLen = K->len;
STUB_Init();
STUB_Replace(&tmpRpInfo, BN_RandRangeEx, STUB_RandRangeK);
CRYPT_EAL_PkeyPara para;
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub;
Set_DSA_Para(¶, &prv, &pub, P, Q, G, X, Y);
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_SUCCESS);
signLen = CRYPT_EAL_PkeyGetSignLen(pkey);
ASSERT_TRUE(signLen > 0);
/* Encoding r and s vectors */
vectorSign = (uint8_t *)malloc(signLen);
vectorSignLen = signLen;
ASSERT_EQ(SignEncode(vectorSign, &vectorSignLen, R, S, &bnR, &bnS), CRYPT_SUCCESS);
/* Calculates the hash of the msg. */
ASSERT_EQ(Compute_Md(hashId, Msg, &mdOut), SUCCESS);
/* Sign */
hitlsSign = (uint8_t *)malloc(signLen);
hitlsSignOutLen = signLen;
ASSERT_EQ(CRYPT_EAL_PkeySignData(pkey, mdOut.x, mdOut.len, hitlsSign, &hitlsSignOutLen), CRYPT_SUCCESS);
/* Compare the signatures of hitls and vector. */
ASSERT_EQ(hitlsSignOutLen, vectorSignLen);
ASSERT_EQ(memcmp(vectorSign, hitlsSign, hitlsSignOutLen), 0);
/* Verify the signature of the hash data. */
ASSERT_EQ(CRYPT_EAL_PkeyVerifyData(pkey, mdOut.x, mdOut.len, hitlsSign, hitlsSignOutLen), CRYPT_SUCCESS);
EXIT:
STUB_Reset(&tmpRpInfo);
if (mdOut.x != NULL) {
free(mdOut.x);
}
free(vectorSign);
free(hitlsSign);
BN_Destroy(bnR);
BN_Destroy(bnS);
BSL_ERR_RemoveErrorStack(true);
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DSA_GEN_FUNC_TC001
* @title DSA function test (gen a key pair).
* @precon Registering memory-related functions.
* Dsa vertors.
* @brief
* 1. Init the drbg, expected result 1.
* 2. Create the context(ctx) of the DSA algorithm, expected result 2.
* 3. Set para for dsa, expected result 3.
* 4. Generate a key pair, expected result 4.
* 5. Call the CRYPT_EAL_PkeyGetSignLen method to get sign length, expected result 5.
* 6. Allocate the memory for the signature, expected result 6.
* 7. Sign, expected result 7.
* 8. Verify, expected result 8.
* @expect
* 1. CRYPT_SUCCESS
* 2. Success, and two contexts are not NULL.
* 3. CRYPT_SUCCESS
* 4. CRYPT_SUCCESS
* 5. signLen > 0
* 6. Success
* 7. CRYPT_SUCCESS
* 8. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_GEN_FUNC_TC001(Hex *p, Hex *q, Hex *g, Hex *data, int isProvider)
{
CRYPT_EAL_PkeyCtx *ctx = NULL;
CRYPT_EAL_PkeyPara para = {0};
uint8_t *sign = NULL;
uint32_t signLen;
Set_DSA_Para(¶, NULL, NULL, p, q, g, NULL, NULL);
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_DSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(ctx, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx), CRYPT_SUCCESS);
signLen = CRYPT_EAL_PkeyGetSignLen(ctx);
ASSERT_TRUE(signLen > 0);
sign = (uint8_t *)malloc(signLen);
ASSERT_EQ(CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SHA256, data->x, data->len, sign, &signLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SHA256, data->x, data->len, sign, signLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
free(sign);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DSA_DUP_CTX_FUNC_TC001
* @title DSA: CRYPT_EAL_PkeyDupCtx test.
* @precon Registering memory-related functions.
* Dsa vertors.
* @brief
* 1. Create the context of the dsa algorithm, expected result 1.
* 2. Init the drbg, expected result 2.
* 3. Set para and generate a key pair, expected result 3.
* 4. Call the CRYPT_EAL_PkeyDupCtx method to dup dsa context, expected result 4.
* 5. Call the CRYPT_EAL_PkeyCmp method to compare public key, expected result 5.
* 6. Call the CRYPT_EAL_PkeyGetKeyBits to get keyLen from contexts, expected result 6.
* 7. Call the CRYPT_EAL_PkeyGetPub method to obtain the public key from the contexts, expected result 7.
* 8. Compare public keys, expected result 8.
* 9. Call the CRYPT_EAL_PkeyGetPrv method to obtain the private key from the contexts, expected result 9.
* 10. Compare privates keys, expected result 10.
* @expect
* 1. Success, and context is not NULL.
* 2-3. CRYPT_SUCCESS
* 4. Success, and context is not NULL.
* 5. CRYPT_SUCCESS
* 6. The key length obtained from both contexts is the same.
* 7. CRYPT_SUCCESS
* 8. The two public keys are the same.
* 9. CRYPT_SUCCESS
* 10. The two private keys are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_DUP_CTX_FUNC_TC001(Hex *p, Hex *q, Hex *g, int isProvider)
{
uint8_t *key1 = NULL;
uint8_t *key2 = NULL;
uint32_t keyLen1, keyLen2;
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPub pub1, pub2;
CRYPT_EAL_PkeyPrv prv1, prv2;
CRYPT_EAL_PkeyCtx *ctx = NULL;
CRYPT_EAL_PkeyCtx *dupCtx = NULL;
Set_DSA_Para(¶, NULL, NULL, p, q, g, NULL, NULL);
TestMemInit();
ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_DSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(ctx, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx), CRYPT_SUCCESS);
dupCtx = CRYPT_EAL_PkeyDupCtx(ctx);
ASSERT_TRUE(dupCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx, dupCtx), CRYPT_SUCCESS);
keyLen1 = CRYPT_EAL_PkeyGetKeyBits(ctx);
keyLen2 = CRYPT_EAL_PkeyGetKeyBits(dupCtx);
ASSERT_EQ(keyLen1, keyLen2);
key1 = calloc(1u, keyLen1);
key2 = calloc(1u, keyLen2);
ASSERT_TRUE(key1 != NULL && key2 != NULL);
Set_DSA_Pub(&pub1, key1, keyLen1);
Set_DSA_Pub(&pub2, key2, keyLen2);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctx, &pub1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(dupCtx, &pub2), CRYPT_SUCCESS);
ASSERT_COMPARE("Compare public key", key1, pub1.key.dsaPub.len, key2, pub2.key.dsaPub.len);
Set_DSA_Prv(&prv1, key1, keyLen1);
Set_DSA_Prv(&prv2, key2, keyLen2);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, &prv1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(dupCtx, &prv2), CRYPT_SUCCESS);
ASSERT_COMPARE("Compare private key", key1, prv1.key.dsaPrv.len, key2, prv2.key.dsaPrv.len);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_EAL_PkeyFreeCtx(dupCtx);
BSL_SAL_Free(key1);
BSL_SAL_Free(key2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DSA_KEY_PAIR_CHECK_FUNC_TC001
* @title DSA: key pair check.
* @precon Registering memory-related functions.
* @brief
* 1. Create two contexts(pubCtx, prvCtx) of the dsa algorithm, expected result 1
* 2. Set para and public key for pubCtx, expected result 2
* 3. Set para and private key for prvCtx, expected result 3
* 4. Init the drbg, expected result 5, expected result 4
* 5. Check whether the public key matches the private key, expected result 5
* @expect
* 1. Success, and contexts are not NULL.
* 2-4. CRYPT_SUCCESS
* 5. Return CRYPT_SUCCESS when expect is 1, CRYPT_DSA_VERIFY_FAIL otherwise.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_KEY_PAIR_CHECK_FUNC_TC001(Hex *P, Hex *Q, Hex *G, Hex *X, Hex *Y, int expect)
{
#if !defined(HITLS_CRYPTO_DSA_CHECK)
(void)P;
(void)Q;
(void)G;
(void)X;
(void)Y;
(void)expect;
SKIP_TEST();
#else
CRYPT_EAL_PkeyCtx *pubCtx = NULL;
CRYPT_EAL_PkeyCtx *prvCtx = NULL;
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
int expectRet = expect == 1 ? CRYPT_SUCCESS : CRYPT_DSA_PAIRWISE_CHECK_FAIL;
Set_DSA_Para(¶, &prv, &pub, P, Q, G, X, Y);
TestMemInit();
pubCtx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_DSA);
prvCtx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_DSA);
ASSERT_TRUE(pubCtx != NULL && prvCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pubCtx, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubCtx, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(prvCtx, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prv), CRYPT_SUCCESS);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), expectRet);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pubCtx);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DSA_GET_KEY_BITS_FUNC_TC001
* @title DSA: get key bits.
* @brief
* 1. Create a context of the DSA algorithm, expected result 1
* 2. Get key bits, expected result 2
* @expect
* 1. Success, and context is not NULL.
* 2. Equal to keyBits.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_GET_KEY_BITS_FUNC_TC001(int id, int keyBits, Hex *P, Hex *Q, Hex *G, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, id, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
CRYPT_EAL_PkeyPara para;
para.id = CRYPT_PKEY_DSA;
para.para.dsaPara.p = P->x;
para.para.dsaPara.pLen = P->len;
para.para.dsaPara.q = Q->x;
para.para.dsaPara.qLen = Q->len;
para.para.dsaPara.g = G->x;
para.para.dsaPara.gLen = G->len;
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetKeyBits(pkey) == (uint32_t)keyBits);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DSA_GET_SEC_BITS_FUNC_TC001
* @title DSA CRYPT_EAL_PkeyGetSecurityBits test.
* @precon nan
* @brief
* 1. Create the context of the dsa algorithm, expected result 1
* 2. Set dsa para, expected result 2
* 3. Call the CRYPT_EAL_PkeyGetSecurityBits Obtains secbits, expected result 3
* @expect
* 1. Success, and the context is not null.
* 2. CRYPT_SUCCESS
* 3. The return value is secBits.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_GET_SEC_BITS_FUNC_TC001(int id, int secBits, Hex *P, Hex *Q, Hex *G)
{
CRYPT_EAL_PkeyCtx *pkey = CRYPT_EAL_PkeyNewCtx(id);
ASSERT_TRUE(pkey != NULL);
CRYPT_EAL_PkeyPara para;
para.id = CRYPT_PKEY_DSA;
para.para.dsaPara.p = P->x;
para.para.dsaPara.pLen = P->len;
para.para.dsaPara.q = Q->x;
para.para.dsaPara.qLen = Q->len;
para.para.dsaPara.g = G->x;
para.para.dsaPara.gLen = G->len;
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetSecurityBits(pkey), secBits);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
#ifdef HITLS_CRYPTO_DSA_GEN_PARA
static uint8_t *g_dsa_seed = NULL;
static int32_t ref = 0;
int32_t STUB_CRYPT_EAL_Randbytes(uint8_t *byte, uint32_t len)
{
if (ref == 0) {
(void)memcpy_s(byte, len, g_dsa_seed, len);
ref = 1;
} else {
for (uint32_t i = 0; i < len; i++) {
byte[i] = (uint8_t)(rand() % 255); // mod 255 get 8bit number.
}
}
return CRYPT_SUCCESS;
}
int32_t STUB_CRYPT_EAL_RandbytesEx(CRYPT_EAL_LibCtx *libCtx, uint8_t *byte, uint32_t len)
{
(void)libCtx;
return STUB_CRYPT_EAL_Randbytes(byte, len);
}
#endif /* HITLS_CRYPTO_DSA */
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_VERIFY_PQ_FUNC_TC001(int algId, Hex *seed, char *pHex, char *qHex)
{
#ifndef HITLS_CRYPTO_DSA_GEN_PARA
(void)algId;
(void)seed;
(void)pHex;
(void)qHex;
SKIP_TEST();
#else
BSL_Buffer seedTmp = {seed->x, seed->len};
BN_BigNum *p = NULL;
BN_BigNum *q = NULL;
ASSERT_EQ(BN_Hex2Bn(&p, pHex), CRYPT_SUCCESS);
ASSERT_EQ(BN_Hex2Bn(&q, qHex), CRYPT_SUCCESS);
CRYPT_DSA_Para dsaPara = {p, q, NULL};
uint32_t counter = 5;
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_EQ(CryptDsaFips1864ValidatePq(algId, NULL, NULL, CRYPT_DSA_FFC_PARAM, &seedTmp, &dsaPara, counter), 0);
EXIT:
TestRandDeInit();
BN_Destroy(p);
BN_Destroy(q);
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_GEN_PQ_FUNC_TC001(int algId, int L, int N, Hex *seed, char *pHex, char *qHex)
{
#ifndef HITLS_CRYPTO_DSA_GEN_PARA
(void)algId;
(void)L;
(void)N;
(void)seed;
(void)pHex;
(void)qHex;
SKIP_TEST();
#else
BN_BigNum *pReq = NULL;
BN_BigNum *qReq = NULL;
uint32_t counter = 0;
g_dsa_seed = seed->x;
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
FuncStubInfo tmpRpInfo;
STUB_Init();
STUB_Replace(&tmpRpInfo, CRYPT_EAL_RandbytesEx, STUB_CRYPT_EAL_RandbytesEx);
CRYPT_RandRegist(STUB_CRYPT_EAL_Randbytes);
ref = 0;
DSA_FIPS186_4_Para fipsPara = {algId, 0, L, N};
BSL_Buffer seedTmp = {seed->x, seed->len};
CRYPT_DSA_Ctx *ctx = CRYPT_DSA_NewCtx();
ASSERT_TRUE(ctx != NULL);
CRYPT_DSA_Para *dsaPara = (CRYPT_DSA_Para *)BSL_SAL_Calloc(1, sizeof(CRYPT_DSA_Para));
ASSERT_TRUE(dsaPara != NULL);
ctx->para = dsaPara;
ASSERT_EQ(CryptDsaFips1864GenPq(ctx, &fipsPara, CRYPT_DSA_FFC_PARAM, &seedTmp, &counter), CRYPT_SUCCESS);
ASSERT_EQ(CryptDsaFips1864ValidatePq(algId, NULL, NULL, CRYPT_DSA_FFC_PARAM, &seedTmp, ctx->para, counter), 0);
ASSERT_EQ(BN_Hex2Bn(&pReq, pHex), CRYPT_SUCCESS);
ASSERT_EQ(BN_Hex2Bn(&qReq, qHex), CRYPT_SUCCESS);
ASSERT_EQ(BN_Cmp(ctx->para->p, pReq), 0);
ASSERT_EQ(BN_Cmp(ctx->para->q, qReq), 0);
EXIT:
CRYPT_EAL_RandDeinit();
STUB_Reset(&tmpRpInfo);
TestRandDeInit();
g_dsa_seed = NULL;
CRYPT_DSA_FreeCtx(ctx);
BN_Destroy(pReq);
BN_Destroy(qReq);
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_GEN_G_FUNC_TC001(char *pHex, char *qHex, char *gHex)
{
#ifndef HITLS_CRYPTO_DSA_GEN_PARA
(void)pHex;
(void)qHex;
(void)gHex;
SKIP_TEST();
#else
BN_BigNum *p = NULL;
BN_BigNum *q = NULL;
BN_BigNum *gReq = NULL;
ASSERT_EQ(BN_Hex2Bn(&p, pHex), CRYPT_SUCCESS);
ASSERT_EQ(BN_Hex2Bn(&q, qHex), CRYPT_SUCCESS);
ASSERT_EQ(BN_Hex2Bn(&gReq, gHex), CRYPT_SUCCESS);
CRYPT_DSA_Para dsaPara = {p, q, NULL};
ASSERT_EQ(CryptDsaFips1864GenUnverifiableG(&dsaPara), CRYPT_SUCCESS);
ASSERT_EQ(CryptDsaFips1864PartialValidateG(&dsaPara), CRYPT_SUCCESS);
ASSERT_EQ(BN_Cmp(dsaPara.g, gReq), 0);
EXIT:
BN_Destroy(p);
BN_Destroy(q);
BN_Destroy(dsaPara.g);
BN_Destroy(gReq);
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_GEN_G_FUNC_TC002(int algId, int index, Hex *seed, char *pHex, char *qHex)
{
#ifndef HITLS_CRYPTO_DSA_GEN_PARA
(void)algId;
(void)index;
(void)seed;
(void)pHex;
(void)qHex;
SKIP_TEST();
#else
BN_BigNum *p = NULL;
BN_BigNum *q = NULL;
ASSERT_EQ(BN_Hex2Bn(&p, pHex), CRYPT_SUCCESS);
ASSERT_EQ(BN_Hex2Bn(&q, qHex), CRYPT_SUCCESS);
DSA_FIPS186_4_Para fipsPara = {algId, index, 0, 0};
BSL_Buffer seedTmp = {seed->x, seed->len};
CRYPT_DSA_Para dsaPara = {p, q, NULL};
ASSERT_EQ(CryptDsaFips1864GenVerifiableG(&fipsPara, &seedTmp, &dsaPara), CRYPT_SUCCESS);
ASSERT_EQ(CryptDsaFips1864ValidateG(&fipsPara, &seedTmp, &dsaPara), CRYPT_SUCCESS);
EXIT:
BN_Destroy(p);
BN_Destroy(q);
BN_Destroy(dsaPara.g);
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_GEN_G_FUNC_TC003(int algId, int index, Hex *seed, char *pHex, char *qHex)
{
#ifndef HITLS_CRYPTO_DSA_GEN_PARA
(void)algId;
(void)index;
(void)seed;
(void)pHex;
(void)qHex;
SKIP_TEST();
#else
BN_BigNum *p = NULL;
BN_BigNum *q = NULL;
ASSERT_EQ(BN_Hex2Bn(&p, pHex), CRYPT_SUCCESS);
ASSERT_EQ(BN_Hex2Bn(&q, qHex), CRYPT_SUCCESS);
DSA_FIPS186_4_Para fipsPara = {algId, index, 0, 0};
BSL_Buffer seedTmp = {seed->x, seed->len};
CRYPT_DSA_Para dsaPara = {p, q, NULL};
ASSERT_EQ(CryptDsaFips1864GenVerifiableG(&fipsPara, &seedTmp, &dsaPara), CRYPT_DSA_ERR_TRY_CNT);
EXIT:
BN_Destroy(p);
BN_Destroy(q);
BN_Destroy(dsaPara.g);
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_GEN_G_FUNC_TC004(int algId, int index, Hex *seed, char *pHex, char *qHex, char *gHex)
{
#ifndef HITLS_CRYPTO_DSA_GEN_PARA
(void)algId;
(void)index;
(void)seed;
(void)pHex;
(void)qHex;
(void)gHex;
SKIP_TEST();
#else
BN_BigNum *p = NULL;
BN_BigNum *q = NULL;
BN_BigNum *gReq = NULL;
ASSERT_EQ(BN_Hex2Bn(&p, pHex), CRYPT_SUCCESS);
ASSERT_EQ(BN_Hex2Bn(&q, qHex), CRYPT_SUCCESS);
ASSERT_EQ(BN_Hex2Bn(&gReq, gHex), CRYPT_SUCCESS);
DSA_FIPS186_4_Para fipsPara = {algId, index, 0, 0};
BSL_Buffer seedTmp = {seed->x, seed->len};
CRYPT_DSA_Para dsaPara = {p, q, NULL};
ASSERT_EQ(CryptDsaFips1864GenVerifiableG(&fipsPara, &seedTmp, &dsaPara), CRYPT_SUCCESS);
ASSERT_EQ(CryptDsaFips1864ValidateG(&fipsPara, &seedTmp, &dsaPara), CRYPT_SUCCESS);
ASSERT_EQ(BN_Cmp(dsaPara.g, gReq), 0);
EXIT:
BN_Destroy(p);
BN_Destroy(q);
BN_Destroy(gReq);
BN_Destroy(dsaPara.g);
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_KEY_PAIR_GEN_BY_PARAM_FUNC_TC001(int flag, int gIndex)
{
#ifndef HITLS_CRYPTO_DSA_GEN_PARA
(void)flag;
(void)gIndex;
SKIP_TEST();
#else
int32_t algId = CRYPT_MD_SHA256;
uint32_t L = 2048;
uint32_t N = 256;
uint32_t seedLen = 256;
int32_t index = gIndex;
BSL_Param params[6] = {
{CRYPT_PARAM_DSA_ALGID, BSL_PARAM_TYPE_INT32, &algId, sizeof(int32_t), 0},
{CRYPT_PARAM_DSA_PBITS, BSL_PARAM_TYPE_UINT32, &L, sizeof(uint32_t), 0},
{CRYPT_PARAM_DSA_QBITS, BSL_PARAM_TYPE_UINT32, &N, sizeof(uint32_t), 0},
{CRYPT_PARAM_DSA_SEEDLEN, BSL_PARAM_TYPE_UINT32, &seedLen, sizeof(uint32_t), 0},
{CRYPT_PARAM_DSA_GINDEX, BSL_PARAM_TYPE_INT32, &index, sizeof(int32_t), 0},
BSL_PARAM_END
};
CRYPT_EAL_PkeyCtx *pkey = NULL;
uint8_t *sign = NULL;
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
#ifdef HITLS_CRYPTO_PROVIDER
ASSERT_EQ(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0), CRYPT_SUCCESS);
#endif
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_DSA);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_DSA_ERR_KEY_PARA);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GEN_PARA, params, 0), CRYPT_SUCCESS);
uint32_t genFlag = (uint8_t)flag;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_GEN_FLAG, &genFlag, sizeof(genFlag)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
uint32_t signLen = CRYPT_EAL_PkeyGetSignLen(pkey);
ASSERT_NE(signLen, 0);
sign = (uint8_t *)BSL_SAL_Calloc(signLen, 1);
ASSERT_TRUE(sign != NULL);
uint8_t data[] = "testdata";
uint32_t dataLen = 8;
ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SHA256, data, dataLen, sign, &signLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA256, data, dataLen, sign, signLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_RandDeinit();
CRYPT_EAL_PkeyFreeCtx(pkey);
BSL_SAL_Free(sign);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DSA_CHECK_KEYPAIR_TC001
* @brief
* Create a dsa key pairs to check the key pair consistency.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_CHECK_KEYPAIR_TC001(Hex *p, Hex *g, Hex *q, int isProvider)
{
#if !defined(HITLS_CRYPTO_DSA_CHECK)
(void)p;
(void)g;
(void)q;
(void)isProvider;
SKIP_TEST();
#else
CRYPT_EAL_PkeyPara para = {0};
Set_DSA_Para(¶, NULL, NULL, p, q, g, NULL, NULL);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default",
isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(pkey, pkey) == CRYPT_SUCCESS);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DSA_CHECK_KEYPAIR_INVALIED_TC001
* @brief
* Create a dsa key pairs to check the key pair consistency.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_CHECK_KEYPAIR_INVALIED_TC001(Hex *p, Hex *g, Hex *q, int isProvider)
{
#if !defined(HITLS_CRYPTO_DSA_CHECK)
(void)p;
(void)g;
(void)q;
(void)isProvider;
SKIP_TEST();
#else
TestMemInit();
uint8_t pubKey[1030];
uint32_t pubKeyLen = sizeof(pubKey);
uint8_t prvKey[1030];
uint32_t prvKeyLen = sizeof(prvKey);
CRYPT_EAL_PkeyPub pub = {0};
CRYPT_EAL_PkeyPrv prv = {0};
Set_DSA_Pub(&pub, pubKey, pubKeyLen);
Set_DSA_Prv(&prv, prvKey, prvKeyLen);
CRYPT_EAL_PkeyPara para = {0};
Set_DSA_Para(¶, NULL, NULL, p, q, g, NULL, NULL);
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default",
isProvider);
CRYPT_EAL_PkeyCtx *pubCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_DSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default",
isProvider);
CRYPT_EAL_PkeyCtx *prvCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_DSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default",
isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(prvCtx != NULL);
ASSERT_TRUE(pubCtx != NULL);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pubCtx, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(prvCtx, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS); // get prv and pub
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(NULL, NULL) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pubCtx, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx) == CRYPT_NULL_INPUT); // no prv key
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(prvCtx, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pubCtx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx) == CRYPT_DSA_PAIRWISE_CHECK_FAIL);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(pubCtx);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_DSA_CHECK_PRV_TC001
* @brief
* Create a dsa key pairs to check the prv key.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_DSA_CHECK_PRV_TC001(Hex *p, Hex *g, Hex *q, int isProvider)
{
#if !defined(HITLS_CRYPTO_DSA_CHECK)
(void)p;
(void)g;
(void)q;
(void)isProvider;
SKIP_TEST();
#else
TestMemInit();
int32_t bits;
CRYPT_EAL_PkeyPara para = {0};
Set_DSA_Para(¶, NULL, NULL, p, q, g, NULL, NULL);
BN_BigNum *x = NULL;
CRYPT_DSA_Ctx *ctx = NULL;
BN_BigNum *maxValue = NULL;
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_DSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default",
isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS); // get prv and pub
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SUCCESS);
ctx = (CRYPT_DSA_Ctx *)pkey->key;
x = ctx->x;
if (q->len != 0) {
ctx->x = ctx->para->q;
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_DSA_INVALID_PRVKEY);
} else {
maxValue = BN_Create(0);
bits = BN_Bits(ctx->para->p);
ASSERT_EQ(BN_SetLimb(maxValue, 1), CRYPT_SUCCESS);
BN_Lshift(maxValue, maxValue, bits);
ctx->x = maxValue;
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_DSA_INVALID_PRVKEY);
}
ctx->x = x;
EXIT:
BN_Destroy(maxValue);
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
#endif
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/dsa/test_suite_sdv_eal_dsa.c | C | unknown | 42,695 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "eal_md_local.h"
#include "eal_pkey_local.h"
#include "crypt_eal_md.h"
#include "crypt_eal_mac.h"
#include "crypt_dsa.h"
#include "crypt_eal_cipher.h"
#include "crypt_eal_pkey.h"
#include "eal_cipher_local.h"
#include "modes_local.h"
#include "eal_common.h"
static bool IsMacAlgIdValid(int id)
{
int algList[] = {
CRYPT_MAC_HMAC_MD5,
CRYPT_MAC_HMAC_SHA1,
CRYPT_MAC_HMAC_SHA224,
CRYPT_MAC_HMAC_SHA256,
CRYPT_MAC_HMAC_SHA384,
CRYPT_MAC_HMAC_SHA512,
CRYPT_MAC_HMAC_SHA3_224,
CRYPT_MAC_HMAC_SHA3_256,
CRYPT_MAC_HMAC_SHA3_384,
CRYPT_MAC_HMAC_SHA3_512,
CRYPT_MAC_HMAC_SM3,
CRYPT_MAC_CMAC_AES128,
CRYPT_MAC_CMAC_AES192,
CRYPT_MAC_CMAC_AES256,
CRYPT_MAC_GMAC_AES128,
CRYPT_MAC_GMAC_AES192,
CRYPT_MAC_GMAC_AES256,
CRYPT_MAC_SIPHASH64,
CRYPT_MAC_SIPHASH128
};
int algIdCnt = sizeof(algList) / sizeof(int);
for (int i = 0; i < algIdCnt; i++) {
if (id == algList[i]) {
return true;
}
}
return false;
}
static bool IsCipherAlgIdValid(int id)
{
int algList[] = {
CRYPT_CIPHER_AES128_CBC,
CRYPT_CIPHER_AES192_CBC,
CRYPT_CIPHER_AES256_CBC,
CRYPT_CIPHER_AES128_CTR,
CRYPT_CIPHER_AES192_CTR,
CRYPT_CIPHER_AES256_CTR,
CRYPT_CIPHER_AES128_ECB,
CRYPT_CIPHER_AES192_ECB,
CRYPT_CIPHER_AES256_ECB,
CRYPT_CIPHER_AES128_XTS,
CRYPT_CIPHER_AES256_XTS,
CRYPT_CIPHER_AES128_CCM,
CRYPT_CIPHER_AES192_CCM,
CRYPT_CIPHER_AES256_CCM,
CRYPT_CIPHER_AES128_GCM,
CRYPT_CIPHER_AES192_GCM,
CRYPT_CIPHER_AES256_GCM,
CRYPT_CIPHER_AES128_CFB,
CRYPT_CIPHER_AES192_CFB,
CRYPT_CIPHER_AES256_CFB,
CRYPT_CIPHER_AES128_OFB,
CRYPT_CIPHER_AES192_OFB,
CRYPT_CIPHER_AES256_OFB,
CRYPT_CIPHER_CHACHA20_POLY1305,
CRYPT_CIPHER_SM4_XTS,
CRYPT_CIPHER_SM4_CBC,
CRYPT_CIPHER_SM4_ECB,
CRYPT_CIPHER_SM4_CTR,
CRYPT_CIPHER_SM4_GCM,
CRYPT_CIPHER_SM4_CFB,
CRYPT_CIPHER_SM4_OFB,
};
int algIdCnt = sizeof(algList) / sizeof(int);
for (int i = 0; i < algIdCnt; i++) {
if (id == algList[i]) {
return true;
}
}
return false;
}
static bool IsPkeyAlgIdValid(int id)
{
int algList[] = {
CRYPT_PKEY_DSA,
CRYPT_PKEY_ED25519,
CRYPT_PKEY_X25519,
CRYPT_PKEY_RSA,
CRYPT_PKEY_DH,
CRYPT_PKEY_ECDSA,
CRYPT_PKEY_ECDH,
CRYPT_PKEY_SM2
};
int algIdCnt = sizeof(algList) / sizeof(int);
for (int i = 0; i < algIdCnt; i++) {
if (id == algList[i]) {
return true;
}
}
return false;
}
#define MD_OUTPUT_MAXSIZE 128
static int32_t MdTest(CRYPT_EAL_MdCTX *ctx, Hex *msg, Hex *hash)
{
(void)msg;
(void)hash;
uint8_t output[MD_OUTPUT_MAXSIZE];
uint32_t outLen = MD_OUTPUT_MAXSIZE;
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, msg->x, msg->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);
if (ctx->id != CRYPT_MD_SHAKE128 && ctx->id != CRYPT_MD_SHAKE256) {
ASSERT_TRUE(outLen == hash->len);
}
ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
return 0;
EXIT:
return -1;
}
/* END_HEADER */
/**
* @test SDV_CRYPTO_MAC_ALG_CHECK_TC001
* @title Check the validity of the mac algorithm ID.
* @precon nan
* @brief
* 1. Call the CRYPT_EAL_MacIsValidAlgId method, compare the returned value with 'isValid', expected result 1
* @expect
* 1. Both are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_MAC_ALG_CHECK_TC001(int algId)
{
int isValid = IsMacAlgIdValid(algId);
ASSERT_TRUE(CRYPT_EAL_MacIsValidAlgId(algId) == isValid);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CIPHER_ALG_CHECK_TC001
* @title Check the validity of the symmetric algorithm ID.
* @precon nan
* @brief
* 1. Call the CRYPT_EAL_CipherIsValidAlgId method, compare the returned value with 'isValid', expected result 1
* @expect
* 1. Both are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CIPHER_ALG_CHECK_TC001(int algId)
{
int isValid = IsCipherAlgIdValid(algId);
ASSERT_TRUE(CRYPT_EAL_CipherIsValidAlgId(algId) == isValid);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_MD_COPY_FUNC_TC001
* @title CRYPT_EAL_MdCopyCtx function test.
* @precon nan
* @brief
* 1. Create the context ctx of md algorithm, expected result 1
* 2. Calculate the hash of msg, and compare the calculated result with hash vector, expected result 2
* 3. Call to CRYPT_EAL_MdCopyCtx method to copy ctx, expected result 3
* 4. Calculate the hash of msg, and compare the calculated result with hash vector, expected result 4
* @expect
* 1. Success, the context is not null.
* 2. Success, the hashs are the same.
* 3. CRYPT_SUCCESS
* 4. Success, the hashs are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_MD_COPY_FUNC_TC001(int id, Hex *msg, Hex *hash)
{
TestMemInit();
CRYPT_EAL_MdCTX *cpyCtx = NULL;
CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdNewCtx(id);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(MdTest(ctx, msg, hash), 0);
cpyCtx = CRYPT_EAL_MdNewCtx(id);
ASSERT_TRUE(cpyCtx != NULL);
ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, ctx), CRYPT_SUCCESS);
ASSERT_EQ(MdTest(cpyCtx, msg, hash), 0);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
CRYPT_EAL_MdFreeCtx(cpyCtx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_EAL_PKEY_NEW_CTX_API_TC001
* @title CRYPT_EAL_PkeyNewCtx test.
* @precon nan
* @brief
* 1. Call the CRYPT_EAL_PkeyNewCtx method, algId is CRYPT_PKEY_MAX, expected result 1
* @expect
* 1. Return null.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_PKEY_NEW_CTX_API_TC001(void)
{
CRYPT_EAL_PkeyCtx *pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_MAX);
ASSERT_TRUE(pkey == NULL);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_EAL_PKEY_FREE_CTX_API_TC001
* @title CRYPT_EAL_PkeyFreeCtx test.
* @precon nan
* @brief
* 1. Call the CRYPT_EAL_PkeyFreeCtx method, ctx is null, expected result 1
* @expect
* 1. No memory leakage occurs.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_PKEY_FREE_CTX_API_TC001(void)
{
CRYPT_EAL_PkeyFreeCtx(NULL);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_EAL_PKEY_SET_PARA_API_TC001
* @title Check the validity of the asymmetric algorithm ID.
* @precon nan
* @brief
* 1. Call the CRYPT_EAL_PkeySetPara method:
* (1) pkey = NULL, expected result 1
* (2) para = NULL, expected result 1
* (3) pkey.id != para.id, expected result 2
* @expect
* 1. CRYPT_NULL_INPUT.
* 2. CRYPT_EAL_ERR_ALGID.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_PKEY_SET_PARA_API_TC001(void)
{
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyCtx *pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_DSA);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(NULL, ¶) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, NULL) == CRYPT_NULL_INPUT);
para.id = CRYPT_PKEY_RSA;
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_EAL_ERR_ALGID);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_EAL_PKEY_ALG_CHECK_TC001
* @title Check the validity of the asymmetric algorithm ID.
* @precon nan
* @brief
* 1. Call the CRYPT_EAL_PkeyIsValidAlgId method, compare the returned value with 'isValid', expected result 1
* @expect
* 1. Both are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_PKEY_ALG_CHECK_TC001(int algId)
{
int isValid = IsPkeyAlgIdValid(algId);
ASSERT_TRUE(CRYPT_EAL_PkeyIsValidAlgId(algId) == isValid);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_EAL_PKEY_SET_PRV_API_TC001
* @title CRYPT_EAL_PkeySetPrv bad arguments.
* @precon nan
* @brief
* 1. Call the CRYPT_EAL_PkeySetPrv:
* (1) pkey=NULL, expected result 1
* (2) prv=NULL, expected result 1
* (3) pkey.id != prv.id, expected result 2
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_EAL_ERR_ALGID
*/
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_PKEY_SET_PRV_API_TC001(void)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPrv prv = {0};
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_RSA);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(NULL, &prv), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, NULL), CRYPT_NULL_INPUT);
prv.id = CRYPT_PKEY_DSA;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_EAL_ERR_ALGID);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_EAL_PKEY_SET_PUB_API_TC001
* @title CRYPT_EAL_PkeySetPub bad arguments.
* @precon nan
* @brief
* 1. Call the CRYPT_EAL_PkeySetPub:
* (1) pkey=NULL, expected result 1
* (2) prv=NULL, expected result 1
* (3) pkey.id != prv.id, expected result 2
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_EAL_ERR_ALGID
*/
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_PKEY_SET_PUB_API_TC001(void)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPub pub = {0};
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_RSA);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(NULL, &pub), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, NULL), CRYPT_NULL_INPUT);
pub.id = CRYPT_PKEY_DSA;
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_EAL_ERR_ALGID);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_EAL_PKEY_GEN_API_TC001
* @title CRYPT_EAL_PkeyGen bad arguments.
* @precon nan
* @brief
* 1. Call the CRYPT_EAL_PkeySetPub: peky = NULL, expected result 1
* @expect
* 1. CRYPT_NULL_INPUT
*/
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_PKEY_GEN_API_TC001(void)
{
ASSERT_EQ(CRYPT_EAL_PkeyGen(NULL), CRYPT_NULL_INPUT);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_EAL_PKEY_CMP_TC001
* @title CRYPT_EAL_PkeyCmp Test.
* @precon nan
* @brief
* 1. Call the CRYPT_EAL_PkeyCmp, ctx1=NULL, ctx2=NULL, expected result 1
* 2. Call the CRYPT_EAL_PkeyCmp, ctx1=NULL, ctx2!=NULL or ctx1=NULL, ctx2!=NULL, expected result 2
* 3. Call the CRYPT_EAL_PkeyCmp, ctx1!=NULL, ctx2!=NULL, the content in ctx1 and ctx2 is empty, expected result 2
* 4. Call the CRYPT_EAL_PkeyCmp, ctx1!=NULL, ctx2!=NULL, ctx1.id!=ctx2.id, expected result 3
* 5. Call the CRYPT_EAL_PkeyCmp, ctx1->pkey=NULL, expected result 2
* @expect
* 1. CRYPT_SUCCESS
* 2. CRYPT_NULL_INPUT
* 3. CRYPT_EAL_PKEY_CMP_DIFF_KEY_TYPE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_PKEY_CMP_TC001(void)
{
CRYPT_EAL_PkeyCtx ctx1 = {0};
CRYPT_EAL_PkeyCtx ctx2 = {0};
CRYPT_EAL_PkeyCtx *pkey = NULL;
ASSERT_EQ(CRYPT_EAL_PkeyCmp(NULL, NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(NULL, &ctx2), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(&ctx1, NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(&ctx1, &ctx2), CRYPT_NULL_INPUT);
ctx1.id = CRYPT_PKEY_DH;
ctx2.id = CRYPT_PKEY_DSA;
ASSERT_EQ(CRYPT_EAL_PkeyCmp(&ctx1, &ctx2), CRYPT_EAL_PKEY_CMP_DIFF_KEY_TYPE);
ctx2.id = CRYPT_PKEY_DH;
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_DH);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(pkey->method != NULL);
ctx1.method = pkey->method;
ctx2.method = pkey->method;
ASSERT_EQ(CRYPT_EAL_PkeyCmp(&ctx1, &ctx2), CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_EAL_PKEY_GET_ID_API_TC001
* @title CRYPT_EAL_PkeyGetId Test.
* @precon nan
* @brief
* 1. Create the context(ctx) of pkeyId, expected result 1
* 2. Call the CRYPT_EAL_PkeyGetId to get id of ctx, expected result 2
* 3. Call the CRYPT_EAL_PkeyGetId to get id of NULL, expected result 3
* @expect
* 1. Success, and context is not NULL.
* 2. The getted id and pkeyId are the same.
* 3. Get id: CRYPT_PKEY_MAX
*/
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_PKEY_GET_ID_API_TC001(void)
{
int pkeyId = CRYPT_PKEY_DSA;
CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(pkeyId);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyGetId(ctx), pkeyId);
ASSERT_EQ(CRYPT_EAL_PkeyGetId(NULL), CRYPT_PKEY_MAX);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_EAL_PKEY_EXT_DATA_API_TC001
* @title CRYPT_EAL_PkeySetExtData/CRYPT_EAL_PkeyGetExtData Test.
* @precon nan
* @brief
* 1. Create the context(ctx) of pkeyId, expected result 1
* 2. Call the CRYPT_EAL_PkeySetExtData to set ext data, ctx is null, expected result 2
* 3. Call the CRYPT_EAL_PkeySetExtData to set ext data, all parameters are valid, expected result 3
* 4. Call the CRYPT_EAL_PkeyGetExtData to get ext data, ctx is null, expected result 4
* 5. Call the CRYPT_EAL_PkeyGetExtData to get ext data, all parameters are valid, expected result 5
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_NULL_INPUT
* 3. CRYPT_SUCCESS
* 4. Return null.
* 5. The returned value is not null and the value is correct.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_PKEY_EXT_DATA_API_TC001(void)
{
int pkeyId = CRYPT_PKEY_DSA;
int data = 1;
void *ptr = NULL;
CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(pkeyId);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetExtData(NULL, &data), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySetExtData(ctx, &data), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetExtData(NULL) == NULL);
ptr = CRYPT_EAL_PkeyGetExtData(ctx);
ASSERT_TRUE(ptr != NULL);
ASSERT_EQ(*(int *)ptr, data);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_EAL_REINIT_TC001
*/
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_REINIT_TC001(int id)
{
uint8_t key[16] = {0};
uint32_t keyLen = 16;
uint8_t iv[16] = {0};
uint32_t ivLen = 16;
uint8_t in[15] = {0};
uint32_t inLen = 15;
uint8_t out[64] = {0};
uint32_t outLen = 64;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx((CRYPT_CIPHER_AlgId)id);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);
(void)CRYPT_EAL_CipherSetPadding(ctx, CRYPT_PADDING_PKCS7);
ASSERT_EQ(CRYPT_EAL_CipherUpdate(ctx, in, inLen, out, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherReinit(ctx, iv, ivLen), CRYPT_SUCCESS);
struct ModesCipherCtx *ciphCtx = ((struct CryptEalCipherCtx *)ctx)->ctx;
ASSERT_TRUE(ciphCtx != NULL);
// Check data dataLen
ASSERT_EQ(ciphCtx->dataLen, 0);
for (uint32_t i = 0; i < EAL_MAX_BLOCK_LENGTH; i++) {
ASSERT_EQ(ciphCtx->data[i], 0);
}
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_EAL_REINIT_TC002
*/
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_REINIT_TC002(int id)
{
uint8_t key[32] = {0};
uint32_t keyLen = 32;
uint8_t iv[12] = {0};
uint32_t ivLen = 12;
uint8_t in[15] = {0};
uint32_t inLen = 15;
uint8_t out[64] = {0};
uint32_t outLen = 64;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx((CRYPT_CIPHER_AlgId)id);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherUpdate(ctx, in, inLen, out, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherReinit(ctx, iv, ivLen), CRYPT_SUCCESS);
struct ModesChaChaCtx *ciphCtx = ((struct CryptEalCipherCtx *)ctx)->ctx;
ASSERT_TRUE(ciphCtx != NULL);
// Check data dataLen
ASSERT_EQ(ciphCtx->chachaCtx.polyCtx.lastLen, 0);
uint32_t lastSize = (uint32_t)sizeof(ciphCtx->chachaCtx.polyCtx.last);
for (uint32_t i = 0; i < lastSize; i++) {
ASSERT_EQ(ciphCtx->chachaCtx.polyCtx.last[i], 0);
}
// Check aadLen cipherTextLen
ASSERT_EQ(ciphCtx->chachaCtx.aadLen, 0);
ASSERT_EQ(ciphCtx->chachaCtx.cipherTextLen, 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_EAL_REINIT_TC003
*/
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_REINIT_TC003(int id)
{
uint8_t key[16] = {0};
uint32_t keyLen = 16;
uint8_t iv[12] = {0};
uint32_t ivLen = 12;
uint8_t in[15] = {0};
uint32_t inLen = 15;
uint8_t out[64] = {0};
uint32_t outLen = 64;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx((CRYPT_CIPHER_AlgId)id);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key, keyLen, iv, ivLen, true), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherUpdate(ctx, in, inLen, out, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherReinit(ctx, iv, ivLen), CRYPT_SUCCESS);
struct ModesGcmCtx *ciphCtx = ((struct CryptEalCipherCtx *)ctx)->ctx;
ASSERT_TRUE(ciphCtx != NULL);
// Check data dataLen
ASSERT_EQ(ciphCtx->gcmCtx.aadLen, 0);
ASSERT_EQ(ciphCtx->gcmCtx.lastLen, 0);
ASSERT_EQ(ciphCtx->gcmCtx.plaintextLen, 0);
for (uint32_t i = 0; i < GCM_BLOCKSIZE; i++) {
ASSERT_EQ(ciphCtx->gcmCtx.ghash[i], 0);
}
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_EAL_GET_KEY_LEN_TC001
*/
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_GET_KEY_LEN_TC001(int algid, int paramId, int pubLen, int prvLen, int sharedLen)
{
CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(algid);
ASSERT_TRUE(ctx != NULL);
int32_t ret;
if (paramId != 0) {
ret = CRYPT_EAL_PkeySetParaById(ctx, paramId);
ASSERT_EQ(ret, CRYPT_SUCCESS);
}
uint32_t val = 0;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PUBKEY_LEN, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_EQ(val, pubLen);
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PRVKEY_LEN, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_EQ(val, prvLen);
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_SHARED_KEY_LEN, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_EQ(val, sharedLen);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_EAL_GET_KEY_LEN_TC002
*/
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_GET_KEY_LEN_TC002(int algid, int paramId, int pubLen, int prvLen)
{
CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(algid);
ASSERT_TRUE(ctx != NULL);
int32_t ret;
if (paramId != 0) {
ret = CRYPT_EAL_PkeySetParaById(ctx, paramId);
ASSERT_EQ(ret, CRYPT_SUCCESS);
}
uint32_t val = 0;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PUBKEY_LEN, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_EQ(val, pubLen);
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PRVKEY_LEN, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_EQ(val, prvLen);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_EAL_GET_KEY_LEN_TC003_1
*/
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_GET_KEY_LEN_TC003_1(int algid, int rsaBits, Hex *p, Hex *q, Hex *g)
{
TestRandInit();
CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(algid);
ASSERT_TRUE(ctx != NULL);
int32_t ret;
CRYPT_EAL_PkeyPara para = {0};
uint8_t e[3] = {1, 0, 1};
if (algid == CRYPT_PKEY_RSA) {
para.id = CRYPT_PKEY_RSA;
para.para.rsaPara.e = e;
para.para.rsaPara.eLen = 3;
para.para.rsaPara.bits = rsaBits;
} else {
para.id = algid; // DH or DSA
para.para.dhPara.p = p->x;
para.para.dhPara.q = q->x;
para.para.dhPara.g = g->x;
para.para.dhPara.pLen = p->len;
para.para.dhPara.qLen = q->len;
para.para.dhPara.gLen = g->len;
}
ASSERT_EQ(CRYPT_EAL_PkeySetPara(ctx, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx), CRYPT_SUCCESS);
uint32_t val = 0;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PUBKEY_LEN, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PRVKEY_LEN, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
if (algid == CRYPT_PKEY_DH) {
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_SHARED_KEY_LEN, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
}
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_EAL_GET_KEY_LEN_TC003_2
*/
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_GET_KEY_LEN_TC003_2(int algid, int rsaBits, Hex *p, Hex *q, Hex *g)
{
TestRandInit();
CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(algid);
ASSERT_TRUE(ctx != NULL);
int32_t ret;
CRYPT_EAL_PkeyPara para = {0};
uint8_t e[3] = {1, 0, 1};
if (algid == CRYPT_PKEY_RSA) {
para.id = CRYPT_PKEY_RSA;
para.para.rsaPara.e = e;
para.para.rsaPara.eLen = 3;
para.para.rsaPara.bits = rsaBits;
} else {
para.id = algid; // DH or DSA
para.para.dhPara.p = p->x;
para.para.dhPara.q = q->x;
para.para.dhPara.g = g->x;
para.para.dhPara.pLen = p->len;
para.para.dhPara.qLen = q->len;
para.para.dhPara.gLen = g->len;
}
ASSERT_EQ(CRYPT_EAL_PkeySetPara(ctx, ¶), CRYPT_SUCCESS);
uint32_t flag = CRYPT_ENABLE_SP800_KEYGEN_FLAG;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_GEN_FLAG, &flag, sizeof(flag));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx), CRYPT_DSA_PARA_ERROR);
flag = CRYPT_DISABLE_SP800_KEYGEN_FLAG;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_GEN_FLAG, &flag, sizeof(flag));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_EAL_GET_KEY_LEN_TC003_3
*/
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_GET_KEY_LEN_TC003_3(int algid, int rsaBits, Hex *p, Hex *q, Hex *g)
{
TestRandInit();
CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(algid);
ASSERT_TRUE(ctx != NULL);
int32_t ret;
CRYPT_EAL_PkeyPara para = {0};
uint8_t e[3] = {1, 0, 1};
if (algid == CRYPT_PKEY_RSA) {
para.id = CRYPT_PKEY_RSA;
para.para.rsaPara.e = e;
para.para.rsaPara.eLen = 3;
para.para.rsaPara.bits = rsaBits;
} else {
para.id = algid; // DH or DSA
para.para.dhPara.p = p->x;
para.para.dhPara.q = q->x;
para.para.dhPara.g = g->x;
para.para.dhPara.pLen = p->len;
para.para.dhPara.qLen = q->len;
para.para.dhPara.gLen = g->len;
}
ASSERT_EQ(CRYPT_EAL_PkeySetPara(ctx, ¶), CRYPT_SUCCESS);
uint32_t flag = CRYPT_ENABLE_SP800_KEYGEN_FLAG;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_GEN_FLAG, &flag, sizeof(flag));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/eal/test_suite_sdv_eal.c | C | unknown | 23,501 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "stub_replace.h"
#include "crypt_errno.h"
#include "crypt_utils.h"
#include "bsl_init.h"
#include "bsl_err.h"
#include "bsl_err_internal.h"
#include "crypt_types.h"
#include "crypt_eal_rand.h"
#include "crypt_eal_md.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_mac.h"
#include "crypt_eal_kdf.h"
#include "crypt_eal_cipher.h"
#include "asmcap_local.h"
#include "bsl_params.h"
#include "crypt_params_key.h"
/* END_HEADER */
#define DATA_LEN (64)
void ResetStatus(void)
{
CRYPT_EAL_RandDeinit();
BSL_GLOBAL_DeInit();
}
bool STUB_IsSupportAVX()
{
return false;
}
bool STUB_CRYPT_AES_AsmCheck()
{
return false;
}
bool STUB_IsSupportNEON()
{
return false;
}
bool STUB_IsSupportBMI1()
{
return false;
}
bool STUB_IsSupportMOVBE()
{
return false;
}
bool STUB_IsSupportAES()
{
return false;
}
int32_t STUB_CRYPT_GHASH_AsmCheck()
{
return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
}
int32_t STUB_CRYPT_POLY1305_AsmCheck()
{
return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
}
#define CRYPT_INIT_ABILITY_CPU_POS 0
#define CRYPT_INIT_ABILITY_BSL_POS 1
#define CRYPT_INIT_ABILITY_RAND_POS 2
#define CRYPT_INIT_ABILITY_BITMAP(value, pos) (((value) >> (pos)) & 0x1)
#define CRYPT_INIT_SUPPORT_ABILITY(cap, pos) (CRYPT_INIT_ABILITY_BITMAP(cap, pos) != 0)
#define DRBG_MAX_OUTPUT_SIZE (1 << 16)
/* @
* @test SDV_CRYPT_INIT_FUNC_TC001
* @spec -
* @title CRYPT_EAL_Init functional test as constructor
* @precon nan
* @brief 1. CRYPT_EAL_Init called as constructor
2. check if DRBG is initialized.
3、check if BSL is initialized.
* @expect 1. DRBG is initialized
2、BSL is initialized
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_INIT_FUNC_TC001()
{
#if defined(HITLS_EAL_INIT_OPTS)
uint8_t output[DATA_LEN];
uint32_t len = DATA_LEN;
int32_t ret = CRYPT_SUCCESS;
if(CRYPT_INIT_SUPPORT_ABILITY(HITLS_EAL_INIT_OPTS, CRYPT_INIT_ABILITY_RAND_POS)) {
ret = CRYPT_EAL_ERR_DRBG_REPEAT_INIT;
}
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_AES128_CTR, NULL, NULL, NULL, 0) == ret);
ASSERT_TRUE(CRYPT_EAL_Randbytes(output, len) == CRYPT_SUCCESS);
EXIT:
ResetStatus();
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CRYPT_EAL_Init_TC002
* @title Check if cpu capability is called at entry point.
* @precon nan
* @brief
* 1. STUB function
* 1. call CRYPT_EAL_CipherNewCtx
* @expect
* 1. CRYPT_EAL_CipherNewCtx returns NULL
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CRYPT_EAL_Init_TC002()
{
FuncStubInfo tmpStubInfo = {0};
CRYPT_EAL_CipherCtx *ctx = NULL;
STUB_Init();
ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
CRYPT_EAL_CipherFreeCtx(ctx);
#if defined(HITLS_CRYPTO_ASM_CHECK)
#if defined(__x86_64__)
#if defined(HITLS_CRYPTO_AES_ASM)
STUB_Replace(&tmpStubInfo, IsSupportAVX, STUB_IsSupportAVX);
ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx == NULL);
#endif
#if defined(HITLS_CRYPTO_SM4_ASM)
ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_SM4_CBC);
ASSERT_TRUE(ctx == NULL);
#endif
STUB_Reset(&tmpStubInfo);
#elif defined(__aarch64__)
#if defined(HITLS_CRYPTO_AES_ASM)
STUB_Replace(&tmpStubInfo, IsSupportAES, STUB_IsSupportAES);
ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx == NULL);
#endif
#endif
#endif
EXIT:
STUB_Reset(&tmpStubInfo);
ResetStatus();
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CRYPT_EAL_Init_TC003
* @title Check if cpu capability is called at entry point.
* @precon nan
* @brief
* 1. STUB function
* 1. call CRYPT_EAL_MdNewCtx
* @expect
* 1. CRYPT_EAL_CipherNewCtx returns NULL
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CRYPT_EAL_Init_TC003()
{
CRYPT_EAL_MdCTX *ctx = NULL;
ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA256);
ASSERT_TRUE(ctx != NULL);
CRYPT_EAL_MdFreeCtx(ctx);
#if defined(HITLS_CRYPTO_ASM_CHECK)
#if defined(__x86_64__)
#if defined(HITLS_CRYPTO_SM2_ASM)
FuncStubInfo tmpStubInfo = {0};
STUB_Init();
STUB_Replace(&tmpStubInfo, IsSupportMOVBE, STUB_IsSupportMOVBE);
ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SM3);
ASSERT_TRUE(ctx == NULL);
STUB_Reset(&tmpStubInfo);
#endif
#endif
#endif
EXIT:
ResetStatus();
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CRYPT_EAL_Init_TC004
* @title Check if cpu capability is called at entry point.
* @precon nan
* @brief
* 1. STUB function
* 1. call CRYPT_EAL_MdNewCtx
* @expect
* 1. CRYPT_EAL_CipherNewCtx returns NULL
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CRYPT_EAL_Init_TC004()
{
ResetStatus();
FuncStubInfo tmpStubInfo = {0};
STUB_Init();
uint32_t keyLen = DATA_LEN;
uint8_t key[keyLen];
uint32_t saltLen = DATA_LEN;
uint8_t salt[saltLen];
uint32_t it = 1024;
uint32_t outLen = DATA_LEN;
uint8_t out[outLen];
CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_PBKDF2);
ASSERT_TRUE(ctx != NULL);
CRYPT_MAC_AlgId macAlgId = CRYPT_MAC_HMAC_SHA256;
BSL_Param params[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&macAlgId, sizeof(macAlgId)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS,
key, keyLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
salt, saltLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_ITER, BSL_PARAM_TYPE_UINT32, &it,
sizeof(it)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
#if defined(HITLS_CRYPTO_ASM_CHECK)
#if defined(__x86_64__)
#if defined(HITLS_CRYPTO_SHA2_ASM)
STUB_Replace(&tmpStubInfo, IsSupportAVX, STUB_IsSupportAVX);
ASSERT_TRUE(CRYPT_EAL_KdfSetParam(ctx, params) != CRYPT_SUCCESS);
STUB_Reset(&tmpStubInfo);
#endif
#if defined(HITLS_CRYPTO_MD5_ASM)
STUB_Replace(&tmpStubInfo, IsSupportBMI1, STUB_IsSupportBMI1);
macAlgId = CRYPT_MAC_HMAC_MD5;
ASSERT_TRUE(CRYPT_EAL_KdfSetParam(ctx, params) != CRYPT_SUCCESS);
STUB_Reset(&tmpStubInfo);
#endif
#if defined(HITLS_CRYPTO_SM3_ASM)
STUB_Replace(&tmpStubInfo, IsSupportMOVBE, STUB_IsSupportMOVBE);
macAlgId = CRYPT_MAC_HMAC_SM3;
ASSERT_TRUE(CRYPT_EAL_KdfSetParam(ctx, params) != CRYPT_SUCCESS);
STUB_Reset(&tmpStubInfo);
#endif
#endif
#endif
EXIT:
CRYPT_EAL_KdfFreeCtx(ctx);
STUB_Reset(&tmpStubInfo);
ResetStatus();
}
/* END_CASE */
/**
* @test SDV_CRYPTO_CRYPT_EAL_Init_TC005
* @title Check if cpu capability is called at entry point.
* @precon nan
* @brief
* 1. STUB function
* 1. call CRYPT_EAL_MdNewCtx
* @expect
* 1. CRYPT_EAL_CipherNewCtx returns NULL
*/
/* BEGIN_CASE */
void SDV_CRYPTO_CRYPT_EAL_Init_TC005()
{
ResetStatus();
FuncStubInfo tmpStubInfo = {0};
CRYPT_EAL_RndCtx *ctx = NULL;
STUB_Init();
ctx = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA256, NULL, NULL);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_DrbgInstantiate(ctx, NULL, 0) == CRYPT_SUCCESS);
CRYPT_EAL_DrbgDeinit(ctx);
#if defined(HITLS_CRYPTO_ASM_CHECK)
#if defined(__x86_64__)
STUB_Replace(&tmpStubInfo, IsSupportAVX, STUB_IsSupportAVX);
#if defined(HITLS_CRYPTO_SHA1_ASM)
ctx = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA1, NULL, NULL);
ASSERT_TRUE(ctx == NULL);
ASSERT_NE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA1, NULL, NULL, NULL, 0), CRYPT_SUCCESS);
#endif
#if defined(HITLS_CRYPTO_SHA2_ASM)
ctx = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA256, NULL, NULL);
ASSERT_TRUE(ctx == NULL);
ASSERT_NE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0), CRYPT_SUCCESS);
#endif
#if defined(HITLS_CRYPTO_AES_ASM)
ctx = CRYPT_EAL_DrbgNew(CRYPT_RAND_AES128_CTR, NULL, NULL);
ASSERT_TRUE(ctx == NULL);
ASSERT_NE(CRYPT_EAL_RandInit(CRYPT_RAND_AES128_CTR, NULL, NULL, NULL, 0), CRYPT_SUCCESS);
#endif
#elif defined(__aarch64__)
#if defined(HITLS_CRYPTO_AES_ASM)
STUB_Replace(&tmpStubInfo, IsSupportAES, STUB_IsSupportAES);
ctx = CRYPT_EAL_DrbgNew(CRYPT_RAND_AES128_CTR, NULL, NULL);
ASSERT_TRUE(ctx == NULL);
ASSERT_NE(CRYPT_EAL_RandInit(CRYPT_RAND_AES128_CTR, NULL, NULL, NULL, 0), CRYPT_SUCCESS);
#endif
#endif
#endif
EXIT:
STUB_Reset(&tmpStubInfo);
ResetStatus();
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/ealinit/test_suite_sdv_ealinit.c | C | unknown | 9,001 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include "securec.h"
#include "crypt_bn.h"
#include "bsl_err.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "crypt_dsa.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_rand.h"
#include "stub_replace.h"
#include "crypt_util_rand.h"
#include "crypt_encode_internal.h"
#include "crypt_eal_md.h"
#include "crypt_dsa.h"
#include "crypt_ecdh.h"
#include "crypt_ecdsa.h"
#include "crypt_ecc.h"
#include "eal_pkey_local.h"
#define SUCCESS 0
#define ERROR (-1)
#define BITS_OF_BYTE 8
#define KEY_MAX_LEN 133
#define PUBKEY_MAX_LEN 133 // 521(The public key length of the longest curve.) * 2 + 1 1043
#define PRVKEY_MAX_LEN 65
#define ECC_MAX_BIT_LEN 521
#define CRYPT_EAL_PKEY_KEYMGMT_OPERATE 0
static uint8_t gkRandBuf[80];
static uint32_t gkRandBufLen = 0;
typedef struct {
uint8_t data[KEY_MAX_LEN];
uint32_t len;
} KeyData;
static int32_t RandFunc(uint8_t *randNum, uint32_t randLen)
{
const int maxNum = 255;
for (uint32_t i = 0; i < randLen; i++) {
randNum[i] = (uint8_t)(rand() % maxNum);
}
return 0;
}
static int32_t RandFuncEx(void *libCtx, uint8_t *randNum, uint32_t randLen)
{
(void)libCtx;
const int maxNum = 255;
for (uint32_t i = 0; i < randLen; i++) {
randNum[i] = (uint8_t)(rand() % maxNum);
}
return 0;
}
static int32_t STUB_RandRangeK(void *libCtx, BN_BigNum *r, const BN_BigNum *p)
{
(void)p;
(void)libCtx;
BN_Bin2Bn(r, gkRandBuf, gkRandBufLen);
return CRYPT_SUCCESS;
}
static int32_t EccPointToBuffer(Hex *pubKeyX, Hex *pubKeyY, CRYPT_PKEY_PointFormat pointFormat, KeyData *pubKey)
{
uint8_t value;
value = *(uint8_t *)(pubKeyY->x + pubKeyY->len - 1);
int sign = 0; /* The value 0 indicates an odd number.*/
if (value % 2 == 0) {
sign = 1;
}
switch (pointFormat) {
case CRYPT_POINT_COMPRESSED: {
pubKey->data[0] = (sign == 1) ? 0x02 : 0x03;
ASSERT_TRUE_AND_LOG(
"memcpy_s", memcpy_s(pubKey->data + 1, pubKey->len - 1, pubKeyX->x, pubKeyX->len) == EOK);
pubKey->len = pubKeyX->len + 1;
} break;
case CRYPT_POINT_UNCOMPRESSED: {
pubKey->data[0] = 0x04;
ASSERT_TRUE_AND_LOG(
"memcpy_s", memcpy_s(pubKey->data + 1, pubKey->len - 1, pubKeyX->x, pubKeyX->len) == EOK);
ASSERT_TRUE_AND_LOG("memcpy_s",
memcpy_s(pubKey->data + 1 + pubKeyX->len, pubKey->len - 1 - pubKeyX->len, pubKeyY->x, pubKeyY->len) ==
EOK);
pubKey->len = pubKeyX->len + pubKeyY->len + 1;
} break;
case CRYPT_POINT_HYBRID: {
pubKey->data[0] = (sign == 1) ? 0x06 : 0x07;
ASSERT_TRUE_AND_LOG(
"memcpy_s", memcpy_s(pubKey->data + 1, pubKey->len - 1, pubKeyX->x, pubKeyX->len) == EOK);
ASSERT_TRUE_AND_LOG("memcpy_s",
memcpy_s(pubKey->data + 1 + pubKeyX->len, pubKey->len - 1 - pubKeyX->len, pubKeyY->x, pubKeyY->len) ==
EOK);
pubKey->len = pubKeyX->len + pubKeyY->len + 1;
} break;
default:
return ERROR;
}
return SUCCESS;
EXIT:
return -1; /* -1 indicates an exception. */
}
static int GetPubKeyLen(int eccId)
{
switch (eccId) {
case CRYPT_ECC_NISTP224:
return 57; /* SECP224R1 */
case CRYPT_ECC_NISTP256: /* (32 * 2) + 1 SECP256R1, brainpoolP256r1 */
case CRYPT_ECC_BRAINPOOLP256R1:
return 65;
case CRYPT_ECC_NISTP384: /* (48 * 2) + 1 SECP384R1, brainpoolP384r1 */
case CRYPT_ECC_BRAINPOOLP384R1:
return 97;
case CRYPT_ECC_BRAINPOOLP512R1:
return 129; /* brainpoolP512r1 */
case CRYPT_ECC_NISTP521:
return 133; /* (66 * 2) + 1 SECP521R1 */
default:
return SUCCESS;
}
}
static int GetPrvKeyLen(int eccId)
{
switch (eccId) {
case CRYPT_ECC_NISTP224:
return 28;
case CRYPT_ECC_NISTP256:
case CRYPT_ECC_BRAINPOOLP256R1:
return 32;
case CRYPT_ECC_NISTP384:
case CRYPT_ECC_BRAINPOOLP384R1:
return 48;
case CRYPT_ECC_BRAINPOOLP512R1:
return 64;
case CRYPT_ECC_NISTP521:
return 66;
default:
return SUCCESS;
}
}
static void Ecc_SetPubKey(CRYPT_EAL_PkeyPub *pub, int id, uint8_t *key, uint32_t len)
{
pub->id = id;
pub->key.eccPub.data = key;
pub->key.eccPub.len = len;
}
static void Ecc_SetPrvKey(CRYPT_EAL_PkeyPrv *prv, int id, uint8_t *key, uint32_t len)
{
prv->id = id;
prv->key.eccPrv.data = key;
prv->key.eccPrv.len = len;
}
static int Ecc_GenKey(
int algId, int eccId, Hex *prvKeyVector, Hex *pubKeyX, Hex *pubKeyY, int pointFormat, int isProvider)
{
int ret;
FuncStubInfo tmpRpInfo;
CRYPT_EAL_PkeyCtx *pkey = NULL;
KeyData pubKeyVector = {{0}, KEY_MAX_LEN};
CRYPT_EAL_PkeyPub ecdsaPubKey = {0};
CRYPT_EAL_PkeyPrv ecdsaPrvKey = {0};
/* Init the DRBG */
TestMemInit();
/* Create a key structure. */
pkey = TestPkeyNewCtx(NULL, algId, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, eccId), CRYPT_SUCCESS);
/* Mock BN_RandRange to STUB_RandRangeK */
ASSERT_TRUE(memcpy_s(gkRandBuf, sizeof(gkRandBuf), prvKeyVector->x, prvKeyVector->len) == 0);
gkRandBufLen = prvKeyVector->len;
STUB_Init();
STUB_Replace(&tmpRpInfo, BN_RandRangeEx, STUB_RandRangeK);
/* Generate a key pair */
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
/* Set point format*/
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_ECC_POINT_FORMAT, &pointFormat, sizeof(uint32_t)), CRYPT_SUCCESS);
/* Get public key */
ecdsaPubKey.id = algId;
ecdsaPubKey.key.eccPub.data = (uint8_t *)malloc(GetPubKeyLen(eccId));
ASSERT_TRUE(ecdsaPubKey.key.eccPub.data != NULL);
ecdsaPubKey.key.eccPub.len = GetPubKeyLen(eccId);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &ecdsaPubKey), CRYPT_SUCCESS);
/* Get private key */
ecdsaPrvKey.id = algId;
ecdsaPrvKey.key.eccPrv.data = (uint8_t *)malloc(GetPrvKeyLen(eccId));
ASSERT_TRUE(ecdsaPrvKey.key.eccPrv.data != NULL);
ecdsaPrvKey.key.eccPrv.len = GetPrvKeyLen(eccId);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &ecdsaPrvKey), CRYPT_SUCCESS);
/* Convert the point to buffer */
ret = EccPointToBuffer(pubKeyX, pubKeyY, pointFormat, &pubKeyVector);
ASSERT_TRUE_AND_LOG("EccPointToBuffer", ret == CRYPT_SUCCESS);
ASSERT_COMPARE("Compare PubKey",
pubKeyVector.data,
ecdsaPubKey.key.eccPub.len,
ecdsaPubKey.key.eccPub.data,
ecdsaPubKey.key.eccPub.len);
ASSERT_COMPARE("Compare PrvKey",
prvKeyVector->x,
ecdsaPrvKey.key.eccPrv.len,
ecdsaPrvKey.key.eccPrv.data,
ecdsaPrvKey.key.eccPrv.len);
free(ecdsaPubKey.key.eccPub.data);
free(ecdsaPrvKey.key.eccPrv.data);
STUB_Reset(&tmpRpInfo);
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
return SUCCESS;
EXIT:
free(ecdsaPubKey.key.eccPub.data);
free(ecdsaPrvKey.key.eccPrv.data);
STUB_Reset(&tmpRpInfo);
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
return ERROR;
}
int EAL_PkeyNewCtx_Api_TC001(int algId)
{
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
/* Registers memory functions. */
TestMemInit();
pkeyCtx = CRYPT_EAL_PkeyNewCtx(algId);
ASSERT_TRUE_AND_LOG("CRYPT_EAL_PkeyNewCtx", pkeyCtx != NULL);
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
return SUCCESS;
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
return ERROR;
}
int EAL_PkeyFreeCtx_Api_TC001(int algId)
{
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
TestMemInit();
pkeyCtx = CRYPT_EAL_PkeyNewCtx(algId);
ASSERT_TRUE_AND_LOG("CRYPT_EAL_PkeyNewCtx", pkeyCtx != NULL);
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
pkeyCtx = NULL;
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
return SUCCESS;
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
return ERROR;
}
int EAL_PkeySetParaById_Api_TC001(int algId)
{
int ret = ERROR;
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
TestMemInit();
pkeyCtx = CRYPT_EAL_PkeyNewCtx(algId);
ASSERT_TRUE_AND_LOG("CRYPT_EAL_PkeyNewCtx", pkeyCtx != NULL);
ASSERT_TRUE_AND_LOG("Invalid Pkey", CRYPT_EAL_PkeySetParaById(NULL, CRYPT_ECC_NISTP224) == CRYPT_NULL_INPUT);
ASSERT_TRUE_AND_LOG("CRYPT_ECC_NISTP224", CRYPT_EAL_PkeySetParaById(pkeyCtx, CRYPT_ECC_NISTP224) == CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("CRYPT_ECC_NISTP256", CRYPT_EAL_PkeySetParaById(pkeyCtx, CRYPT_ECC_NISTP256) == CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("CRYPT_ECC_NISTP384", CRYPT_EAL_PkeySetParaById(pkeyCtx, CRYPT_ECC_NISTP384) == CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("CRYPT_ECC_NISTP521", CRYPT_EAL_PkeySetParaById(pkeyCtx, CRYPT_ECC_NISTP521) == CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG(
"CRYPT_ECC_BRAINPOOLP256R1", CRYPT_EAL_PkeySetParaById(pkeyCtx, CRYPT_ECC_BRAINPOOLP256R1) == CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG(
"CRYPT_ECC_BRAINPOOLP384R1", CRYPT_EAL_PkeySetParaById(pkeyCtx, CRYPT_ECC_BRAINPOOLP384R1) == CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG(
"CRYPT_ECC_BRAINPOOLP512R1", CRYPT_EAL_PkeySetParaById(pkeyCtx, CRYPT_ECC_BRAINPOOLP512R1) == CRYPT_SUCCESS);
ret = SUCCESS;
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
return ret;
}
int EAL_PkeyCtrl_Api_TC001(int algId, int type, int expect)
{
int ret = ERROR;
int32_t value = 1;
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
TestMemInit();
pkeyCtx = CRYPT_EAL_PkeyNewCtx(algId);
ASSERT_TRUE_AND_LOG("CRYPT_EAL_PkeyNewCtx", pkeyCtx != NULL);
ASSERT_TRUE_AND_LOG("CRYPT_EAL_PkeyCtrl", CRYPT_EAL_PkeyCtrl(pkeyCtx, type, &value, sizeof(int32_t)) == expect);
ret = SUCCESS;
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
return ret;
}
int EAL_PkeyCtrl_Api_TC002(int algId)
{
uint32_t ret, pointFormat;
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
TestMemInit();
pkeyCtx = CRYPT_EAL_PkeyNewCtx(algId);
ASSERT_TRUE_AND_LOG("CRYPT_EAL_PkeyNewCtx", pkeyCtx != NULL);
pointFormat = 1;
ret = CRYPT_EAL_PkeyCtrl(NULL, CRYPT_CTRL_SET_ECC_POINT_FORMAT, &pointFormat, sizeof(uint32_t));
ASSERT_TRUE_AND_LOG("pkey = null", ret == CRYPT_NULL_INPUT);
ret = CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_ECC_POINT_FORMAT, NULL, 0);
ASSERT_TRUE_AND_LOG("val = null, len = 0", ret == CRYPT_NULL_INPUT);
ret = CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_ECC_POINT_FORMAT, NULL, sizeof(uint32_t));
ASSERT_TRUE_AND_LOG("val = null, len != 0", ret == CRYPT_NULL_INPUT);
ret = CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_ECC_POINT_FORMAT, &pointFormat, 0);
ASSERT_TRUE_AND_LOG("val != null, len = 0", ret == CRYPT_ECC_PKEY_ERR_CTRL_LEN);
pointFormat = CRYPT_POINT_MAX;
ret = CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_ECC_POINT_FORMAT, &pointFormat, sizeof(uint32_t));
ASSERT_TRUE_AND_LOG("PointFormat = CRYPT_POINT_MAX", ret == CRYPT_ECC_PKEY_ERR_INVALID_POINT_FORMAT);
pointFormat = CRYPT_POINT_COMPRESSED;
ret = CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_ECC_POINT_FORMAT, &pointFormat, sizeof(uint32_t));
ASSERT_TRUE_AND_LOG("PointFormat = CRYPT_POINT_COMPRESSED", ret == CRYPT_SUCCESS);
pointFormat = CRYPT_POINT_UNCOMPRESSED;
ret = CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_ECC_POINT_FORMAT, &pointFormat, sizeof(uint32_t));
ASSERT_TRUE_AND_LOG("PointFormat = CRYPT_POINT_UNCOMPRESSED", ret == CRYPT_SUCCESS);
pointFormat = CRYPT_POINT_HYBRID;
ret = CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_ECC_POINT_FORMAT, &pointFormat, sizeof(uint32_t));
ASSERT_TRUE_AND_LOG("PointFormat = CRYPT_POINT_HYBRID", ret == CRYPT_SUCCESS);
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
return SUCCESS;
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
return ERROR;
}
int EAL_PkeyCtrl_Api_TC003(int algId, int eccId, Hex *pubKeyX, Hex *pubKeyY)
{
uint32_t ret, pointFormat;
CRYPT_EAL_PkeyCtx *ctx = NULL;
CRYPT_EAL_PkeyPub pub1 = {0};
CRYPT_EAL_PkeyPub pub2 = {0};
KeyData pubKeyVector1 = {{0}, KEY_MAX_LEN};
KeyData pubKeyVector2 = {{0}, KEY_MAX_LEN};
KeyData pubKeyVector3 = {{0}, KEY_MAX_LEN};
TestMemInit();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
/* Create a key structure. */
ctx = CRYPT_EAL_PkeyNewCtx(algId);
ASSERT_TRUE_AND_LOG("NewCtx", ctx != NULL);
ASSERT_TRUE_AND_LOG("CRYPT_EAL_PkeySetParaById", CRYPT_EAL_PkeySetParaById(ctx, eccId) == CRYPT_SUCCESS);
/* Convert the format of point to compressed. */
ret = EccPointToBuffer(pubKeyX, pubKeyY, CRYPT_POINT_COMPRESSED, &pubKeyVector1);
ASSERT_TRUE_AND_LOG("EccPointToBuffer", ret == CRYPT_SUCCESS);
/* Set public key. */
Ecc_SetPubKey(&pub1, algId, pubKeyVector1.data, pubKeyVector1.len);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &pub1), CRYPT_SUCCESS);
/* Set the point format to compressed. */
pointFormat = CRYPT_POINT_COMPRESSED;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_ECC_POINT_FORMAT, &pointFormat, sizeof(uint32_t));
ASSERT_TRUE_AND_LOG("Set CRYPT_POINT_COMPRESSED", ret == CRYPT_SUCCESS);
/* Set the point format to hybrid. */
pointFormat = CRYPT_POINT_HYBRID;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_ECC_POINT_FORMAT, &pointFormat, sizeof(uint32_t));
ASSERT_TRUE_AND_LOG("Set CRYPT_POINT_HYBRID", ret == CRYPT_SUCCESS);
/* Get the public key. */
Ecc_SetPubKey(&pub2, algId, pubKeyVector2.data, GetPubKeyLen(eccId));
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctx, &pub2), CRYPT_SUCCESS);
/* Convert the format of point to hybrid. */
ret = EccPointToBuffer(pubKeyX, pubKeyY, pointFormat, &pubKeyVector3);
ASSERT_TRUE_AND_LOG("EccPointToBuffer", ret == CRYPT_SUCCESS);
/* Compare */
ASSERT_TRUE_AND_LOG("Compare PubKey Len", pub2.key.eccPub.len == pubKeyVector3.len);
ASSERT_TRUE_AND_LOG("Compare PubKey", memcmp(pub2.key.eccPub.data, pubKeyVector3.data, pubKeyVector3.len) == 0);
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_EAL_RandDeinit();
return SUCCESS;
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_EAL_RandDeinit();
return ERROR;
}
int EAL_PkeyGetPrv_Api_TC001(int algId, Hex *prvKey)
{
int ret = ERROR;
CRYPT_EAL_PkeyCtx *ctx = NULL;
CRYPT_EAL_PkeyPrv prv1 = {0};
CRYPT_EAL_PkeyPrv prv2 = {0};
KeyData prvKeyBuffer = {{0}, KEY_MAX_LEN};
TestMemInit();
/* Create a key structure. */
ctx = CRYPT_EAL_PkeyNewCtx(algId);
ASSERT_TRUE_AND_LOG("NewCtx", ctx != NULL);
ASSERT_TRUE_AND_LOG("SetParaById", CRYPT_EAL_PkeySetParaById(ctx, CRYPT_ECC_NISTP224) == CRYPT_SUCCESS);
/* Get the private key when there is no private key. */
Ecc_SetPrvKey(&prv2, algId, prvKeyBuffer.data, GetPrvKeyLen(CRYPT_ECC_NISTP224));
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, &prv2), CRYPT_ECC_PKEY_ERR_EMPTY_KEY);
/* Set the private key. */
Ecc_SetPrvKey(&prv1, algId, prvKey->x, prvKey->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &prv1), CRYPT_SUCCESS);
/* Input parameter test of CRYPT_EAL_PkeyGetPrv. */
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(NULL, &prv2), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, NULL), CRYPT_NULL_INPUT);
prv2.id = CRYPT_PKEY_DH;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, &prv2), CRYPT_EAL_ERR_ALGID);
prv2.id = algId;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, &prv2), CRYPT_SUCCESS);
ret = SUCCESS;
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
return ret;
}
int EAL_PkeyGetPrv_Provider_Api_TC001(int algId, Hex *prvKey)
{
int ret = ERROR;
CRYPT_EAL_PkeyCtx *ctx = NULL;
CRYPT_EAL_PkeyPrv prv1 = {0};
CRYPT_EAL_PkeyPrv prv2 = {0};
KeyData prvKeyBuffer = {{0}, KEY_MAX_LEN};
TestMemInit();
/* Create a key structure. */
ctx = TestPkeyNewCtx(NULL, algId, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", true);
ASSERT_TRUE_AND_LOG("NewCtx", ctx != NULL);
ASSERT_TRUE_AND_LOG("SetParaById", CRYPT_EAL_PkeySetParaById(ctx, CRYPT_ECC_NISTP224) == CRYPT_SUCCESS);
/* Get the private key when there is no private key. */
Ecc_SetPrvKey(&prv2, algId, prvKeyBuffer.data, GetPrvKeyLen(CRYPT_ECC_NISTP224));
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, &prv2), CRYPT_ECC_PKEY_ERR_EMPTY_KEY);
/* Set the private key. */
Ecc_SetPrvKey(&prv1, algId, prvKey->x, prvKey->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &prv1), CRYPT_SUCCESS);
/* Input parameter test of CRYPT_EAL_PkeyGetPrv. */
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(NULL, &prv2), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, NULL), CRYPT_NULL_INPUT);
prv2.id = CRYPT_PKEY_DH;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, &prv2), CRYPT_EAL_ERR_ALGID);
prv2.id = algId;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, &prv2), CRYPT_SUCCESS);
ret = SUCCESS;
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
return ret;
}
int EAL_PkeyGetPub_Api_TC001(int algId, Hex *pubKeyX, Hex *pubKeyY)
{
int ret = ERROR;
CRYPT_EAL_PkeyCtx *ctx = NULL;
CRYPT_EAL_PkeyPub pub1, pub2;
KeyData pubKeyVector1 = {{0}, KEY_MAX_LEN};
KeyData pubKeyVector2 = {{0}, KEY_MAX_LEN};
TestMemInit();
/* Create a key structure. */
ctx = CRYPT_EAL_PkeyNewCtx(algId);
ASSERT_TRUE_AND_LOG("NewCtx", ctx != NULL);
ASSERT_TRUE_AND_LOG("SetParaById", CRYPT_EAL_PkeySetParaById(ctx, CRYPT_ECC_NISTP224) == CRYPT_SUCCESS);
/* Get the public key when there is no public key. */
Ecc_SetPubKey(&pub2, algId, pubKeyVector2.data, GetPubKeyLen(CRYPT_ECC_NISTP224));
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctx, &pub2), CRYPT_ECC_PKEY_ERR_EMPTY_KEY);
/* Set the public key. */
ASSERT_TRUE_AND_LOG("EccPointToBuffer",
EccPointToBuffer(pubKeyX, pubKeyY, CRYPT_POINT_UNCOMPRESSED, &pubKeyVector1) == CRYPT_SUCCESS);
Ecc_SetPubKey(&pub1, algId, pubKeyVector1.data, pubKeyVector1.len);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &pub1), CRYPT_SUCCESS);
/* Input parameter test of CRYPT_EAL_PkeyGetPub. */
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(NULL, &pub2), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctx, NULL), CRYPT_NULL_INPUT);
pub2.id = CRYPT_PKEY_DH;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctx, &pub2), CRYPT_EAL_ERR_ALGID);
pub2.id = algId;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctx, &pub2), CRYPT_SUCCESS);
ret = SUCCESS;
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
return ret;
}
int EAL_PkeyGetPub_Provider_Api_TC001(int algId, Hex *pubKeyX, Hex *pubKeyY)
{
int ret = ERROR;
CRYPT_EAL_PkeyCtx *ctx = NULL;
CRYPT_EAL_PkeyPub pub1, pub2;
KeyData pubKeyVector1 = {{0}, KEY_MAX_LEN};
KeyData pubKeyVector2 = {{0}, KEY_MAX_LEN};
TestMemInit();
/* Create a key structure. */
ctx = TestPkeyNewCtx(NULL, algId, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", true);
ASSERT_TRUE_AND_LOG("NewCtx", ctx != NULL);
ASSERT_TRUE_AND_LOG("SetParaById", CRYPT_EAL_PkeySetParaById(ctx, CRYPT_ECC_NISTP224) == CRYPT_SUCCESS);
/* Get the public key when there is no public key. */
Ecc_SetPubKey(&pub2, algId, pubKeyVector2.data, GetPubKeyLen(CRYPT_ECC_NISTP224));
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctx, &pub2), CRYPT_ECC_PKEY_ERR_EMPTY_KEY);
/* Set the public key. */
ASSERT_TRUE_AND_LOG("EccPointToBuffer",
EccPointToBuffer(pubKeyX, pubKeyY, CRYPT_POINT_UNCOMPRESSED, &pubKeyVector1) == CRYPT_SUCCESS);
Ecc_SetPubKey(&pub1, algId, pubKeyVector1.data, pubKeyVector1.len);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &pub1), CRYPT_SUCCESS);
/* Input parameter test of CRYPT_EAL_PkeyGetPub. */
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(NULL, &pub2), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctx, NULL), CRYPT_NULL_INPUT);
pub2.id = CRYPT_PKEY_DH;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctx, &pub2), CRYPT_EAL_ERR_ALGID);
pub2.id = algId;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctx, &pub2), CRYPT_SUCCESS);
ret = SUCCESS;
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
return ret;
}
int EAL_PkeySetPrv_Api_TC001(int algId, Hex *prvKey, Hex *errorPrvKey)
{
int ret = ERROR;
CRYPT_EAL_PkeyCtx *ctx = NULL;
CRYPT_EAL_PkeyPrv prv = {0};
TestMemInit();
/* Create a key structure. */
ctx = CRYPT_EAL_PkeyNewCtx(algId);
ASSERT_TRUE_AND_LOG("NewCtx", ctx != NULL);
/* Set the key without curve */
Ecc_SetPrvKey(&prv, algId, prvKey->x, prvKey->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &prv), CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeySetParaById(ctx, CRYPT_ECC_NISTP224) == CRYPT_SUCCESS);
/* Input parameter test of CRYPT_EAL_PkeySetPrv. */
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(NULL, &prv), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, NULL), CRYPT_NULL_INPUT);
prv.id = CRYPT_PKEY_DH;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &prv), CRYPT_EAL_ERR_ALGID);
prv.id = algId;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &prv), CRYPT_SUCCESS);
prv.key.eccPrv.data = errorPrvKey->x;
prv.key.eccPrv.len = errorPrvKey->len;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &prv), CRYPT_ECC_PKEY_ERR_INVALID_PRIVATE_KEY);
ret = SUCCESS;
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
return ret;
}
int EAL_PkeySetPrv_Api_TC002(int algId, Hex *prvKey, Hex *pubKeyX, Hex *pubKeyY)
{
int ret = ERROR;
CRYPT_EAL_PkeyCtx *ctx = NULL;
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub1, pub2;
KeyData pubKeyVector = {{0}, KEY_MAX_LEN};
KeyData pubKeyVector2 = {{0}, KEY_MAX_LEN};
TestMemInit();
/* Create a key structure. */
ctx = CRYPT_EAL_PkeyNewCtx(algId);
ASSERT_TRUE_AND_LOG("NewCtx", ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetParaById(ctx, CRYPT_ECC_NISTP224) == CRYPT_SUCCESS);
/* Set the public key. */
ASSERT_TRUE_AND_LOG("EccPointToBuffer",
EccPointToBuffer(pubKeyX, pubKeyY, CRYPT_POINT_UNCOMPRESSED, &pubKeyVector) == CRYPT_SUCCESS);
Ecc_SetPubKey(&pub1, algId, pubKeyVector.data, pubKeyVector.len);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &pub1), CRYPT_SUCCESS);
/* Set the private key. */
Ecc_SetPrvKey(&prv, algId, prvKey->x, prvKey->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &prv), CRYPT_SUCCESS);
/* Get the public key. */
Ecc_SetPubKey(&pub2, algId, pubKeyVector2.data, pubKeyVector2.len);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctx, &pub2), CRYPT_SUCCESS);
ret = SUCCESS;
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
return ret;
}
int EAL_PkeySetPub_Api_TC001(int algId, Hex *pubKeyVector)
{
int ret = ERROR;
CRYPT_EAL_PkeyCtx *ctx = NULL;
CRYPT_EAL_PkeyPub pub;
TestMemInit();
/* Create a key structure. */
ctx = CRYPT_EAL_PkeyNewCtx(algId);
ASSERT_TRUE_AND_LOG("NewCtx", ctx != NULL);
Ecc_SetPubKey(&pub, algId, pubKeyVector->x, pubKeyVector->len);
/* Set the pubilc key without curve. */
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &pub), CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeySetParaById(ctx, CRYPT_ECC_NISTP224) == CRYPT_SUCCESS);
/* Input parameter test of CRYPT_EAL_PkeySetPub. */
ASSERT_EQ(CRYPT_EAL_PkeySetPub(NULL, &pub), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, NULL), CRYPT_NULL_INPUT);
pub.id = CRYPT_PKEY_DH;
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &pub), CRYPT_EAL_ERR_ALGID);
pub.id = algId;
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &pub), CRYPT_SUCCESS);
ret = SUCCESS;
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
return ret;
}
int EAL_PkeySetPub_Api_TC002(int algId, Hex *prvKey, Hex *pubKey)
{
int ret = ERROR;
CRYPT_EAL_PkeyCtx *ctx = NULL;
CRYPT_EAL_PkeyPrv prv1, prv2;
(void)memset_s(&prv1.key.rsaPrv, sizeof(prv1.key.rsaPrv), 0, sizeof(prv1.key.rsaPrv));
(void)memset_s(&prv2.key.rsaPrv, sizeof(prv2.key.rsaPrv), 0, sizeof(prv2.key.rsaPrv));
CRYPT_EAL_PkeyPub ecdsaPubkey;
KeyData pubKeyVector = {{0}, KEY_MAX_LEN};
TestMemInit();
/* Create a key structure. */
ctx = CRYPT_EAL_PkeyNewCtx(algId);
ASSERT_TRUE_AND_LOG("NewCtx", ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetParaById(ctx, CRYPT_ECC_NISTP224) == CRYPT_SUCCESS);
/* Set the private key. */
Ecc_SetPrvKey(&prv1, algId, prvKey->x, prvKey->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &prv1), CRYPT_SUCCESS);
/* Set the public key. */
Ecc_SetPubKey(&ecdsaPubkey, algId, pubKey->x, pubKey->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &ecdsaPubkey), CRYPT_SUCCESS);
/* Get the private key. */
Ecc_SetPrvKey(&prv2, algId, pubKeyVector.data, pubKeyVector.len);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, &prv2), CRYPT_SUCCESS);
ret = SUCCESS;
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
return ret;
}
int EAL_PkeySetPub_Api_TC003(int algId, int eccId, Hex *pubKey, Hex *errorPubKey, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPub pub = {0};
TestMemInit();
/* Create a key structure. */
pkey = TestPkeyNewCtx(NULL, algId, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE_AND_LOG("NewCtx", pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetParaById(pkey, eccId) == CRYPT_SUCCESS);
/* Constructing a public key that is too long. */
pub.id = algId;
pub.key.eccPub.data = (uint8_t *)malloc(GetPubKeyLen(eccId) + 1); // Allocate for 1 more byte.
ASSERT_TRUE(pub.key.eccPub.data != NULL);
pub.key.eccPub.len = GetPubKeyLen(eccId) + 1;
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_ECC_ERR_POINT_CODE);
free(pub.key.eccPub.data);
/* Constructing a public key that is too short. */
pub.id = algId;
pub.key.eccPub.data = (uint8_t *)malloc(GetPubKeyLen(eccId) - 1); // Allocate 1 byte less.
ASSERT_TRUE(pub.key.eccPub.data != NULL);
pub.key.eccPub.len = GetPubKeyLen(eccId) - 1;
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_ECC_ERR_POINT_CODE);
free(pub.key.eccPub.data);
pub.key.eccPub.data = NULL;
/* Abnormal public key point: The length is abnormal. */
if (pubKey->x != NULL) {
Ecc_SetPubKey(&pub, algId, pubKey->x, pubKey->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_ECC_ERR_POINT_CODE);
}
if (errorPubKey->x != NULL) {
Ecc_SetPubKey(&pub, algId, errorPubKey->x, errorPubKey->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_ECC_POINT_NOT_ON_CURVE);
}
CRYPT_EAL_PkeyFreeCtx(pkey);
return SUCCESS;
EXIT:
if (pub.key.eccPub.data != NULL) {
free(pub.key.eccPub.data);
}
CRYPT_EAL_PkeyFreeCtx(pkey);
return ERROR;
}
int EAL_PkeyGetParaId_Api_TC001(int algId, int paraId)
{
int ret = ERROR;
CRYPT_EAL_PkeyCtx *pkey = NULL;
TestMemInit();
ASSERT_TRUE(CRYPT_EAL_PkeyGetParaId(pkey) == CRYPT_PKEY_PARAID_MAX);
pkey = CRYPT_EAL_PkeyNewCtx(algId);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyGetParaId(pkey) == CRYPT_PKEY_PARAID_MAX);
ASSERT_TRUE(CRYPT_EAL_PkeySetParaById(pkey, (CRYPT_PKEY_ParaId)paraId) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetParaId(pkey) == (CRYPT_PKEY_ParaId)paraId);
ret = SUCCESS;
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
return ret;
}
int EAL_PkeyCmp_Api_TC001(int algId, Hex *pubKeyX, Hex *pubKeyY)
{
int ret = ERROR;
CRYPT_EAL_PkeyPub pub = {0};
KeyData pubkey = {{0}, KEY_MAX_LEN};
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_EAL_PkeyCtx *ctx1 = CRYPT_EAL_PkeyNewCtx(algId);
CRYPT_EAL_PkeyCtx *ctx2 = CRYPT_EAL_PkeyNewCtx(algId);
ASSERT_TRUE(ctx1 != NULL && ctx2 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_ECC_KEY_PUBKEY_NOT_EQUAL);
ASSERT_EQ(EccPointToBuffer(pubKeyX, pubKeyY, CRYPT_POINT_COMPRESSED, &pubkey), CRYPT_SUCCESS);
Ecc_SetPubKey(&pub, algId, pubkey.data, pubkey.len);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx1, CRYPT_ECC_NISTP224), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx1, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_ECC_KEY_PUBKEY_NOT_EQUAL);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx2, CRYPT_ECC_NISTP256), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx2, &pub), CRYPT_ECC_ERR_POINT_CODE);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx2, CRYPT_ECC_NISTP224), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx2, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_SUCCESS);
ret = SUCCESS;
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
return ret;
}
int EAL_PkeyCmp_Provider_Api_TC001(int algId, Hex *pubKeyX, Hex *pubKeyY)
{
int ret = ERROR;
CRYPT_EAL_PkeyPub pub = {0};
KeyData pubkey = {{0}, KEY_MAX_LEN};
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_EAL_PkeyCtx *ctx1 = TestPkeyNewCtx(NULL, algId,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", true);
CRYPT_EAL_PkeyCtx *ctx2 = TestPkeyNewCtx(NULL, algId,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", true);
ASSERT_TRUE(ctx1 != NULL && ctx2 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_ECC_KEY_PUBKEY_NOT_EQUAL);
ASSERT_EQ(EccPointToBuffer(pubKeyX, pubKeyY, CRYPT_POINT_COMPRESSED, &pubkey), CRYPT_SUCCESS);
Ecc_SetPubKey(&pub, algId, pubkey.data, pubkey.len);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx1, CRYPT_ECC_NISTP224), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx1, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_ECC_KEY_PUBKEY_NOT_EQUAL);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx2, CRYPT_ECC_NISTP256), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx2, &pub), CRYPT_ECC_ERR_POINT_CODE);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx2, CRYPT_ECC_NISTP224), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx2, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_SUCCESS);
ret = SUCCESS;
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
return ret;
}
int EAL_PkeyGetPara_Func_TC001(int algId, Hex *p, Hex *a, Hex *b, Hex *x, Hex *y, Hex *n, Hex *h)
{
int ret = ERROR;
CRYPT_EAL_PkeyCtx *ctx = NULL;
uint8_t pData[ECC_MAX_BIT_LEN] = {0};
uint8_t aData[ECC_MAX_BIT_LEN] = {0};
uint8_t bData[ECC_MAX_BIT_LEN] = {0};
uint8_t nData[ECC_MAX_BIT_LEN] = {0};
uint8_t xData[ECC_MAX_BIT_LEN] = {0};
uint8_t yData[ECC_MAX_BIT_LEN] = {0};
uint8_t hData[ECC_MAX_BIT_LEN] = {0};
CRYPT_EAL_PkeyPara eccPara = {
.id = algId,
.para.eccPara.a = a->x,
.para.eccPara.aLen = a->len,
.para.eccPara.b = b->x,
.para.eccPara.bLen = b->len,
.para.eccPara.n = n->x,
.para.eccPara.nLen = n->len,
.para.eccPara.p = p->x,
.para.eccPara.pLen = p->len,
.para.eccPara.x = x->x,
.para.eccPara.xLen = x->len,
.para.eccPara.y = y->x,
.para.eccPara.yLen = y->len,
.para.eccPara.h = h->x,
.para.eccPara.hLen = h->len,
};
CRYPT_EAL_PkeyPara para = {.id = algId,
.para.eccPara.a = aData,
.para.eccPara.aLen = ECC_MAX_BIT_LEN,
.para.eccPara.b = bData,
.para.eccPara.bLen = ECC_MAX_BIT_LEN,
.para.eccPara.n = nData,
.para.eccPara.nLen = ECC_MAX_BIT_LEN,
.para.eccPara.p = pData,
.para.eccPara.pLen = ECC_MAX_BIT_LEN,
.para.eccPara.x = xData,
.para.eccPara.xLen = ECC_MAX_BIT_LEN,
.para.eccPara.y = yData,
.para.eccPara.yLen = ECC_MAX_BIT_LEN,
.para.eccPara.h = hData,
.para.eccPara.hLen = ECC_MAX_BIT_LEN};
TestMemInit();
ctx = CRYPT_EAL_PkeyNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
/* Set and get elliptic curve */
ASSERT_EQ(CRYPT_EAL_PkeySetPara(ctx, &eccPara), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPara(ctx, ¶), CRYPT_SUCCESS);
ASSERT_TRUE(para.para.eccPara.aLen == a->len);
ASSERT_TRUE(memcmp(aData, a->x, a->len) == 0);
ASSERT_TRUE(para.para.eccPara.bLen == b->len);
ASSERT_TRUE(memcmp(bData, b->x, b->len) == 0);
ASSERT_TRUE(para.para.eccPara.nLen == n->len);
ASSERT_TRUE(memcmp(nData, n->x, n->len) == 0);
ASSERT_TRUE(para.para.eccPara.pLen == p->len);
ASSERT_TRUE(memcmp(pData, p->x, p->len) == 0);
ASSERT_TRUE(para.para.eccPara.xLen == x->len);
ASSERT_TRUE(memcmp(xData, x->x, x->len) == 0);
ASSERT_TRUE(para.para.eccPara.yLen == y->len);
ASSERT_TRUE(memcmp(yData, y->x, y->len) == 0);
ASSERT_TRUE(para.para.eccPara.hLen == h->len);
ASSERT_TRUE(memcmp(hData, h->x, h->len) == 0);
ret = SUCCESS;
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
return ret;
}
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/ecc/test_suite_sdv_eal_ecc.base.c | C | unknown | 33,252 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* INCLUDE_BASE test_suite_sdv_eal_ecc */
/* BEGIN_HEADER */
#include "crypt_ecc.h"
#include "ecc_local.h"
/* END_HEADER */
#define ECDH_MAX_BIT_LEN 521
/**
* @test SDV_CRYPTO_ECDH_NEW_CTX_API_TC001
* @title ECDH CRYPT_EAL_PkeyNewCtx test.
* @precon Registering memory-related functions.
* @brief
* 1. Call the CRYPT_EAL_PkeyNewCtx method to create a pkey structure, algId is CRYPT_PKEY_ECDH, expected result 1
* 2. Releases the pkey structure, expected result 2
* @expect
* 1. Success, and the structure is not NULL.
* 2. No memory leakage occurs.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_NEW_CTX_API_TC001(void)
{
ASSERT_TRUE(EAL_PkeyNewCtx_Api_TC001(CRYPT_PKEY_ECDH) == SUCCESS);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_SET_PARA_BY_ID_API_TC001
* @title ECDH CRYPT_EAL_PkeySetParaById: Test the validity of input parameters.
* @precon Registering memory-related functions.
* @brief
* 1. Create the context of the ecdh algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeySetParaById method:
* (1) context = NULL, expected result 2.
* (2) CRYPT_PKEY_ParaId = CRYPT_ECC_NISTP224, expected result 3.
* (3) CRYPT_PKEY_ParaId = CRYPT_ECC_NISTP256, expected result 3.
* (4) CRYPT_PKEY_ParaId = CRYPT_ECC_NISTP384, expected result 3.
* (5) CRYPT_PKEY_ParaId = CRYPT_ECC_NISTP521, expected result 3.
* (6) CRYPT_PKEY_ParaId = CRYPT_ECC_BRAINPOOLP256R1, expected result 3.
* (7) CRYPT_PKEY_ParaId = CRYPT_ECC_BRAINPOOLP384R1, expected result 3.
* (8) CRYPT_PKEY_ParaId = CRYPT_ECC_BRAINPOOLP512R1, expected result 3.
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_NULL_INPUT
* 3. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_SET_PARA_BY_ID_API_TC001(void)
{
ASSERT_TRUE(EAL_PkeySetParaById_Api_TC001(CRYPT_PKEY_ECDH) == SUCCESS);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_EXCH_API_TC001
* @title ECDH CRYPT_EAL_PkeyComputeShareKey: Test the validity of parameters.
* @precon Registering memory-related functions.
* Test Vectors for ECDH : public key, private key, share secret
* @brief
* 1. Create two contexts(ecdhPkey, ecdhPkey2, peerEcdhPkey) of the ECDH algorithm, expected result 1
* 2. ecdhPkey: Set elliptic curve type and private key, expected result 2
* 3. peerEcdhPkey: Set elliptic curve type and public key, expected result 3
* 4. Call the CRYPT_EAL_PkeyComputeShareKey method before init the drbg, expected result 4:
* 5. Call the CRYPT_EAL_PkeyComputeShareKey method:
* (1) pkey = NULL, expected result 5
* (2) pubPkey = NULL, expected result 6
* (3) share = NULL, shareLen != 0, expected result 7
* (4) share != NULL, shareLen = NULL, expected result 8
* (5) share != NULL, shareLen = 1, expected result 9
* (6) all parameters are valid, but the local ctx does not have a private key, expected result 10
* (7) pkey.id != pubPkey.id, expected result 11
* (8) all parameters are valid, expected result 12
* @expect
* 1. Success, and contexts are not NULL.
* 2-3. CRYPT_SUCCESS
* 4. CRYPT_NO_REGIST_RAND
* 5-8. CRYPT_NULL_INPUT
* 9. CRYPT_ECC_BUFF_LEN_NOT_ENOUGH
* 10. CRYPT_ECDH_ERR_EMPTY_KEY
* 11. CRYPT_EAL_ERR_ALGID
* 12. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_EXCH_API_TC001(Hex *prvKeyVector, Hex *peerPubKeyVector, Hex *shareKeyVector)
{
CRYPT_EAL_PkeyCtx *ecdhPkey = NULL;
CRYPT_EAL_PkeyCtx *ecdhPkey2 = NULL;
CRYPT_EAL_PkeyCtx *peerEcdhPkey = NULL;
CRYPT_EAL_PkeyPrv ecdhPrvkey = {0};
CRYPT_EAL_PkeyPub peerEcdhPubkey;
uint8_t *shareKey = NULL;
uint32_t shareKeyLen;
TestMemInit();
ecdhPkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ECDH);
ecdhPkey2 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ECDH);
peerEcdhPkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ECDH);
ASSERT_TRUE(ecdhPkey != NULL && ecdhPkey2 != NULL && peerEcdhPkey != NULL);
/* Local: Set elliptic curve type and private key. */
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ecdhPkey, CRYPT_ECC_NISTP256), CRYPT_SUCCESS);
Ecc_SetPrvKey(&ecdhPrvkey, CRYPT_PKEY_ECDH, prvKeyVector->x, prvKeyVector->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ecdhPkey, &ecdhPrvkey), CRYPT_SUCCESS);
/* Peer: Set elliptic curve type and public key. */
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(peerEcdhPkey, CRYPT_ECC_NISTP256), CRYPT_SUCCESS);
Ecc_SetPubKey(&peerEcdhPubkey, CRYPT_PKEY_ECDH, peerPubKeyVector->x, peerPubKeyVector->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(peerEcdhPkey, &peerEcdhPubkey), CRYPT_SUCCESS);
/* Input parameter test of CRYPT_EAL_PkeyComputeShareKey. */
shareKey = (uint8_t *)malloc(shareKeyVector->len);
ASSERT_TRUE(shareKey != NULL);
shareKeyLen = shareKeyVector->len;
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(NULL, peerEcdhPkey, shareKey, &shareKeyLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(ecdhPkey, NULL, shareKey, &shareKeyLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(ecdhPkey, peerEcdhPkey, NULL, &shareKeyLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(ecdhPkey, peerEcdhPkey, shareKey, NULL), CRYPT_NULL_INPUT);
shareKeyLen = 1; // 1 is invalid
ASSERT_EQ(
CRYPT_EAL_PkeyComputeShareKey(ecdhPkey, peerEcdhPkey, shareKey, &shareKeyLen), CRYPT_ECC_BUFF_LEN_NOT_ENOUGH);
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(ecdhPkey2, peerEcdhPkey, shareKey, &shareKeyLen), CRYPT_ECDH_ERR_EMPTY_KEY);
ecdhPkey->id = CRYPT_PKEY_DH;
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(ecdhPkey, peerEcdhPkey, shareKey, &shareKeyLen), CRYPT_EAL_ERR_ALGID);
ecdhPkey->id = CRYPT_PKEY_ECDH;
shareKeyLen = shareKeyVector->len;
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(ecdhPkey, peerEcdhPkey, shareKey, &shareKeyLen), CRYPT_SUCCESS);
EXIT:
free(shareKey);
CRYPT_EAL_PkeyFreeCtx(ecdhPkey);
CRYPT_EAL_PkeyFreeCtx(ecdhPkey2);
CRYPT_EAL_PkeyFreeCtx(peerEcdhPkey);
TestRandDeInit();
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_CTRL_API_TC001
* @title ECDH CRYPT_EAL_PkeyCtrl: Test the validity of opt.
* @precon Registering memory-related functions.
* @brief
* 1. Create the context of the ecdh algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyCtrl method:
* (1) opt = CRYPT_CTRL_SET_RSA_RSAES_PKCSV15, expected result 2
* (2) opt = CRYPT_CTRL_SET_ECC_POINT_FORMAT, expected result 3
* (3) opt = CRYPT_CTRL_SET_ECC_USE_COFACTOR_MODE, expected result 4
* (4) opt = CRYPT_CTRL_SET_SM2_USER_ID, expected result 5
* (5) opt = CRYPT_CTRL_SET_RSA_PADDING, expected result 6
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_ECC_PKEY_ERR_UNSUPPORTED_CTRL_OPTION
* 3. CRYPT_SUCCESS
* 4. CRYPT_SUCCESS
* 5. CRYPT_ECC_PKEY_ERR_UNSUPPORTED_CTRL_OPTION
* 6. CRYPT_ECC_PKEY_ERR_UNSUPPORTED_CTRL_OPTION
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_CTRL_API_TC001(int type, int expect)
{
ASSERT_TRUE(EAL_PkeyCtrl_Api_TC001(CRYPT_PKEY_ECDH, type, expect) == SUCCESS);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_CTRL_API_TC002
* @title ECDH CRYPT_EAL_PkeyCtrl: Test the validity of pkey and value.
* @precon Registering memory-related functions.
* @brief
* 1. Create the context of the ecdh algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyCtrl method:
* (1) pkey = null, expected result 2
* (2) val = null, len = 0, expected result 3
* (3) val = null, len != 0, expected result 4
* (4) val != null, len = 0, expected result 5
* (5) PointFormat = CRYPT_POINT_MAX, expected result 6
* (6) PointFormat = CRYPT_POINT_COMPRESSED, expected result 7
* (7) PointFormat = CRYPT_POINT_UNCOMPRESSED, expected result 8
* (8) PointFormat = CRYPT_POINT_HYBRID, expected result 9
* @expect
* 1. Success, and the context is not NULL.
* 2-4. CRYPT_NULL_INPUT
* 5. CRYPT_ECC_PKEY_ERR_CTRL_LEN
* 6. CRYPT_ECC_PKEY_ERR_INVALID_POINT_FORMAT
* 7-9. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_CTRL_API_TC002(void)
{
ASSERT_TRUE(EAL_PkeyCtrl_Api_TC002(CRYPT_PKEY_ECDH) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_CTRL_API_TC003
* @title ECDH CRYPT_EAL_PkeyCtrl: Test the effect of the point format on the key.
* @precon Registering memory-related functions.
* public key point
* @brief
* 1. Create the context of the ecdh algorithm, expected result 1
* 2. Set the para by eccId(p-224/256/384/512, bp256r1/384r1/512/r1), expected result 2
* 3. Convert the format of the public key vector to COMPRESSED, expected result 3
* 4. Set the public key, expected result 4
* 5. Call the CRYPT_EAL_PkeyCtrl method to set point format to COMPRESSED, expected result 5
* 6. Call the CRYPT_EAL_PkeyCtrl method to set point format to HYBRID, expected result 6
* 7. Get the public key, expected result 7
* 8. Convert the format of the public key vector to HYBRID, expected result 8
* 9. Compare the output of the preceding two steps, expected result 9
* @expect
* 1. Success, and the context is not NULL.
* 2-8. CRYPT_SUCCESS
* 9. The two are same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_CTRL_API_TC003(int eccId, Hex *pubKeyX, Hex *pubKeyY)
{
if (IsCurveDisabled(eccId)) {
SKIP_TEST();
}
ASSERT_TRUE(EAL_PkeyCtrl_Api_TC003(CRYPT_PKEY_ECDH, eccId, pubKeyX, pubKeyY) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_GET_PRV_API_TC001
* @title ECDH CRYPT_EAL_PkeyGetPrv: Test the validity of parameters.
* @precon Registering memory-related functions.
* private key
* @brief
* 1. Create the context of the ecdh algorithm, expected result 1
* 2. Set the para by eccId(p-224), expected result 2
* 3. Get the private key when there is no private key, expected result 3
* 4. Set the private key, expected result 4
* 5. Call the CRYPT_EAL_PkeyGetPrv method:
* (1) pkey = null, expected result 5
* (2) prv = null, expected result 6
* (3) pkey.id != prv.id, expected result 7
* (4) Correct parameters., expected result 8
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_ECC_PKEY_ERR_EMPTY_KEY
* 4. CRYPT_SUCCESS
* 5-6. CRYPT_NULL_INPUT
* 7. CRYPT_EAL_ERR_ALGID
* 8. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_GET_PRV_API_TC001(Hex *prvKey)
{
ASSERT_TRUE(EAL_PkeyGetPrv_Api_TC001(CRYPT_PKEY_ECDH, prvKey) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_GET_PUB_API_TC001
* @title ECDH CRYPT_EAL_PkeyGetPub: Test the validity of parameters.
* @precon Registering memory-related functions.
* public key point
* @brief
* 1. Create the context of the ecdh algorithm, expected result 1
* 2. Set the para by eccId(p-224), expected result 2
* 3. Get the public key when there is no public key, expected result 3
* 4. Set the public key, expected result 4
* 5. Call the CRYPT_EAL_PkeyGetPub method:
* (1) pkey = null, expected result 5
* (2) pub = null, expected result 6
* (3) pkey.id != pub.id, expected result 7
* (4) Correct parameters, expected result 8
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_ECC_PKEY_ERR_EMPTY_KEY
* 4. CRYPT_SUCCESS
* 5-6. CRYPT_NULL_INPUT
* 7. CRYPT_EAL_ERR_ALGID
* 8. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_GET_PUB_API_TC001(Hex *pubKeyX, Hex *pubKeyY)
{
ASSERT_TRUE(EAL_PkeyGetPub_Api_TC001(CRYPT_PKEY_ECDH, pubKeyX, pubKeyY) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_SET_PRV_API_TC001
* @title ECDH CRYPT_EAL_PkeySetPrv: Test the validity of parameters.
* @precon Registering memory-related functions.
* Prepare valid private key and invalid private key.
* @brief
* 1. Create the context of the ecdh algorithm, expected result 1
* 2. Set the the valid private key before setting the curve, expected result 2
* 3. Set the para by eccId(p-224), expected result 3
* 4. Call the CRYPT_EAL_PkeySetPrv method:
* (1) pkey = null, expected result 4
* (2) prv = null, expected result 5
* (3) pkey.id != prv.id, expected result 6
* (4) Set the valid private key, expected result 7
* (5) Set the invalid private key, expected result 8
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_NULL_INPUT
* 3. CRYPT_SUCCESS
* 4-5. CRYPT_NULL_INPUT
* 6. CRYPT_EAL_ERR_ALGID
* 7. CRYPT_SUCCESS
* 8. CRYPT_ECC_PKEY_ERR_INVALID_PRIVATE_KEY
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_SET_PRV_API_TC001(Hex *prvKey, Hex *errorPrvKey)
{
ASSERT_TRUE(EAL_PkeySetPrv_Api_TC001(CRYPT_PKEY_ECDH, prvKey, errorPrvKey) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_SET_PRV_API_TC002
* @title Check whether the public key is cleared when the private key is set.
* @precon Registering memory-related functions.
* private key, public key point
* @brief
* 1. Create the context of the ecdh algorithm, expected result 1
* 2. Set the para by eccId(p-224), expected result 2
* 3. Set the the public key, expected result 3
* 4. Set the the private key, expected result 4
* 5. Get the the public key, expected result 5
* @expect
* 1. Success, and the context is not NULL.
* 2-5. CRYPT_SUCCESSY
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_SET_PRV_API_TC002(Hex *prvKey, Hex *pubKeyX, Hex *pubKeyY)
{
ASSERT_TRUE(EAL_PkeySetPrv_Api_TC002(CRYPT_PKEY_ECDH, prvKey, pubKeyX, pubKeyY) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_SET_PUB_API_TC001
* @title ECDH CRYPT_EAL_PkeySetPub: Test the validity of parameters.
* @precon Prepare valid public key.
* @brief
* 1. Create the context of the ecdh algorithm, expected result 1
* 2. Set the the public key before setting the curve, expected result 2
* 3. Set the para by eccId(p-224), expected result 3
* 4. Call the CRYPT_EAL_PkeySetPub method:
* (1) pkey = null, expected result 4
* (2) pub = null, expected result 5
* (3) pkey.id != pub.id, expected result 6
* (4) Set the valid public key, expected result 7
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_NULL_INPUT
* 3. CRYPT_SUCCESS
* 4-5. CRYPT_NULL_INPUT
* 6. CRYPT_EAL_ERR_ALGID
* 7. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_SET_PUB_API_TC001(Hex *pubKeyVector)
{
ASSERT_TRUE(EAL_PkeySetPub_Api_TC001(CRYPT_PKEY_ECDH, pubKeyVector) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_SET_PUB_API_TC002
* @title Check whether the private key is cleared when the public key is set.
* @precon Registering memory-related functions.
* public key, private key
* @brief
* 1. Create the context of the ecdh algorithm, expected result 1
* 2. Set the para by eccId(p-224), expected result 2
* 3. Set the the private key, expected result 3
* 4. Set the the public key, expected result 4
* 5. Get the the private key, expected result 5
* @expect
* 1. Success, and the context is not NULL.
* 2-5. CRYPT_SUCCESSY
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_SET_PUB_API_TC002(Hex *prvKey, Hex *pubKey)
{
ASSERT_TRUE(EAL_PkeySetPub_Api_TC002(CRYPT_PKEY_ECDH, prvKey, pubKey) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_SET_PUB_API_TC003
* @title Test the function of setting public keys of different lengths.
* @precon Public keys of different lengths.
* @brief
* 1. Create the context of the ecdh algorithm, expected result 1
* 2. Set the para by eccId(p-224/256/384/512, bp256r1/384r1/512/r1), expected result 2
* 3. Set public keys of different lengths, expected result 3
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_SUCCESSY
* 3. CRYPT_ECC_ERR_POINT_CODE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_SET_PUB_API_TC003(int eccId, Hex *pubKey, Hex *errorPubKey, int isProvider)
{
ASSERT_TRUE(EAL_PkeySetPub_Api_TC003(CRYPT_PKEY_ECDSA, eccId, pubKey, errorPubKey, isProvider) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_GET_PARA_ID_API_TC001
* @title ECDH CRYPT_EAL_PkeyGetParaId test.
* @precon Registering memory-related functions.
* @brief
* 1. Get para id before creating context, expected result 1
* 1. Create the context of the ecdh algorithm, expected result 2
* 2. Set para id(p-224/256/384/512), expected result 3
* 3. Get para id, expected result 4
* @expect
* 1. CRYPT_PKEY_PARAID_MAX
* 2. Success, and the context is not NULL.
* 3. CRYPT_SUCCESS
* 4. The obtained id is the same as the set id.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_GET_PARA_ID_API_TC001(int id)
{
ASSERT_TRUE(EAL_PkeyGetParaId_Api_TC001(CRYPT_PKEY_ECDH, id) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_DUP_CTX_API_TC001
* @title ECDH CRYPT_EAL_PkeyDupCtx test.
* @precon Registering memory-related functions.
* @brief
* 1. Create the context(pKeyCtx) of the ecdh algorithm, expected result 1
* 2. Set the para by eccId(p-224/256/384/512, bp256r1/384r1/512/r1), expected result 2
* 3. Call the CRYPT_EAL_PkeyDupCtx to dup context where the parameter is null, expected result 3
* 4. Call the CRYPT_EAL_PkeyDupCtx to dup context(newCtx), expected result 4
* 5. Get the reference count, expected result 5
* 6. Compare the pkey ids obtained from pKeyCtx and newCtx, , expected result 6
* 7. Compare the curve ids obtained from pKeyCtx and newCtx, expected result 7
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_SUCCESSY
* 3. Return null.
* 4. Return non-null.
* 5. The reference count is 1.
* 6-7. Both are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_DUP_CTX_API_TC001(int paraId, int isProvider)
{
CRYPT_EAL_PkeyCtx *pKeyCtx = NULL;
CRYPT_EAL_PkeyCtx *newCtx = NULL;
pKeyCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDH, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pKeyCtx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetParaById(pKeyCtx, (CRYPT_PKEY_ParaId)paraId) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyDupCtx(NULL) == NULL);
newCtx = CRYPT_EAL_PkeyDupCtx(pKeyCtx);
ASSERT_TRUE(newCtx != NULL);
ASSERT_EQ(newCtx->references.count, 1);
ASSERT_TRUE(CRYPT_EAL_PkeyGetId(pKeyCtx) == CRYPT_EAL_PkeyGetId(newCtx));
ASSERT_TRUE(CRYPT_EAL_PkeyGetParaId(pKeyCtx) == CRYPT_EAL_PkeyGetParaId(newCtx));
EXIT:
CRYPT_EAL_PkeyFreeCtx(pKeyCtx);
CRYPT_EAL_PkeyFreeCtx(newCtx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_CMP_FUNC_TC001
* @title ECDH: CRYPT_EAL_PkeyCmp test.
* @precon Registering memory-related functions.
* @brief
* 1. Create the contexts(ctx1, ctx2) of the ecdh algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 2
* 3. Set para id CRYPT_ECC_NISTP224 and public key for ctx1, expected result 3
* 4. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 4
* 5. Set para id CRYPT_ECC_NISTP256 for ctx2, expected result 5
* 6. Set public key for ctx2, expected result 6
* 7. Set para id CRYPT_ECC_NISTP224 and public key for ctx2, expected result 7
* 8. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 8
* @expect
* 1. Success, and contexts are not NULL.
* 2. CRYPT_ECC_KEY_PUBKEY_NOT_EQUAL
* 3. CRYPT_SUCCESS
* 4. CRYPT_ECC_KEY_PUBKEY_NOT_EQUAL
* 5. CRYPT_SUCCESS
* 6. CRYPT_ECC_ERR_POINT_CODE
* 7. CRYPT_SUCCESS
* 8. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_CMP_FUNC_TC001(Hex *pubKeyX, Hex *pubKeyY)
{
ASSERT_TRUE(EAL_PkeyCmp_Api_TC001(CRYPT_PKEY_ECDH, pubKeyX, pubKeyY) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_EXCH_FUNC_TC001
* @title ECDH key exchange test: set the key and exchange the key.
* @precon Registering memory-related functions.
* @brief
* 1. Create two contexts(ecdhPkey, peerEcdhPubPkey) of the ECDH algorithm, expected result 1
* 2. Init the drbg, expected result 2
* 3. ecdhPkey: Set elliptic curve type(p-224/256/384/512, bp256r1/384r1/512/r1) and private key, expected result 3
* 4. peerEcdhPubPkey: Set elliptic curve type(p-224/256/384/512, bp256r1/384r1/512/r1) and public key(compressed/
* uncompressed/hybrid), expected result 4
* 5. Compute the shared key, expected result 5
* 6. Compare the output shared secret and shared secret vector, expected result 6
* @expect
* 1. Success, and two contexts are not NULL.
* 2-5. CRYPT_SUCCESS
* 6. The two shared secrets are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_EXCH_FUNC_TC001(
int eccId, Hex *prvKeyVector, Hex *pubKeyX, Hex *pubKeyY, int pointFormat, Hex *shareKeyVector, int isProvider)
{
if (IsCurveDisabled(eccId)) {
SKIP_TEST();
}
int ret;
CRYPT_EAL_PkeyCtx *ecdhPkey = NULL;
CRYPT_EAL_PkeyCtx *peerEcdhPubPkey = NULL;
CRYPT_EAL_PkeyPrv ecdhPrvkey = {0};
CRYPT_EAL_PkeyPub peerEcdhPubkey;
KeyData pubKeyVector = {{0}, KEY_MAX_LEN};
uint8_t *shareKey = NULL;
uint32_t shareKeyLen;
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ecdhPkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
peerEcdhPubPkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ECDH);
ASSERT_TRUE(ecdhPkey != NULL && peerEcdhPubPkey != NULL);
/* Local: Set elliptic curve type and private key. */
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ecdhPkey, eccId), CRYPT_SUCCESS);
Ecc_SetPrvKey(&ecdhPrvkey, CRYPT_PKEY_ECDH, prvKeyVector->x, prvKeyVector->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ecdhPkey, &ecdhPrvkey), CRYPT_SUCCESS);
/* Peer: Set elliptic curve type and public key. */
/* Create a key structure to store the public key. */
ret = EccPointToBuffer(pubKeyX, pubKeyY, pointFormat, &pubKeyVector);
ASSERT_TRUE_AND_LOG("EccPointToVector", ret == CRYPT_SUCCESS);
Ecc_SetPubKey(&peerEcdhPubkey, CRYPT_PKEY_ECDH, pubKeyVector.data, pubKeyVector.len);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(peerEcdhPubPkey, eccId), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(peerEcdhPubPkey, &peerEcdhPubkey), CRYPT_SUCCESS);
/* Compute share secret. */
shareKeyLen = CRYPT_EAL_PkeyGetKeyLen(ecdhPkey);
ASSERT_TRUE(shareKeyLen > shareKeyVector->len);
shareKey = (uint8_t *)malloc(shareKeyVector->len);
ASSERT_TRUE(shareKey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(ecdhPkey, peerEcdhPubPkey, shareKey, &shareKeyLen), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("Compare ShareKey Len", shareKeyLen == shareKeyVector->len);
ASSERT_COMPARE("Compare ShareKey", shareKey, shareKeyLen, shareKeyVector->x, shareKeyVector->len);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ecdhPkey);
CRYPT_EAL_PkeyFreeCtx(peerEcdhPubPkey);
TestRandDeInit();
free(shareKey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_GET_PARA_FUNC_TC001
* @title ECDH CRYPT_EAL_PkeyGetPara test.
* @precon Registering memory-related functions.
* @brief
* 1. Create context of the ECDH algorithm, expected result 1
* 2. Set para, expected result 2
* 3. Get para, expected result 3
* 4. Check whether the set parameters and the obtained parameters are the same, expected result 4
* @expect
* 1. Success, and two contexts are not NULL.
* 2-3. CRYPT_SUCCESS
* 4. The parameters are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_GET_PARA_FUNC_TC001(Hex *p, Hex *a, Hex *b, Hex *x, Hex *y, Hex *n, Hex *h)
{
ASSERT_TRUE(EAL_PkeyGetPara_Func_TC001(CRYPT_PKEY_ECDH, p, a, b, x, y, n, h) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_GEN_KEY_FUNC_TC001
* @title ECDH CRYPT_EAL_PkeyGen test.
* @precon Registering memory-related functions.
* @brief
* 1. Create context of the ECDH algorithm, expected result 1
* 2. Set elliptic curve type, expected result 2
* 3. Mock BN_RandRange to STUB_RandRangeK, expected result 3
* 4. Init the drbg, expected result 4
* 5. Call the CRYPT_EAL_PkeyGen method to generate a key pair, expected result 5
* 6. Get public key and private key, expected result 6
* 7. Compare the getted key and vector, expected result 7
* @expect
* 1. Success, and two contexts are not NULL.
* 2. CRYPT_SUCCESS
* 3. SUccess.
* 4-6. CRYPT_SUCCESS
* 7. The getted key and vector are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_GEN_KEY_FUNC_TC001(
int eccId, Hex *prvKeyVector, Hex *pubKeyX, Hex *pubKeyY, int pointFormat, int isProvider)
{
if (IsCurveDisabled(eccId)) {
SKIP_TEST();
}
Ecc_GenKey(CRYPT_PKEY_ECDH, eccId, prvKeyVector, pubKeyX, pubKeyY, pointFormat, isProvider);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_GET_KEY_BITS_FUNC_TC001
* @title ECDH: get key bits.
* @brief
* 1. Create a context of the ECDH algorithm, expected result 1
* 2. Get key bits, expected result 2
* @expect
* 1. Success, and context is not NULL.
* 2. Equal to keyBits.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_GET_KEY_BITS_FUNC_TC001(int paraid, int keyBits, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, paraid), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetKeyBits(pkey) == (uint32_t)keyBits);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_GET_SEC_BITS_FUNC_TC001
* @title ECDH CRYPT_EAL_PkeyGetSecurityBits test.
* @precon nan
* @brief
* 1. Create the context of the ecdh algorithm, expected result 1
* 2. Set ecdh para, expected result 2
* 3. Call the CRYPT_EAL_PkeyGetSecurityBits Obtains secbits, expected result 3
* @expect
* 1. Success, and the context is not null.
* 2. CRYPT_SUCCESS
* 3. The return value is secBits.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_GET_SEC_BITS_FUNC_TC001(int paraid, int secBits)
{
CRYPT_EAL_PkeyCtx *pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ECDH);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, paraid), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetSecurityBits(pkey), secBits);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_CHECK_KEYPAIR_FUNC_TC001
* @title ECDH CRYPT_EAL_PkeyPairCheck test.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_CHECK_KEYPAIR_FUNC_TC001(int paraid, int isProvider)
{
#if !defined(HITLS_CRYPTO_ECDH_CHECK)
(void)paraid;
(void)isProvider;
SKIP_TEST();
#else
TestMemInit();
uint8_t wrong[KEY_MAX_LEN] = {1};
CRYPT_EAL_PkeyPub ecdhPubKey = {0};
CRYPT_EAL_PkeyPrv ecdhPrvKey = {0};
KeyData pubKeyVector = {{0}, KEY_MAX_LEN};
KeyData prvKeyVector = {{0}, KEY_MAX_LEN};
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pubCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *prvCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(pubCtx != NULL);
ASSERT_TRUE(prvCtx != NULL);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, paraid), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pubCtx, paraid), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(prvCtx, paraid), CRYPT_SUCCESS);
Ecc_SetPubKey(&ecdhPubKey, CRYPT_PKEY_ECDH, pubKeyVector.data, pubKeyVector.len);
Ecc_SetPrvKey(&ecdhPrvKey, CRYPT_PKEY_ECDH, prvKeyVector.data, prvKeyVector.len);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pkey, pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &ecdhPubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &ecdhPrvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubCtx, &ecdhPubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &ecdhPrvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_SUCCESS);
ecdhPrvKey.key.eccPrv.data = wrong;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &ecdhPrvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_ECDH_PAIRWISE_CHECK_FAIL);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(pubCtx);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDH_CHECK_PRVKEY_FUNC_TC001
* @title ECDH CRYPT_EAL_PkeyPrvCheck test.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDH_CHECK_PRVKEY_FUNC_TC001(int paraid, int isProvider)
{
#if !defined(HITLS_CRYPTO_ECDH_CHECK)
(void)paraid;
(void)isProvider;
SKIP_TEST();
#else
TestMemInit();
CRYPT_EAL_PkeyPrv ecdhPrvKey = {0};
CRYPT_ECDH_Ctx *ctx = NULL;
BN_BigNum *n = NULL;
BN_BigNum *prvKey = NULL;
KeyData prvKeyVector = {{0}, KEY_MAX_LEN};
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *prvCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDH,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(prvCtx != NULL);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, paraid), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(prvCtx, paraid), CRYPT_SUCCESS);
Ecc_SetPrvKey(&ecdhPrvKey, CRYPT_PKEY_ECDH, prvKeyVector.data, prvKeyVector.len);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_ECC_PKEY_ERR_EMPTY_KEY);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SUCCESS);
ctx = (CRYPT_ECDH_Ctx *)pkey->key;
prvKey = ctx->prvkey;
n = ECC_GetParaN(ctx->para);
(void)BN_Copy(prvKey, n);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_ECDH_INVALID_PRVKEY);
(void)BN_SubLimb(prvKey, prvKey, 1); // key = n - 1
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SUCCESS);
(void)BN_Zeroize(prvKey); // key = 0
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_ECDH_INVALID_PRVKEY);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
BN_Destroy(n);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECC_MUL_CAL_TEST_FUNC_TC001
* @title ECDH SDV_CRYPTO_ECC_MUL_CAL_TEST_FUNC_TC001 test.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECC_MUL_CAL_TEST_FUNC_TC001(int paraId)
{
if (IsCurveDisabled(paraId) && paraId != CRYPT_ECC_SM2) {
SKIP_TEST();
}
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ECC_Para *para = ECC_NewPara(paraId);
ASSERT_TRUE(para != NULL);
BN_BigNum *N = ECC_GetParaN(para);
ASSERT_TRUE(N != NULL);
BN_BigNum *rand = BN_Create(0);
ASSERT_TRUE(rand != NULL);
ASSERT_EQ(BN_RandRange(rand, N), CRYPT_SUCCESS);
ECC_Point *point1 = ECC_NewPoint(para);
ASSERT_TRUE(point1 != NULL);
ECC_Point *point2 = ECC_NewPoint(para);
ASSERT_TRUE(point2 != NULL);
ECC_Point *point3 = ECC_NewPoint(para);
ASSERT_TRUE(point3 != NULL);
// cal N*G
ASSERT_EQ(ECC_PointMul(para, point1, N, NULL), CRYPT_SUCCESS);
ASSERT_EQ(ECP_PointMulFast(para, point2, N, NULL), CRYPT_SUCCESS);
ASSERT_EQ(ECC_PointCmp(para, point1, point2), CRYPT_SUCCESS);
// cal random*G
ASSERT_EQ(ECC_PointMul(para, point1, rand, NULL), CRYPT_SUCCESS);
ASSERT_EQ(ECP_PointMulFast(para, point2, rand, NULL), CRYPT_SUCCESS);
ASSERT_EQ(ECC_PointCmp(para, point1, point2), CRYPT_SUCCESS);
// cal random*Point
ASSERT_EQ(ECC_PointMul(para, point2, rand, point1), CRYPT_SUCCESS);
ASSERT_EQ(ECP_PointMulFast(para, point3, rand, point1), CRYPT_SUCCESS);
ASSERT_EQ(ECC_PointCmp(para, point2, point3), CRYPT_SUCCESS);
EXIT:
ECC_FreePara(para);
ECC_FreePoint(point1);
ECC_FreePoint(point2);
ECC_FreePoint(point3);
BN_Destroy(rand);
BN_Destroy(N);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECC_ADD_CAL_TEST_FUNC_TC001
* @title ECDH SDV_CRYPTO_ECC_ADD_CAL_TEST_FUNC_TC001 test.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECC_ADD_CAL_TEST_FUNC_TC001(int paraId, Hex *bk1, Hex *bk2, Hex *bk3)
{
if (IsCurveDisabled(paraId) && paraId != CRYPT_ECC_SM2) {
SKIP_TEST();
}
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ECC_Para *para = ECC_NewPara(paraId);
ECC_Point *twoG = ECC_NewPoint(para);
ECC_Point *pt1 = ECC_NewPoint(para);
ECC_Point *pt2 = ECC_NewPoint(para);
ECC_Point *r1 = ECC_NewPoint(para);
ECC_Point *r2 = ECC_NewPoint(para);
BN_BigNum *bnk1 = BN_Create(0);
BN_BigNum *bnk2 = BN_Create(0);
BN_BigNum *bnk3 = BN_Create(0);
ASSERT_TRUE(bnk1 != NULL);
ASSERT_TRUE(bnk2 != NULL);
ASSERT_TRUE(bnk3 != NULL);
ASSERT_TRUE(twoG != NULL);
ASSERT_TRUE(pt1 != NULL);
ASSERT_TRUE(pt2 != NULL);
ASSERT_TRUE(r1 != NULL);
ASSERT_TRUE(r2 != NULL);
ASSERT_EQ(BN_Bin2Bn(bnk1, bk1->x, bk1->len), CRYPT_SUCCESS);
ASSERT_EQ(BN_Bin2Bn(bnk2, bk2->x, bk2->len), CRYPT_SUCCESS);
ASSERT_EQ(BN_Bin2Bn(bnk3, bk3->x, bk3->len), CRYPT_SUCCESS);
// cal 2*G
ASSERT_EQ(ECP_PointMulFast(para, twoG, bnk3, NULL), CRYPT_SUCCESS);
ASSERT_EQ(ECP_PointMulFast(para, pt1, bnk1, NULL), CRYPT_SUCCESS);
ASSERT_EQ(ECP_PointMulFast(para, pt2, bnk2, twoG), CRYPT_SUCCESS);
ASSERT_EQ(ECC_PointAddAffine(para, r1, pt1, pt2), CRYPT_SUCCESS);
ASSERT_EQ(ECC_PointMulAdd(para, r2, bnk1, bnk2, twoG), CRYPT_SUCCESS);
ASSERT_EQ(ECC_PointCmp(para, r1, r2), CRYPT_SUCCESS);
EXIT:
ECC_FreePara(para);
ECC_FreePoint(twoG);
ECC_FreePoint(pt1);
ECC_FreePoint(pt2);
ECC_FreePoint(r1);
ECC_FreePoint(r2);
BN_Destroy(bnk1);
BN_Destroy(bnk2);
BN_Destroy(bnk3);
TestRandDeInit();
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/ecc/test_suite_sdv_eal_ecdh.c | C | unknown | 35,302 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* INCLUDE_BASE test_suite_sdv_eal_ecc */
/* BEGIN_HEADER */
int SignEncode(Hex *R, Hex *S, uint8_t *vectorSign, uint32_t *vectorSignLen)
{
int ret;
BN_BigNum *bnR = BN_Create(R->len * BITS_OF_BYTE);
BN_BigNum *bnS = BN_Create(S->len * BITS_OF_BYTE);
ASSERT_TRUE(bnS != NULL && bnR != NULL);
ASSERT_TRUE(BN_Bin2Bn(bnR, R->x, R->len) == CRYPT_SUCCESS);
ASSERT_TRUE(BN_Bin2Bn(bnS, S->x, S->len) == CRYPT_SUCCESS);
ret = CRYPT_EAL_EncodeSign(bnR, bnS, vectorSign, vectorSignLen);
EXIT:
BN_Destroy(bnR);
BN_Destroy(bnS);
return ret;
}
/* END_HEADER */
#define CRYPT_EAL_PKEY_KEYMGMT_OPERATE 0
/**
* @test SDV_CRYPTO_ECDSA_NEW_CTX_API_TC001
* @title ECDSA CRYPT_EAL_PkeyNewCtx test.
* @precon nan
* @brief
* 1. Call the CRYPT_EAL_PkeyNewCtx method to create a pkey structure, algId is CRYPT_PKEY_ECDSA, expected result 1
* 2. Releases the pkey structure, expected result 2
* @expect
* 1. Success, and the structure is not NULL.
* 1. No memory leakage occurs.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_NEW_CTX_API_TC001(void)
{
ASSERT_TRUE(EAL_PkeyNewCtx_Api_TC001(CRYPT_PKEY_ECDSA) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_SET_PARA_BY_ID_API_TC001
* @title ECDSA CRYPT_EAL_PkeySetParaById: Test the validity of input parameters.
* @precon
* @brief
* 1. Create the context of the ecdsa algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeySetParaById method:
* (1) context = NULL, expected result 2.
* (2) CRYPT_PKEY_ParaId = CRYPT_ECC_NISTP224, expected result 3.
* (3) CRYPT_PKEY_ParaId = CRYPT_ECC_NISTP256, expected result 3.
* (4) CRYPT_PKEY_ParaId = CRYPT_ECC_NISTP384, expected result 3.
* (5) CRYPT_PKEY_ParaId = CRYPT_ECC_NISTP521, expected result 3.
* (6) CRYPT_PKEY_ParaId = CRYPT_ECC_BRAINPOOLP256R1, expected result 3.
* (7) CRYPT_PKEY_ParaId = CRYPT_ECC_BRAINPOOLP384R1, expected result 3.
* (8) CRYPT_PKEY_ParaId = CRYPT_ECC_BRAINPOOLP512R1, expected result 3.
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_NULL_INPUT
* 3. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_SET_PARA_BY_ID_API_TC001(void)
{
ASSERT_TRUE(EAL_PkeySetParaById_Api_TC001(CRYPT_PKEY_ECDSA) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_SET_PARA_BY_ID_API_TC002
* @title Repeat to set different curves.
* @precon nan
* @brief
* 1. Create context(ecdsaPkey) of the ECDSA algorithm, expected result 1
* 2. Set elliptic curve type to P224, expected result 2
* 3. Set elliptic curve type to paraId, expected result 3
* 4. Set private key, expected result 4
* 5. Take over random numbers, mock BN_RandRange to generate randVector.
* 6. Compute the signature by ecdsaPkey, expected result 5
* 7. Compares the hitls signature, expected result 6
* @expect
* 1. Success, and two contexts are not NULL.
* 2-5. CRYPT_SUCCESS
* 6. Both are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_SET_PARA_BY_ID_API_TC002(
int paraId, int mdId, Hex *prvKeyVector, Hex *plainText, Hex *signR, Hex *signS, Hex *randVector, int isProvider)
{
CRYPT_EAL_PkeyCtx *ecdsaPkey = NULL;
FuncStubInfo tmpRpInfo;
int ret, vectorSignLen, hitlsSginLen;
uint8_t *vectorSign = NULL;
uint8_t *hitlsSign = NULL;
CRYPT_EAL_PkeyPrv ecdsaPrvkey = {0};
TestMemInit();
ecdsaPkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ecdsaPkey != NULL);
ASSERT_TRUE_AND_LOG(
"SetParaById NISTP224", CRYPT_EAL_PkeySetParaById(ecdsaPkey, CRYPT_ECC_NISTP224) == CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("SetParaById", CRYPT_EAL_PkeySetParaById(ecdsaPkey, paraId) == CRYPT_SUCCESS);
/* Take over random numbers. */
ASSERT_TRUE(memcpy_s(gkRandBuf, sizeof(gkRandBuf), randVector->x, randVector->len) == 0);
gkRandBufLen = randVector->len;
STUB_Init();
STUB_Replace(&tmpRpInfo, BN_RandRangeEx, STUB_RandRangeK);
/* Set private key */
Ecc_SetPrvKey(&ecdsaPrvkey, CRYPT_PKEY_ECDSA, prvKeyVector->x, prvKeyVector->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ecdsaPkey, &ecdsaPrvkey), CRYPT_SUCCESS);
/* Signature */
hitlsSginLen = CRYPT_EAL_PkeyGetSignLen(ecdsaPkey);
hitlsSign = (uint8_t *)malloc(hitlsSginLen);
ASSERT_TRUE(hitlsSign != NULL);
ret = CRYPT_EAL_PkeySign(ecdsaPkey, mdId, plainText->x, plainText->len, hitlsSign, (uint32_t *)&hitlsSginLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
/* Encode the R and S of the vector. */
vectorSignLen = CRYPT_EAL_PkeyGetSignLen(ecdsaPkey);
vectorSign = (uint8_t *)malloc(vectorSignLen);
ASSERT_TRUE(vectorSign != NULL);
ret = SignEncode(signR, signS, vectorSign, (uint32_t *)&vectorSignLen);
ASSERT_TRUE_AND_LOG("SignEncode", ret == CRYPT_SUCCESS);
/* Compare the results of HiTLS vs. Vector. */
ASSERT_EQ(hitlsSginLen, vectorSignLen);
ASSERT_TRUE(memcmp(vectorSign, hitlsSign, hitlsSginLen) == 0);
EXIT:
STUB_Reset(&tmpRpInfo);
free(hitlsSign);
free(vectorSign);
CRYPT_EAL_PkeyFreeCtx(ecdsaPkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_SIGN_API_TC001
* @title ECDSA CRYPT_EAL_PkeySign: Test the validity of parameters.
* @precon nan
* @brief
* 1. Create the context of the ecdsa algorithm, expected result 1
* 2. Set para by curve id(P-224) and set private key, expected result 2
* 3. Call the CRYPT_EAL_PkeySign method:
* (1) pkey = null, expected result 3
* (2) msg = null, expected result 4
* (3) sign = NULL, signLen != 0, expected result 5
* (4) sign != NULL, signLen = 0, expected result 6
* (5) sign != NULL, signLen = 1, expected result 7
* (6) msg != NULL, msgLen = 0, expected result 8
* (7) Correct parameters, expected result 9
* 4. Compare the signgures of HiTLS and vector, expected result 10
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_SUCCESS
* 3-5. CRYPT_NULL_INPUT
* 6-7. CRYPT_DSA_BUFF_LEN_NOT_ENOUGH
* 8-9. CRYPT_SUCCESS
* 10. Both are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_SIGN_API_TC001(
int mdId, Hex *prvKeyVector, Hex *msg, Hex *signR, Hex *signS, Hex *randVector, int isProvider)
{
CRYPT_EAL_PkeyCtx *ecdsaPkey = NULL;
FuncStubInfo tmpRpInfo;
int vectorSignLen;
uint32_t signLen;
uint8_t *vectorSign = NULL;
uint8_t *sign = NULL;
CRYPT_EAL_PkeyPrv ecdsaPrvkey = {0};
/* Register memory */
TestMemInit();
/* Take over random numbers. */
ASSERT_TRUE(memcpy_s(gkRandBuf, sizeof(gkRandBuf), randVector->x, randVector->len) == 0);
gkRandBufLen = randVector->len;
STUB_Init();
STUB_Replace(&tmpRpInfo, BN_RandRangeEx, STUB_RandRangeK);
ecdsaPkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ecdsaPkey != NULL);
/* Set para by curve id and set private key. */
ASSERT_TRUE(CRYPT_EAL_PkeySetParaById(ecdsaPkey, CRYPT_ECC_NISTP224) == CRYPT_SUCCESS);
Ecc_SetPrvKey(&ecdsaPrvkey, CRYPT_PKEY_ECDSA, prvKeyVector->x, prvKeyVector->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ecdsaPkey, &ecdsaPrvkey), CRYPT_SUCCESS);
/* Input parameter test of CRYPT_EAL_PkeySign. */
signLen = CRYPT_EAL_PkeyGetSignLen(ecdsaPkey);
sign = (uint8_t *)malloc(signLen);
ASSERT_TRUE(sign != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySign(NULL, mdId, msg->x, msg->len, sign, &signLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySign(ecdsaPkey, mdId, NULL, msg->len, sign, &signLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySign(ecdsaPkey, mdId, msg->x, msg->len, NULL, &signLen), CRYPT_NULL_INPUT);
signLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeySign(ecdsaPkey, mdId, msg->x, msg->len, sign, &signLen), CRYPT_ECDSA_BUFF_LEN_NOT_ENOUGH);
signLen = 1;
ASSERT_EQ(CRYPT_EAL_PkeySign(ecdsaPkey, mdId, msg->x, msg->len, sign, &signLen), CRYPT_ECDSA_BUFF_LEN_NOT_ENOUGH);
signLen = CRYPT_EAL_PkeyGetSignLen(ecdsaPkey);
/* The plaintext length is 0 and the other parameters are normal, and it is expected to succeed. */
ASSERT_EQ(CRYPT_EAL_PkeySign(ecdsaPkey, mdId, msg->x, 0, sign, &signLen), CRYPT_SUCCESS);
signLen = CRYPT_EAL_PkeyGetSignLen(ecdsaPkey);
ASSERT_TRUE(CRYPT_EAL_PkeySign(ecdsaPkey, mdId, msg->x, msg->len, sign, (uint32_t *)&signLen) == CRYPT_SUCCESS);
/* Encode the R and S of the vector. */
vectorSignLen = CRYPT_EAL_PkeyGetSignLen(ecdsaPkey);
vectorSign = (uint8_t *)malloc(vectorSignLen);
ASSERT_TRUE(vectorSign != NULL);
ASSERT_TRUE_AND_LOG(
"SignEncode", SignEncode(signR, signS, vectorSign, (uint32_t *)&vectorSignLen) == CRYPT_SUCCESS);
/* Compare the results of HiTLS vs. Vector. */
ASSERT_EQ(signLen, vectorSignLen);
ASSERT_TRUE(memcmp(vectorSign, sign, signLen) == 0);
EXIT:
STUB_Reset(&tmpRpInfo);
free(sign);
free(vectorSign);
CRYPT_EAL_PkeyFreeCtx(ecdsaPkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_SIGN_API_TC002
* @title ECDSA CRYPT_EAL_PkeySign: Missing private key.
* @precon nan
* @brief
* 1. Create the context of the ecdsa algorithm, expected result 1
* 2. Set para by curve id(P-224), expected result 2
* 3. Call the CRYPT_EAL_PkeySign method to compute signature,expected result 3
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_ECDSA_ERR_EMPTY_KEY
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_SIGN_API_TC002(int mdId, Hex *plainText, int isProvider)
{
uint32_t hitlsSignLen;
uint8_t *hitlsSign = NULL;
CRYPT_EAL_PkeyCtx *ecdsaPkey = NULL;
TestMemInit();
ecdsaPkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ecdsaPkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetParaById(ecdsaPkey, CRYPT_ECC_NISTP224) == CRYPT_SUCCESS);
/* Signature */
hitlsSignLen = CRYPT_EAL_PkeyGetSignLen(ecdsaPkey);
hitlsSign = (uint8_t *)malloc(hitlsSignLen);
ASSERT_TRUE(hitlsSign != NULL);
ASSERT_TRUE_AND_LOG("CRYPT_EAL_PkeySign No PrvKey",
CRYPT_EAL_PkeySign(ecdsaPkey, mdId, plainText->x, plainText->len, hitlsSign, &hitlsSignLen) ==
CRYPT_ECDSA_ERR_EMPTY_KEY);
EXIT:
free(hitlsSign);
CRYPT_EAL_PkeyFreeCtx(ecdsaPkey);
CRYPT_EAL_RandDeinit();
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_SIGN_API_TC003
* @title ECDSA CRYPT_EAL_PkeySign: Missing private key.
* @precon nan
* @brief
* 1. Create the context of the ecdsa algorithm, expected result 1
* 2. Set para by curve id(P-224) and set private key, expected result 2
* 3. Call the CRYPT_EAL_PkeySign method to compute signature,expected result 3
* 4. Mock BN_RandRange to STUB_RandRangeK
* 5. Call the CRYPT_EAL_PkeySign method to compute signature,expected result 4
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_NO_REGIST_RAND
* 4. CRYPT_ECDSA_ERR_TRY_CNT on randVector is 0, otherwise CRYPT_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_SIGN_API_TC003(
int mdId, Hex *prvKeyVector, Hex *plainText, Hex *randVector, int result, int isProvider)
{
CRYPT_EAL_PkeyCtx *ecdsaPkey = NULL;
FuncStubInfo tmpRpInfo;
int ret, hitlsSginLen;
uint8_t *hitlsSign = NULL;
CRYPT_EAL_PkeyPrv ecdsaPrvkey = {0};
/* Register memory */
TestMemInit();
ecdsaPkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ecdsaPkey != NULL);
/* Set para by curve id and set private key */
ASSERT_TRUE(CRYPT_EAL_PkeySetParaById(ecdsaPkey, CRYPT_ECC_NISTP256) == CRYPT_SUCCESS);
Ecc_SetPrvKey(&ecdsaPrvkey, CRYPT_PKEY_ECDSA, prvKeyVector->x, prvKeyVector->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ecdsaPkey, &ecdsaPrvkey), CRYPT_SUCCESS);
/* Signature */
hitlsSginLen = CRYPT_EAL_PkeyGetSignLen(ecdsaPkey);
hitlsSign = (uint8_t *)malloc(hitlsSginLen);
ASSERT_TRUE(hitlsSign != NULL);
ret = CRYPT_EAL_PkeySign(ecdsaPkey, mdId, plainText->x, plainText->len, hitlsSign, (uint32_t *)&hitlsSginLen);
ASSERT_EQ(ret, CRYPT_NO_REGIST_RAND);
/* Take over random numbers. */
ASSERT_TRUE(memcpy_s(gkRandBuf, sizeof(gkRandBuf), randVector->x, randVector->len) == 0);
gkRandBufLen = randVector->len;
STUB_Init();
STUB_Replace(&tmpRpInfo, BN_RandRangeEx, STUB_RandRangeK);
ret = CRYPT_EAL_PkeySign(ecdsaPkey, mdId, plainText->x, plainText->len, hitlsSign, (uint32_t *)&hitlsSginLen);
if (result == 1) {
ASSERT_EQ(ret, CRYPT_SUCCESS);
} else {
ASSERT_EQ(ret, CRYPT_ECDSA_ERR_TRY_CNT);
}
EXIT:
STUB_Reset(&tmpRpInfo);
free(hitlsSign);
CRYPT_EAL_PkeyFreeCtx(ecdsaPkey);
CRYPT_EAL_RandDeinit();
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_SIGN_DATA_API_TC001
* @title ECDSA CRYPT_EAL_PkeySign: Test the validity of parameters.
* @precon nan
* @brief
* 1. Create the context of the ecdsa algorithm, expected result 1
* 2. Set para by curve id(P-224) and set private key, expected result 2
* 3. Call the CRYPT_EAL_PkeySignData method:
* (1) pkey = null, expected result 3
* (2) msg = null, msgLen != 0, expected result 3
* (3) msg != NULL, msgLen = 0, expected result 3
* (4) sign = NULL, signLen != 0, expected result 6
* (5) sign != NULL, signLen = NULL, expected result 7
* (6) Correct parameters, expected result 8
* (7) sign != NULL, signLen = 0, expected result 9
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_SUCCESS
* 3-4. CRYPT_ERR_ALGID
* 5-7. CRYPT_NULL_INPUT
* 8. CRYPT_NO_REGIST_RAND
* 9. CRYPT_ECDSA_BUFF_LEN_NOT_ENOUGH
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_SIGN_DATA_API_TC001(Hex *prvKeyVector, Hex *msg, int isProvider)
{
uint32_t hitlsSignLen;
uint8_t *hitlsSign = NULL;
CRYPT_EAL_PkeyCtx *ecdsaPkey = NULL;
CRYPT_EAL_PkeyPrv ecdsaPrvkey = {0};
TestMemInit();
ecdsaPkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ecdsaPkey != NULL);
/* Set para by curve id and set private key */
ASSERT_TRUE(CRYPT_EAL_PkeySetParaById(ecdsaPkey, CRYPT_ECC_NISTP256) == CRYPT_SUCCESS);
Ecc_SetPrvKey(&ecdsaPrvkey, CRYPT_PKEY_ECDSA, prvKeyVector->x, prvKeyVector->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ecdsaPkey, &ecdsaPrvkey), CRYPT_SUCCESS);
/* Signature */
hitlsSignLen = CRYPT_EAL_PkeyGetSignLen(ecdsaPkey);
hitlsSign = (uint8_t *)malloc(hitlsSignLen);
ASSERT_TRUE(hitlsSign != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySignData(NULL, msg->x, msg->len, hitlsSign, &hitlsSignLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySignData(ecdsaPkey, NULL, msg->len, hitlsSign, &hitlsSignLen), CRYPT_INVALID_ARG);
ASSERT_EQ(CRYPT_EAL_PkeySignData(ecdsaPkey, msg->x, 0, hitlsSign, &hitlsSignLen), CRYPT_INVALID_ARG);
ASSERT_EQ(CRYPT_EAL_PkeySignData(ecdsaPkey, msg->x, msg->len, NULL, &hitlsSignLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySignData(ecdsaPkey, msg->x, msg->len, hitlsSign, NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySignData(ecdsaPkey, msg->x, msg->len, hitlsSign, &hitlsSignLen), CRYPT_NO_REGIST_RAND);
hitlsSignLen = 0;
ASSERT_EQ(
CRYPT_EAL_PkeySignData(ecdsaPkey, msg->x, msg->len, hitlsSign, &hitlsSignLen), CRYPT_ECDSA_BUFF_LEN_NOT_ENOUGH);
EXIT:
free(hitlsSign);
CRYPT_EAL_PkeyFreeCtx(ecdsaPkey);
CRYPT_EAL_RandDeinit();
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_CTRL_API_TC001
* @title ECDSA CRYPT_EAL_PkeyCtrl: Test the validity of opt.
* @precon nan
* @brief
* 1. Create the context of the ecdsa algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyCtrl method:
* (1) opt = CRYPT_CTRL_SET_RSA_RSAES_PKCSV15, expected result 2
* (2) opt = CRYPT_CTRL_SET_ECC_POINT_FORMAT, expected result 3
* (3) opt = CRYPT_CTRL_SET_ECC_USE_COFACTOR_MODE, expected result 4
* (4) opt = CRYPT_CTRL_SET_SM2_USER_ID, expected result 5
* (5) opt = CRYPT_CTRL_SET_RSA_PADDING, expected result 6
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_ECC_PKEY_ERR_UNSUPPORTED_CTRL_OPTION
* 3. CRYPT_SUCCESS
* 4. CRYPT_ECDSA_ERR_UNSUPPORTED_CTRL_OPTION
* 5. CRYPT_ECC_PKEY_ERR_UNSUPPORTED_CTRL_OPTION
* 6. CRYPT_ECC_PKEY_ERR_UNSUPPORTED_CTRL_OPTION
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_CTRL_API_TC001(int type, int expect)
{
ASSERT_TRUE(EAL_PkeyCtrl_Api_TC001(CRYPT_PKEY_ECDSA, type, expect) == SUCCESS);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_CTRL_API_TC002
* @title ECDSA CRYPT_EAL_PkeyCtrl: Test the validity of pkey and value.
* @precon nan
* @brief
* 1. Create the context of the ECDSA algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyCtrl method:
* (1) pkey = null, expected result 2
* (2) val = null, len = 0, expected result 3
* (3) val = null, len != 0, expected result 4
* (4) val != null, len = 0, expected result 5
* (5) PointFormat = CRYPT_POINT_MAX, expected result 6
* (6) PointFormat = CRYPT_POINT_COMPRESSED, expected result 7
* (7) PointFormat = CRYPT_POINT_UNCOMPRESSED, expected result 8
* (8) PointFormat = CRYPT_POINT_HYBRID, expected result 9
* @expect
* 1. Success, and the context is not NULL.
* 2-4. CRYPT_NULL_INPUT
* 5. CRYPT_ECC_PKEY_ERR_CTRL_LEN
* 6. CRYPT_ECC_PKEY_ERR_INVALID_POINT_FORMAT
* 7-9. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_CTRL_API_TC002(void)
{
ASSERT_TRUE(EAL_PkeyCtrl_Api_TC002(CRYPT_PKEY_ECDSA) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_CTRL_API_TC003
* @title ECDSA CRYPT_EAL_PkeyCtrl: Test the effect of the point format on the key.
* @precon public key point
* @brief
* 1. Create the context of the ecdsa algorithm, expected result 1
* 2. Set the para by eccId(p-224/256/384/512, bp256r1/384r1/512/r1), expected result 2
* 3. Convert the format of the public key vector to COMPRESSED, expected result 3
* 4. Set the public key, expected result 4
* 5. Call the CRYPT_EAL_PkeyCtrl method to set point format to COMPRESSED, expected result 5
* 6. Call the CRYPT_EAL_PkeyCtrl method to set point format to HYBRID, expected result 6
* 7. Get the public key, expected result 7
* 8. Convert the format of the public key vector to HYBRID, expected result 8
* 9. Compare the output of the preceding two steps, expected result 9
* @expect
* 1. Success, and the context is not NULL.
* 2-7. CRYPT_SUCCESS
* 9. The two are same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_CTRL_API_TC003(int eccId, Hex *pubKeyX, Hex *pubKeyY)
{
ASSERT_TRUE(EAL_PkeyCtrl_Api_TC003(CRYPT_PKEY_ECDSA, eccId, pubKeyX, pubKeyY) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_GET_PRV_API_TC001
* @title ECDSA CRYPT_EAL_PkeyGetPrv: Test the validity of parameters.
* @precon private key
* @brief
* 1. Create the context of the ecdsa algorithm, expected result 1
* 2. Set the para by eccId(p-224), expected result 2
* 3. Get the private key when there is no private key, expected result 3
* 4. Set the private key, expected result 4
* 5. Call the CRYPT_EAL_PkeyGetPrv method:
* (1) pkey = null, expected result 5
* (2) prv = null, expected result 6
* (3) pkey.id != prv.id, expected result 7
* (4) Correct parameters, expected result 8
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_ECC_PKEY_ERR_EMPTY_KEY
* 4. CRYPT_SUCCESS
* 5-6. CRYPT_NULL_INPUT
* 7. CRYPT_EAL_ERR_ALGID
* 8. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_GET_PRV_API_TC001(Hex *prvKey)
{
ASSERT_TRUE(EAL_PkeyGetPrv_Api_TC001(CRYPT_PKEY_ECDSA, prvKey) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_GET_PUB_API_TC001
* @title ECDSA CRYPT_EAL_PkeyGetPub: Test the validity of parameters.
* @precon public key point
* @brief
* 1. Create the context of the ecdsa algorithm, expected result 1
* 2. Set the para by eccId(p-224), expected result 2
* 3. Get the public key when there is no public key, expected result 3
* 4. Set the public key, expected result 4
* 5. Call the CRYPT_EAL_PkeyGetPub method:
* (1) pkey = null, expected result 5
* (2) pub = null, expected result 6
* (3) pkey.id != pub.id, expected result 7
* (4) Correct parameters, expected result 8
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_ECC_PKEY_ERR_EMPTY_KEY
* 4. CRYPT_SUCCESS
* 5-6. CRYPT_NULL_INPUT
* 7. CRYPT_EAL_ERR_ALGID
* 8. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_GET_PUB_API_TC001(Hex *pubKeyX, Hex *pubKeyY)
{
ASSERT_TRUE(EAL_PkeyGetPub_Api_TC001(CRYPT_PKEY_ECDSA, pubKeyX, pubKeyY) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_SET_PRV_API_TC001
* @title ECDSA CRYPT_EAL_PkeySetPrv: Test the validity of parameters.
* @precon Prepare valid private key and invalid private key.
* @brief
* 1. Create the context of the ecdsa algorithm, expected result 1
* 2. Set the the valid private key before setting the curve, expected result 2
* 3. Set the para by eccId(p-224), expected result 3
* 4. Call the CRYPT_EAL_PkeySetPrv method:
* (1) pkey = null, expected result 4
* (2) prv = null, expected result 5
* (3) pkey.id != prv.id, expected result 6
* (4) Set the valid private key, expected result 7
* (5) Set the invalid private key, expected result 8
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_NULL_INPUT
* 3. CRYPT_SUCCESS
* 4-5. CRYPT_NULL_INPUT
* 6. CRYPT_EAL_ERR_ALGID
* 7. CRYPT_SUCCESS
* 8. CRYPT_ECC_PKEY_ERR_INVALID_PRIVATE_KEY
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_SET_PRV_API_TC001(Hex *prvKey, Hex *errorPrvKey)
{
ASSERT_TRUE(EAL_PkeySetPrv_Api_TC001(CRYPT_PKEY_ECDSA, prvKey, errorPrvKey) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_SET_PRV_API_TC002
* @title Check whether the public key is cleared when the private key is set.
* @precon private key, public key point
* @brief
* 1. Create the context of the ecdsa algorithm, expected result 1
* 2. Set the para by eccId(p-224), expected result 2
* 3. Set the the public key, expected result 3
* 4. Set the the private key, expected result 4
* 5. Get the the public key, expected result 5
* @expect
* 1. Success, and the context is not NULL.
* 2-5. CRYPT_SUCCESSY
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_SET_PRV_API_TC002(Hex *prvKey, Hex *pubKeyX, Hex *pubKeyY)
{
ASSERT_TRUE(EAL_PkeySetPrv_Api_TC002(CRYPT_PKEY_ECDSA, prvKey, pubKeyX, pubKeyY) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_SET_PUB_API_TC001
* @title ECDSA CRYPT_EAL_PkeySetPub: Test the validity of parameters.
* @precon Prepare valid public key.
* @brief
* 1. Create the context of the ecdsa algorithm, expected result 1
* 2. Set the the public key before setting the curve, expected result 2
* 3. Set the para by eccId(p-224), expected result 3
* 4. Call the CRYPT_EAL_PkeySetPub method:
* (1) pkey = null, expected result 4
* (2) pub = null, expected result 5
* (3) pkey.id != pub.id, expected result 6
* (4) Set the valid public key, expected result 7
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_NULL_INPUT
* 3. CRYPT_SUCCESS
* 4-5. CRYPT_NULL_INPUT
* 6. CRYPT_EAL_ERR_ALGID
* 7. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_SET_PUB_API_TC001(Hex *pubKeyVector)
{
ASSERT_TRUE(EAL_PkeySetPub_Api_TC001(CRYPT_PKEY_ECDSA, pubKeyVector) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_SET_PUB_API_TC002
* @title Check whether the private key is cleared when the public key is set.
* @precon public key, private key
* @brief
* 1. Create the context of the ecdsa algorithm, expected result 1
* 2. Set the para by eccId(p-224), expected result 2
* 3. Set the the private key, expected result 3
* 4. Set the the public key, expected result 4
* 5. Get the the private key, expected result 5
* @expect
* 1. Success, and the context is not NULL.
* 2-5. CRYPT_SUCCESSY
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_SET_PUB_API_TC002(Hex *prvKey, Hex *pubKey)
{
ASSERT_TRUE(EAL_PkeySetPub_Api_TC002(CRYPT_PKEY_ECDSA, prvKey, pubKey) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_SET_PUB_API_TC003
* @title Test the function of setting public keys of different lengths.
* @precon Public keys of different lengths.
* @brief
* 1. Create the context of the ecdsa algorithm, expected result 1
* 2. Set the para by eccId(p-224/256/384/512, bp256r1/384r1/512/r1), expected result 2
* 3. Set public keys of different lengths, expected result 3
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_SUCCESSY
* 3. CRYPT_ECC_ERR_POINT_CODE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_SET_PUB_API_TC003(int eccId, Hex *pubKey, Hex *errorPubKey, int isProvider)
{
ASSERT_TRUE(EAL_PkeySetPub_Api_TC003(CRYPT_PKEY_ECDSA, eccId, pubKey, errorPubKey, isProvider) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_GET_PARA_ID_API_TC001
* @title ECDSA CRYPT_EAL_PkeyGetParaId test.
* @precon Registering memory-related functions.
* @brief
* 1. Get para id before creating context, expected result 1
* 2. Create the context of the ECDSA algorithm, expected result 2
* 3. Set para id(p-224/256/384/512), expected result 3
* 4. Get para id, expected result 4
* @expect
* 1. CRYPT_PKEY_PARAID_MAX
* 2. Success, and the context is not NULL.
* 3. CRYPT_SUCCESS
* 4. The obtained id is the same as the set id.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_GET_PARA_ID_API_TC001(int id)
{
ASSERT_TRUE(EAL_PkeyGetParaId_Api_TC001(CRYPT_PKEY_ECDSA, id) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_CMP_FUNC_TC001
* @title ECDSA: CRYPT_EAL_PkeyCmp test.
* @precon Registering memory-related functions.
* @brief
* 1. Create the contexts(ctx1, ctx2) of the ecdsa algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 2
* 3. Set para id CRYPT_ECC_NISTP224 and public key for ctx1, expected result 3
* 4. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 4
* 5. Set para id CRYPT_ECC_NISTP256 for ctx2, expected result 5
* 6. Set public key for ctx2, expected result 6
* 7. Set para id CRYPT_ECC_NISTP224 and public key for ctx2, expected result 7
* 8. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 8
* @expect
* 1. Success, and contexts are not NULL.
* 2. CRYPT_ECC_KEY_PUBKEY_NOT_EQUAL
* 3. CRYPT_SUCCESS
* 4. CRYPT_ECC_KEY_PUBKEY_NOT_EQUAL
* 5. CRYPT_SUCCESS
* 6. CRYPT_ECC_ERR_POINT_CODE
* 7. CRYPT_SUCCESS
* 8. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_CMP_FUNC_TC001(Hex *pubKeyX, Hex *pubKeyY)
{
ASSERT_TRUE(EAL_PkeyCmp_Api_TC001(CRYPT_PKEY_ECDSA, pubKeyX, pubKeyY) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_VERIFY_API_TC001
* @title ECDSA CRYPT_EAL_PkeyVerify: Test the validity of parameters.
* @precon nan
* @brief
* 1. Create the context of the ecdsa algorithm, expected result 1
* 2. Set para by curve id(P-224), expected result 2
* 3. Verify when there is no public key, expected result 3
* 4. Set public key, expected result 4
* 5. Call the CRYPT_EAL_PkeyVerify method:
* (1) pkey = null, expected result 5
* (2) data = null, dataLen != 0, expected result 6
* (3) data = null or data != null, and dataLen = 0, expected result 7
* (4) sign = null, signLen != 0 or signLen = 0, expected result 8
* (5) sign != null, signLen = 0, expected result 9
* (6) sign != null, signLen = 1, expected result 10
* (7) Correct parameters, expected result 11
* @expect
* 1. Success, and the context is not null.
* 2. CRYPT_SUCCESS
* 3. CRYPT_ECDSA_ERR_EMPTY_KEY
* 4. CRYPT_SUCCESS
* 5-6. CRYPT_NULL_INPUT
* 7. CRYPT_ECDSA_BUFF_LEN_NOT_ENOUGH
* 8-9. CRYPT_NULL_INPUT
* 10. CRYPT_DSA_DECODE_FAIL
* 11. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_VERIFY_API_TC001(Hex *data, Hex *pubKeyX, Hex *pubKeyY, Hex *sign, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPub ecdsaPubkey;
KeyData pubKeyVector = {{0}, KEY_MAX_LEN};
CRYPT_MD_AlgId mdId = CRYPT_MD_SHA224;
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE_AND_LOG("New ECDSA Pkey", pkey != NULL);
/* Set para by curve id. */
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, CRYPT_ECC_NISTP224), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("EccPointToBuffer", EccPointToBuffer(pubKeyX, pubKeyY, 1, &pubKeyVector) == CRYPT_SUCCESS);
/* Verify when there is no public key. */
ASSERT_TRUE(CRYPT_EAL_PkeyVerify(pkey, mdId, data->x, data->len, sign->x, sign->len) == CRYPT_ECDSA_ERR_EMPTY_KEY);
/* Set public key. */
Ecc_SetPubKey(&ecdsaPubkey, CRYPT_PKEY_ECDSA, pubKeyVector.data, pubKeyVector.len);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &ecdsaPubkey), CRYPT_SUCCESS);
/* Input parameter test of CRYPT_EAL_PkeyVerify. */
ASSERT_EQ(CRYPT_EAL_PkeyVerify(NULL, mdId, data->x, data->len, sign->x, sign->len), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, mdId, NULL, data->len, sign->x, sign->len), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, mdId, NULL, 0, sign->x, sign->len), CRYPT_ECDSA_VERIFY_FAIL);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, mdId, data->x, 0, sign->x, sign->len), CRYPT_ECDSA_VERIFY_FAIL);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, mdId, data->x, data->len, NULL, sign->len), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, mdId, data->x, data->len, NULL, 0), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, mdId, data->x, data->len, sign->x, 0), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, mdId, data->x, data->len, sign->x, 1), BSL_ASN1_ERR_DECODE_LEN);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, mdId, data->x, data->len, sign->x, sign->len), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_SIGN_VERIFY_FUNC_TC002
* @title ED25519 sets the keys and performs signature and verifiy tests on the hash data.
* @precon nan
* @brief
* 1. Create context(ecdsaPkey) of the ECDSA algorithm, expected result 1
* 2. Set elliptic curve type, private key, expected result 2
* 3. Take over random numbers, mock BN_RandRange to generate randVector.
* 4. Sign the hash data(all 0x00 or all 0xFF) using ecdsaPkey, expected result 3
* 5. Reset the stubbed function.
* 6. Create context(ecdsaPkey2) of the ECDSA algorithm, expected result 4
* 7. Set elliptic curve type, public key, expected result 5
* 9. Verify the signature by ecdsaPkey2, expected result 6
* @expect
* 1. Success, and context is not NULL.
* 2-3. CRYPT_SUCCESS
* 4. Success, and context is not NULL.
* 5-6. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_SIGN_VERIFY_FUNC_TC002(int eccId, Hex *prvKeyVector, Hex *hashData,
Hex *randVector, Hex *pubKeyX, Hex *pubKeyY, int pointFormat, int isProvider)
{
uint32_t hitlsSignLen;
FuncStubInfo tmpRpInfo;
uint8_t *hitlsSign = NULL;
CRYPT_EAL_PkeyCtx *ecdsaPkey = NULL;
CRYPT_EAL_PkeyCtx *ecdsaPkey2 = NULL;
CRYPT_EAL_PkeyPrv ecdsaPrvkey = {0};
CRYPT_EAL_PkeyPub ecdsaPubkey;
KeyData pubKeyVector = {{0}, KEY_MAX_LEN};
/* Register memory */
TestMemInit();
/* Create an ECDSA context for signing*/
ecdsaPkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ecdsaPkey != NULL);
/* Set para by curve id and set private key */
ASSERT_TRUE_AND_LOG("CRYPT_EAL_PkeySetParaById", CRYPT_EAL_PkeySetParaById(ecdsaPkey, eccId) == CRYPT_SUCCESS);
Ecc_SetPrvKey(&ecdsaPrvkey, CRYPT_PKEY_ECDSA, prvKeyVector->x, prvKeyVector->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ecdsaPkey, &ecdsaPrvkey), CRYPT_SUCCESS);
/* Take over random numbers. */
ASSERT_TRUE(memcpy_s(gkRandBuf, sizeof(gkRandBuf), randVector->x, randVector->len) == 0);
gkRandBufLen = randVector->len;
STUB_Init();
STUB_Replace(&tmpRpInfo, BN_RandRangeEx, STUB_RandRangeK);
/* Sign hash data */
hitlsSignLen = CRYPT_EAL_PkeyGetSignLen(ecdsaPkey);
hitlsSign = (uint8_t *)malloc(hitlsSignLen);
ASSERT_TRUE(hitlsSign != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySignData(ecdsaPkey, hashData->x, hashData->len, hitlsSign, &hitlsSignLen), CRYPT_SUCCESS);
/* Reset the stubbed function */
STUB_Reset(&tmpRpInfo);
/* Create an ESA context for signature verification. */
ecdsaPkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE_AND_LOG("CRYPT_EAL_PkeyNewCtx", ecdsaPkey2 != NULL);
/* Set para by curve id and set public key */
ASSERT_TRUE_AND_LOG("CRYPT_EAL_PkeySetParaById", CRYPT_EAL_PkeySetParaById(ecdsaPkey2, eccId) == CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG(
"EccPointToBuffer", EccPointToBuffer(pubKeyX, pubKeyY, pointFormat, &pubKeyVector) == CRYPT_SUCCESS);
Ecc_SetPubKey(&ecdsaPubkey, CRYPT_PKEY_ECDSA, pubKeyVector.data, pubKeyVector.len);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ecdsaPkey2, &ecdsaPubkey), CRYPT_SUCCESS);
/* Verify hash data */
ASSERT_EQ(CRYPT_EAL_PkeyVerifyData(ecdsaPkey2, hashData->x, hashData->len, hitlsSign, hitlsSignLen), CRYPT_SUCCESS);
EXIT:
free(hitlsSign);
CRYPT_EAL_PkeyFreeCtx(ecdsaPkey);
CRYPT_EAL_PkeyFreeCtx(ecdsaPkey2);
CRYPT_EAL_RandDeinit();
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_VERIFY_DATA_API_TC001
* @title ECDSA CRYPT_EAL_PkeyVerifyData: Test the validity of parameters.
* @precon nan
* @brief
* 1. Create the context of the ecdsa algorithm, expected result 1
* 2. Set para by curve id, expected result 2
* 3. Verify when there is no public key, expected result 3
* 4. Set public key, expected result 4
* 5. Call the CRYPT_EAL_PkeyVerify method:
* (1) pkey = null, expected result 5
* (2) data = null, dataLen != 0 || data != null, dataLen == 0 expected result 5
* (3) sign = null, signLen != 0 or signLen = 0, expected result 8
* (4) sign != null, signLen = 0, expected result 9
* @expect
* 1. Success, and the context is not null.
* 2. CRYPT_SUCCESS
* 3. CRYPT_ECDSA_ERR_EMPTY_KEY
* 4. CRYPT_SUCCESS
* 5. CRYPT_INVALID_ARG
* 6-9. CRYPT_NULL_INPUT
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_VERIFY_DATA_API_TC001(
int paraId, Hex *hashData, Hex *pubKeyX, Hex *pubKeyY, Hex *sign, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPub ecdsaPubkey;
KeyData pubKeyVector = {{0}, KEY_MAX_LEN};
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
/* Set para by curve id */
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, paraId), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("EccPointToBuffer", EccPointToBuffer(pubKeyX, pubKeyY, 1, &pubKeyVector) == CRYPT_SUCCESS);
ASSERT_TRUE(
CRYPT_EAL_PkeyVerifyData(pkey, hashData->x, hashData->len, sign->x, sign->len) == CRYPT_ECDSA_ERR_EMPTY_KEY);
/* Set public key */
Ecc_SetPubKey(&ecdsaPubkey, CRYPT_PKEY_ECDSA, pubKeyVector.data, pubKeyVector.len);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &ecdsaPubkey), CRYPT_SUCCESS);
/* Input parameter test of CRYPT_EAL_PkeyVerifyData. */
ASSERT_TRUE(CRYPT_EAL_PkeyVerifyData(NULL, hashData->x, hashData->len, sign->x, sign->len) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyVerifyData(pkey, NULL, hashData->len, sign->x, sign->len) == CRYPT_INVALID_ARG);
ASSERT_TRUE(CRYPT_EAL_PkeyVerifyData(pkey, hashData->x, 0, sign->x, sign->len) == CRYPT_INVALID_ARG);
ASSERT_TRUE(CRYPT_EAL_PkeyVerifyData(pkey, hashData->x, hashData->len, NULL, sign->len) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyVerifyData(pkey, hashData->x, hashData->len, NULL, 0) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyVerifyData(pkey, hashData->x, hashData->len, sign->x, 0) == CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_GET_SECURITY_BITS_API_TC001
* @title ECDSA CRYPT_EAL_PkeyGetSecurityBits: Test the validity of parameters.
* @precon nan
* @brief
* 1. Create the context of the ecdsa algorithm, expected result 1
* 2. Set para by curve id, expected result 2
* 3. Call the CRYPT_EAL_PkeyVerify method and set the parameter to null, expected result 3
* 4. Call the CRYPT_EAL_PkeyVerify method and the parameter is correct, expected result 4
* @expect
* 1. Success, and the context is not null.
* 2. CRYPT_SUCCESS
* 3. The return value is 0.
* 4. The return value is not 0.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_GET_SECURITY_BITS_API_TC001(int paraId, int securitybits, int isProvider)
{
CRYPT_EAL_PkeyCtx *ecdsaPkey = NULL;
TestMemInit();
/* Create an ECDSA context */
ecdsaPkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE_AND_LOG("New ECDSA Pkey", ecdsaPkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ecdsaPkey, paraId), CRYPT_SUCCESS);
/* Input parameter test of CRYPT_EAL_PkeyGetSecurityBits. */
ASSERT_TRUE(CRYPT_EAL_PkeyGetSecurityBits(NULL) == 0);
ASSERT_TRUE(CRYPT_EAL_PkeyGetSecurityBits(ecdsaPkey) == (uint32_t)securitybits);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ecdsaPkey);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_GET_KEY_BITS_API_TC001
* @title ECDSA CRYPT_EAL_PkeyGetKeyBits: Test the validity of parameters.
* @precon nan
* @brief
* 1. Create the context of the ecdsa algorithm, expected result 1
* 2. Set para by curve id, expected result 2
* 3. Call the CRYPT_EAL_PkeyGetKeyBits method and set the parameter to null, expected result 3
* 4. Call the CRYPT_EAL_PkeyGetKeyBits method and the parameter is correct, expected result 4
* @expect
* 1. Success, and the context is not null.
* 2. CRYPT_SUCCESS
* 3. The return value is 0.
* 4. The return value is not 0.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_GET_KEY_BITS_API_TC001(int paraId, int keyBitsLen, int isProvider)
{
CRYPT_EAL_PkeyCtx *ecdsaPkey = NULL;
TestMemInit();
/* Create an ECDSA context */
ecdsaPkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE_AND_LOG("New ECDSA Pkey", ecdsaPkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ecdsaPkey, paraId), CRYPT_SUCCESS);
/* Input parameter test of CRYPT_EAL_PkeyGetKeyBits. */
ASSERT_TRUE(CRYPT_EAL_PkeyGetKeyBits(NULL) == 0);
ASSERT_TRUE(CRYPT_EAL_PkeyGetKeyBits(ecdsaPkey) == (uint32_t)keyBitsLen);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ecdsaPkey);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_SET_PARA_API_TC001
* @title ECDSA CRYPT_EAL_PkeySetPara: Test the validity of parameters.
* @precon Prepare valid private key and invalid private key.
* @brief
* 1. Create the context of the ecdsa algorithm, expected result 1
* 2. Set the para by eccId, expected result 2
* 3. Call the CRYPT_EAL_PkeySetPara method:
* (1) pkey = null, expected result 3
* (2) para = null, expected result 4
* (3) pkey.id != para.id, expected result 5
* (4) The parameter structure is empty, expected result 6
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_SUCCESS
* 3-4. CRYPT_NULL_INPUT
* 5. CRYPT_EAL_ERR_ALGID
* 6. CRYPT_EAL_ERR_NEW_PARA_FAIL
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_SET_PARA_API_TC001(int paraId, int isProvider)
{
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyCtx *pkey = NULL;
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, paraId), CRYPT_SUCCESS);
/* Input parameter test of CRYPT_EAL_PkeySetPara. */
ASSERT_EQ(CRYPT_EAL_PkeySetPara(NULL, ¶), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, NULL), CRYPT_NULL_INPUT);
para.id = CRYPT_PKEY_DSA;
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_EAL_ERR_ALGID);
para.id = CRYPT_PKEY_ECDSA;
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_SIGN_VERIFY_FUNC_TC001
* @title ECDSA sign and verify test: different hash and curve.
* @precon nan
* @brief
* 1. Init the drbg, expected result 1
* 2. Create context(ecdsaPkey) of the ECDSA algorithm, expected result 2
* 3. Set elliptic curve type, private key and public key, expected result 3
* 4. Take over random numbers, mock BN_RandRange to generate randVector.
* 5. Compute the signature by ecdsaPkey, expected result 4
* 6. Compares the hitls signature, expected result 5
* 7. Verify the signature by ecdsaPkey, expected result 6
* 8. Call the CRYPT_EAL_PkeyCopyCtx method to copy the context, expected result 7
* 9. Use the copied context for signing and verification, expected result 8
* @expect
* 1. Success, and two contexts are not NULL.
* 2-4. CRYPT_SUCCESS
* 5. Both are the same.
* 6-8. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_SIGN_VERIFY_FUNC_TC001(int eccId, int mdId, Hex *prvKeyVector, Hex *msg, Hex *signR, Hex *signS,
Hex *randVector, Hex *pubKeyX, Hex *pubKeyY, int pointFormat, int isProvider)
{
if (IsCurveDisabled(eccId) || IsMdAlgDisabled(mdId)) {
SKIP_TEST();
}
int ret, vectorSignLen, hitlsSginLen;
uint8_t *vectorSign = NULL;
uint8_t *hitlsSign = NULL;
CRYPT_EAL_PkeyCtx *ecdsaPkey = NULL;
CRYPT_EAL_PkeyCtx *cpyCtx = NULL;
CRYPT_EAL_PkeyPrv ecdsaPrvkey = {0};
CRYPT_EAL_PkeyPub ecdsaPubkey;
KeyData pubKeyVector = {{0}, KEY_MAX_LEN};
FuncStubInfo tmpRpInfo;
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ecdsaPkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE_AND_LOG("New ECDSA Pkey", ecdsaPkey != NULL);
/* Set para by curve id */
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ecdsaPkey, eccId), CRYPT_SUCCESS);
/* Set private key */
Ecc_SetPrvKey(&ecdsaPrvkey, CRYPT_PKEY_ECDSA, prvKeyVector->x, prvKeyVector->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ecdsaPkey, &ecdsaPrvkey), CRYPT_SUCCESS);
/* Set public key */
ret = EccPointToBuffer(pubKeyX, pubKeyY, pointFormat, &pubKeyVector);
ASSERT_TRUE_AND_LOG("EccPointToBuffer", ret == CRYPT_SUCCESS);
Ecc_SetPubKey(&ecdsaPubkey, CRYPT_PKEY_ECDSA, pubKeyVector.data, pubKeyVector.len);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ecdsaPkey, &ecdsaPubkey), CRYPT_SUCCESS);
/* Take over random numbers. */
ASSERT_TRUE(memcpy_s(gkRandBuf, sizeof(gkRandBuf), randVector->x, randVector->len) == 0);
gkRandBufLen = randVector->len;
STUB_Init();
STUB_Replace(&tmpRpInfo, BN_RandRangeEx, STUB_RandRangeK);
/* Signature */
hitlsSginLen = CRYPT_EAL_PkeyGetSignLen(ecdsaPkey);
hitlsSign = (uint8_t *)malloc(hitlsSginLen);
ASSERT_TRUE(hitlsSign != NULL);
ret = CRYPT_EAL_PkeySign(ecdsaPkey, mdId, msg->x, msg->len, hitlsSign, (uint32_t *)&hitlsSginLen);
ASSERT_TRUE_AND_LOG("CRYPT_EAL_PkeySign", ret == CRYPT_SUCCESS);
/* Encode the R and S of the vector. */
vectorSignLen = CRYPT_EAL_PkeyGetSignLen(ecdsaPkey);
vectorSign = (uint8_t *)malloc(vectorSignLen);
ASSERT_TRUE(vectorSign != NULL);
ret = SignEncode(signR, signS, vectorSign, (uint32_t *)&vectorSignLen);
ASSERT_TRUE_AND_LOG("SignEncode", ret == CRYPT_SUCCESS);
/* Compare the results of HiTLS vs. Vector. */
ASSERT_EQ(hitlsSginLen, vectorSignLen);
ASSERT_TRUE(memcmp(vectorSign, hitlsSign, hitlsSginLen) == 0);
STUB_Reset(&tmpRpInfo);
/* Verify */
ASSERT_TRUE(CRYPT_EAL_PkeyVerify(ecdsaPkey, mdId, msg->x, msg->len, hitlsSign, hitlsSginLen) == CRYPT_SUCCESS);
/* Copy the contexts: sign and verify */
cpyCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(cpyCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCopyCtx(cpyCtx, ecdsaPkey), CRYPT_SUCCESS);
hitlsSginLen = CRYPT_EAL_PkeyGetSignLen(cpyCtx);
ASSERT_EQ(CRYPT_EAL_PkeySign(cpyCtx, mdId, msg->x, msg->len, hitlsSign, (uint32_t *)&hitlsSginLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(cpyCtx, mdId, msg->x, msg->len, hitlsSign, hitlsSginLen), CRYPT_SUCCESS);
EXIT:
STUB_Reset(&tmpRpInfo);
free(hitlsSign);
free(vectorSign);
CRYPT_EAL_PkeyFreeCtx(ecdsaPkey);
CRYPT_EAL_PkeyFreeCtx(cpyCtx);
TestRandDeInit();
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_SET_PUB_FUNC_TC001
* @title Test set public key.
* @precon nan
* @brief
* 1. Init the drbg, expected result 1
* 2. Create context(ecdsaPkey) of the ECDSA algorithm, expected result 2
* 3. Set elliptic curve type, private key and public key, expected result 3
* 4. Convert the format of the public key vector to COMPRESSED, expected result 4
* 5. Call the CRYPT_EAL_PkeySetPub to set public key, expected result 5
* @expect
* 1. CRYPT_SUCCESS
* 2. Success, and context is not NULL.
* 3. CRYPT_SUCCESS
* 4. CRYPT_SUCCESS
* 5. CRYPT_SUCCESS on result=1
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_SET_PUB_FUNC_TC001(
int eccId, Hex *publicX, Hex *publicY, int result, int pointFormat, int isProvider)
{
if (IsCurveDisabled(eccId)) {
SKIP_TEST();
}
int ret;
CRYPT_EAL_PkeyCtx *ecdsaPkey = NULL;
CRYPT_EAL_PkeyPub ECDSAPubkey;
KeyData pubKeyVector = {{0}, KEY_MAX_LEN};
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ecdsaPkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE_AND_LOG("New ECDSA Pkey", ecdsaPkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ecdsaPkey, eccId), CRYPT_SUCCESS);
ret = EccPointToBuffer(publicX, publicY, pointFormat, &pubKeyVector);
ASSERT_TRUE_AND_LOG("EccPointToBuffer", ret == CRYPT_SUCCESS);
Ecc_SetPubKey(&ECDSAPubkey, CRYPT_PKEY_ECDSA, pubKeyVector.data, pubKeyVector.len);
if (result == 1) {
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ecdsaPkey, &ECDSAPubkey), CRYPT_SUCCESS);
} else {
ASSERT_NE(CRYPT_EAL_PkeySetPub(ecdsaPkey, &ECDSAPubkey), CRYPT_SUCCESS);
}
EXIT:
CRYPT_EAL_PkeyFreeCtx(ecdsaPkey);
TestRandDeInit();
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_GET_PARA_FUNC_TC001
* @title ECD CRYPT_EAL_PkeyGetPara test.
* @precon Registering memory-related functions.
* @brief
* 1. Create context of the ECDSA algorithm, expected result 1
* 2. Set para, expected result 2
* 3. Get para, expected result 3
* 4. Check whether the set parameters and the obtained parameters are the same, expected result 4
* @expect
* 1. Success, and two contexts are not NULL.
* 2-3. CRYPT_SUCCESS
* 4. The parameters are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_GET_PARA_FUNC_TC001(Hex *p, Hex *a, Hex *b, Hex *x, Hex *y, Hex *n, Hex *h)
{
ASSERT_TRUE(EAL_PkeyGetPara_Func_TC001(CRYPT_PKEY_ECDSA, p, a, b, x, y, n, h) == 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_GEN_KEY_FUNC_TC001
* @title ECDSA CRYPT_EAL_PkeyGen test.
* @precon nan
* @brief
* 1. Create context of the ECDSA algorithm, expected result 1
* 2. Set elliptic curve type, expected result 2
* 3. Mock BN_RandRange to STUB_RandRangeK
* 4. Init the drbg, expected result 4
* 5. Call the CRYPT_EAL_PkeyGen method to generate a key pair, expected result 5
* 6. Get public key and private key, expected result 6
* 7. Compare the getted key and vector, expected result 7
* @expect
* 1. Success, and two contexts are not NULL.
* 2. non
* 4-6. CRYPT_SUCCESS
* 7. The getted key and vector are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_GEN_KEY_FUNC_TC001(
int eccId, Hex *prvKeyVector, Hex *pubKeyX, Hex *pubKeyY, int pointFormat, int isProvider)
{
if (IsCurveDisabled(eccId)) {
SKIP_TEST();
}
Ecc_GenKey(CRYPT_PKEY_ECDSA, eccId, prvKeyVector, pubKeyX, pubKeyY, pointFormat, isProvider);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_KEY_PAIR_CHECK_FUNC_TC001
* @title ECDSA: key pair check.
* @precon Registering memory-related functions.
* @brief
* 1. Create two contexts(pubCtx, prvCtx) of the ecdsa algorithm, expected result 1
* 2. Init the drbg, expected result 2
* 3. Set para for pubCtx, expected result 3
* 4. Set public key for pubCtx, expected result 4
* 5. Set para and private key for prvCtx, expected result 5
* 6. Check whether the public key matches the private key, expected result 6
* @expect
* 1. Success, and contexts are not NULL.
* 2-5. CRYPT_SUCCESS
* 6. Return CRYPT_SUCCESS when expect is 1, CRYPT_ECDSA_VERIFY_FAIL otherwise.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_KEY_PAIR_CHECK_FUNC_TC001(
int eccId, Hex *prvKeyVector, Hex *pubKeyX, Hex *pubKeyY, int pointFormat, int expect)
{
#if !defined(HITLS_CRYPTO_ECDSA_CHECK)
(void)eccId;
(void)prvKeyVector;
(void)pubKeyX;
(void)pubKeyY;
(void)pointFormat;
(void)expect;
SKIP_TEST();
#else
if (IsCurveDisabled(eccId)) {
SKIP_TEST();
}
CRYPT_EAL_PkeyCtx *pubCtx = NULL;
CRYPT_EAL_PkeyCtx *prvCtx = NULL;
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
KeyData pubKeyVector = {{0}, KEY_MAX_LEN};
int expectRet = expect == 1 ? CRYPT_SUCCESS : CRYPT_ECDSA_PAIRWISE_CHECK_FAIL;
ASSERT_EQ(EccPointToBuffer(pubKeyX, pubKeyY, pointFormat, &pubKeyVector), CRYPT_SUCCESS);
Ecc_SetPubKey(&pub, CRYPT_PKEY_ECDSA, pubKeyVector.data, pubKeyVector.len);
Ecc_SetPrvKey(&prv, CRYPT_PKEY_ECDSA, prvKeyVector->x, prvKeyVector->len);
TestMemInit();
pubCtx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ECDSA);
prvCtx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ECDSA);
ASSERT_TRUE(pubCtx != NULL && prvCtx != NULL);
/* pubCtx*/
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pubCtx, eccId), CRYPT_SUCCESS);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubCtx, &pub), CRYPT_SUCCESS);
/* prvCtx*/
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(prvCtx, eccId), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prv), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), expectRet);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pubCtx);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_ECDSA_API_TC026
* @title ECDSA get key length
* @brief
1.create ECDSA context. Expect result 1
2.set curve,expect result 2
3.get key length, expect result 3
* @expect 1.context created successfully
2.Success
3.Success
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_API_TC026(int paraId, int keyLen, int isProvider)
{
CRYPT_EAL_PkeyCtx *ecdsaPkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ecdsaPkey, paraId), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetKeyLen(ecdsaPkey), keyLen);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ecdsaPkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_GETSECURITYBITS_API_TC001
* @title Get security bits test
* @brief
* 1. Create context of the ECDSA algorithm, expected result 1
* 2. Set curve type, expected result 2
* 3. Get para, expected result 3
* 4. Obtain security bits are the same, expected result 4
* @expect
* 1. Success, and two contexts are not NULL.
* 2-3. CRYPT_SUCCESS
* 4. The security bits are correct.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_GETSECURITYBITS_API_TC001(int eccId, Hex *prvKeyVector, int secBits, int isProvider)
{
CRYPT_EAL_PkeyCtx *ecdsaPkey = NULL;
CRYPT_EAL_PkeyPrv ecdsaPrvkey = {0};
ecdsaPkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE_AND_LOG("New ECDH Pkey", ecdsaPkey != NULL);
// Set elliptic curve type CRYPT_ECC_NISTP224 = 13
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ecdsaPkey, eccId), CRYPT_SUCCESS);
// Set private key
ecdsaPrvkey.id = CRYPT_PKEY_ECDSA;
ecdsaPrvkey.key.eccPrv.data = prvKeyVector->x;
ecdsaPrvkey.key.eccPrv.len = prvKeyVector->len;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ecdsaPkey, &ecdsaPrvkey), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetSecurityBits(ecdsaPkey) == (uint32_t)secBits);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ecdsaPkey);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_CHECK_KEYPAIR_FUNC_TC001
* @title ECDSA CRYPT_EAL_PkeyPairCheck test.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_CHECK_KEYPAIR_FUNC_TC001(int paraid, int isProvider)
{
#if !defined(HITLS_CRYPTO_ECDSA_CHECK)
(void)paraid;
(void)isProvider;
SKIP_TEST();
#else
TestMemInit();
uint8_t wrong[KEY_MAX_LEN] = {1};
CRYPT_EAL_PkeyPub ecdsaPubKey = {0};
CRYPT_EAL_PkeyPrv ecdsaPrvKey = {0};
KeyData pubKeyVector = {{0}, KEY_MAX_LEN};
KeyData prvKeyVector = {{0}, KEY_MAX_LEN};
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pubCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *prvCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(pubCtx != NULL);
ASSERT_TRUE(prvCtx != NULL);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, paraid), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pubCtx, paraid), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(prvCtx, paraid), CRYPT_SUCCESS);
Ecc_SetPubKey(&ecdsaPubKey, CRYPT_PKEY_ECDSA, pubKeyVector.data, pubKeyVector.len);
Ecc_SetPrvKey(&ecdsaPrvKey, CRYPT_PKEY_ECDSA, prvKeyVector.data, prvKeyVector.len);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pkey, pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &ecdsaPubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &ecdsaPrvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubCtx, &ecdsaPubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &ecdsaPrvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_SUCCESS);
ecdsaPrvKey.key.eccPrv.data = wrong;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &ecdsaPrvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_ECDSA_PAIRWISE_CHECK_FAIL);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(pubCtx);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ECDSA_CHECK_PRVKEY_FUNC_TC001
* @title ECDSA CRYPT_EAL_PkeyPrvCheck test.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ECDSA_CHECK_PRVKEY_FUNC_TC001(int paraid, int isProvider)
{
#if !defined(HITLS_CRYPTO_ECDSA_CHECK)
(void)paraid;
(void)isProvider;
SKIP_TEST();
#else
TestMemInit();
CRYPT_EAL_PkeyPrv ecdsaPrvKey = {0};
CRYPT_ECDSA_Ctx *ctx = NULL;
BN_BigNum *n = NULL;
BN_BigNum *prvKey = NULL;
KeyData prvKeyVector = {{0}, KEY_MAX_LEN};
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *prvCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_ECDSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(prvCtx != NULL);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, paraid), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(prvCtx, paraid), CRYPT_SUCCESS);
Ecc_SetPrvKey(&ecdsaPrvKey, CRYPT_PKEY_ECDSA, prvKeyVector.data, prvKeyVector.len);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_ECC_PKEY_ERR_EMPTY_KEY);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SUCCESS);
ctx = (CRYPT_ECDSA_Ctx *)pkey->key;
prvKey = ctx->prvkey;
n = ECC_GetParaN(ctx->para);
(void)BN_Copy(prvKey, n);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_ECDSA_INVALID_PRVKEY);
(void)BN_SubLimb(prvKey, prvKey, 1); // key = n - 1
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SUCCESS);
(void)BN_Zeroize(prvKey); // key = 0
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_ECDSA_INVALID_PRVKEY);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
BN_Destroy(n);
#endif
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/ecc/test_suite_sdv_eal_ecdsa.c | C | unknown | 59,199 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include "bsl_err.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_rand.h"
#include "crypt_bn.h"
#include "eal_pkey_local.h"
#include "stub_replace.h"
#include "crypt_util_rand.h"
#include "crypt_elgamal.h"
#include "elgamal_local.h"
#include "bn_basic.h"
#include "securec.h"
/* END_HEADER */
#define CRYPT_EAL_PKEY_KEYMGMT_OPERATE 0
#define CRYPT_EAL_PKEY_CIPHER_OPERATE 1
#define CRYPT_EAL_PKEY_EXCH_OPERATE 2
#define CRYPT_EAL_PKEY_SIGN_OPERATE 4
void *malloc_fail(uint32_t size)
{
(void)size;
return NULL;
}
void SetElGamalPara(CRYPT_EAL_PkeyPara *para, Hex *q, uint32_t bits,uint32_t k_bits)
{
para->id = CRYPT_PKEY_ELGAMAL;
para->para.elgamalPara.q = q->x;
para->para.elgamalPara.qLen = q->len;
para->para.elgamalPara.bits = bits;
para->para.elgamalPara.k_bits = k_bits;
}
void SetElGamalPubKey(CRYPT_EAL_PkeyPub *pubKey, uint8_t *g, uint32_t gLen, uint8_t *p, uint32_t pLen, uint8_t *y, uint32_t yLen, uint8_t *q, uint32_t qLen)
{
pubKey->id = CRYPT_PKEY_ELGAMAL;
pubKey->key.elgamalPub.g = g;
pubKey->key.elgamalPub.gLen = gLen;
pubKey->key.elgamalPub.p = p;
pubKey->key.elgamalPub.pLen = pLen;
pubKey->key.elgamalPub.y = y;
pubKey->key.elgamalPub.yLen = yLen;
pubKey->key.elgamalPub.q = q;
pubKey->key.elgamalPub.qLen = qLen;
}
void SetElGamalPrvKey(CRYPT_EAL_PkeyPrv *prvKey, uint8_t *x, uint32_t xLen)
{
prvKey->id = CRYPT_PKEY_ELGAMAL;
prvKey->key.elgamalPrv.x = x;
prvKey->key.elgamalPrv.xLen = xLen;
}
int32_t RandFunc(uint8_t *randNum, uint32_t randLen)
{
const int maxNum = 255;
for (uint32_t i = 0; i < randLen; i++) {
randNum[i] = (uint8_t)(rand() % maxNum);
}
return 0;
}
int32_t RandFuncEx(void *libCtx, uint8_t *randNum, uint32_t randLen)
{
(void)libCtx;
return RandFunc(randNum, randLen);
}
/**
* @test SDV_CRYPTO_ELGAMAL_NEW_API_TC001
* @title ELGAMAL CRYPT_EAL_PkeyNewCtx test.
* @precon nan
* @brief
* 1. Call the CRYPT_EAL_PkeyNewCtx method to create ctx, algId is CRYPT_PKEY_ELGAMAL, expected result 1.
* 2. Release the ctx.
* 3. Repeat steps 1 to 2 for 100 times.
* @expect
* 1. The returned result is not empty.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ELGAMAL_NEW_API_TC001(int isProvider)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = NULL;
/* Run 100 times */
for (int i = 0; i < 100; i++) {
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ELGAMAL, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
CRYPT_EAL_PkeyFreeCtx(pkey);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ELGAMAL_NEW_API_TC002
* @title ELGAMAL CRYPT_EAL_PkeyNewCtx test: Malloc failed.
* @precon Mock BSL_SAL_Malloc to malloc_fail.
* @brief
* 1. Call the CRYPT_EAL_PkeyNewCtx method to create ctx, algId is CRYPT_PKEY_ELGAMAL, expected result 1.
* 2. Release the ctx.
* 3. Reset the BSL_SAL_Malloc.
* @expect
* 1. Failed to create the ctx.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ELGAMAL_NEW_API_TC002(int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
FuncStubInfo tmpRpInfo = {0};
STUB_Init();
ASSERT_TRUE(STUB_Replace(&tmpRpInfo, BSL_SAL_Malloc, malloc_fail) == 0);
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ELGAMAL, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey == NULL);
EXIT:
STUB_Reset(&tmpRpInfo);
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ELGAMAL_SET_PARA_API_TC001
* @title ELGAMAL CRYPT_EAL_PkeySetPara test.
* @precon Create the context of the elgamal algorithm.
*
* @brief
* 1. Call the CRYPT_EAL_PkeySetPara method:
* (1) para = NULL, expected result 1.
* (2) qLen != BN_BITS_TO_BYTES(k_bits), expected result 2.
* (3) q = NULL, bits = 0, expected result 2.
* (4) qLen = BN_BITS_TO_BYTES(k_bits), bits != 0, expected result 3.
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_EAL_ERR_NEW_PARA_FAIL
* 3. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ELGAMAL_SET_PARA_API_TC001(Hex *q,int k_bits, int bits, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPara para = {0};
SetElGamalPara(¶, q, bits , k_bits);
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ELGAMAL, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, NULL), CRYPT_NULL_INPUT);
uint32_t bytes = BN_BITS_TO_BYTES(k_bits);
if (q->len != bytes) {
ASSERT_TRUE_AND_LOG("qLen != BN_BITS_TO_BYTES(k_bits)",
CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_MEM_ALLOC_FAIL);
}
if ( q->len == bytes && bits == 0) {
ASSERT_TRUE_AND_LOG(" q = NULL, bits = 0",
CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_MEM_ALLOC_FAIL);
}
if (q->len == bytes && bits <= k_bits ){
ASSERT_TRUE_AND_LOG(" bits <= k_bits ",
CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_MEM_ALLOC_FAIL);
}
if (q->len == bytes && bits != 0) {
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
}
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ELGAMAL_GEN_API_TC001
* @title ELGAMAL CRYPT_EAL_PkeyGen: No regist rand.
* @precon Create the contexts of the elgamal algorithm and set para.
* @brief
* 1. Call the CRYPT_EAL_PkeyGen method to generate a key pair, expected result 1.
* @expect
* 1. Failed to generate a key pair, the return value is CRYPT_NO_REGIST_RAND.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ELGAMAL_GEN_API_TC001( Hex *q,int k_bits, int bits, int isProvider)
{
CRYPT_EAL_PkeyPara para = {0};
SetElGamalPara(¶, q, bits, k_bits);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey;
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ELGAMAL, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_NO_REGIST_RAND);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ELGAMAL_GET_PUB_API_TC001
* @title ELGAMAL CRYPT_EAL_PkeyGetPub test.
* @precon 1. Create the context of the elgamal algorithm.
* 2. Initialize the DRBG.
* @brief
* 1. Call the CRYPT_EAL_PkeyGetPub method without public key, expected result 1
* 2. Set para and generate a key pair, expected result 2
* 3. Call the CRYPT_EAL_PkeyGetPub method:
* (1) pkey = NULL, expected result 1.
* (2) pub = NULL, expected result 1.
* (3) p = NULL, expected result 1.
* (4) p != NULL and pLen = 0, expected result 3.
* (5) g = NULL, expected result 1.
* (6) g != NULL, gLen = 0, expected result 3.
* (7) y = NULL, expected result 1.
* (8) y != NULL and yLen = 0, expected result 3.
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_SUCCESS
* 3. CRYPT_BN_BUFF_LEN_NOT_ENOUGH
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ELGAMAL_GET_PUB_API_TC001( Hex *q, int k_bits, int bits, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPub pubKey = {0};
uint8_t pubG[600];
uint8_t pubP[600];
uint8_t pubY[600];
uint8_t pubQ[600];
SetElGamalPara(¶, q, bits,k_bits);
SetElGamalPubKey(&pubKey, pubG, 600, pubP, 600,pubY, 600,pubQ,600);
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ELGAMAL, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
/* Missing public key */
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(NULL, &pubKey), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, NULL), CRYPT_NULL_INPUT);
/* p = NULL */
pubKey.key.elgamalPub.p = NULL;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_NULL_INPUT);
pubKey.key.elgamalPub.p = pubP;
/* p != NULL and pLen = 0 */
pubKey.key.elgamalPub.pLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_BN_BUFF_LEN_NOT_ENOUGH);
pubKey.key.elgamalPub.pLen = 600;
/* g = NULL */
pubKey.key.elgamalPub.g = NULL;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_NULL_INPUT);
pubKey.key.elgamalPub.g = pubG;
/* g != NULL, gLen = 0 */
pubKey.key.elgamalPub.gLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_BN_BUFF_LEN_NOT_ENOUGH);
/* y = NULL */
pubKey.key.elgamalPub.y = NULL;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_NULL_INPUT);
pubKey.key.elgamalPub.y = pubY;
/* y != NULL and yLen = 0 */
pubKey.key.elgamalPub.yLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_BN_BUFF_LEN_NOT_ENOUGH);
pubKey.key.elgamalPub.yLen = 600;
/* q = NULL */
pubKey.key.elgamalPub.q = NULL;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_NULL_INPUT);
pubKey.key.elgamalPub.q = pubQ;
/* q != NULL and qLen = 0 */
pubKey.key.elgamalPub.qLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_BN_BUFF_LEN_NOT_ENOUGH);
pubKey.key.elgamalPub.qLen = 600;
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ELGAMAL_GET_PRV_API_TC001
* @title ELGAMAL CRYPT_EAL_PkeyGetPrv: Bad private key.
* @precon 1. Create the context of the elgamal algorithm.
* 2. Initialize the DRBG.
* @brief
* 1. Call the CRYPT_EAL_PkeyGetPrv method without private key, expected result 1
* 2. Set para and generate a key pair, expected result 2
* 3. Call the CRYPT_EAL_PkeyGetPrv method:
* (1) pkey = NULL, expected result 1.
* (2) prv = NULL, expected result 1.
* (3) x = NULL, expected result 1.
* (4) x != NULL and xLen = 0, expected result 3.
* (5) x != NULL, xLen != 0, , expected result 2.
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_SUCCESS
* 3. CRYPT_BN_BUFF_LEN_NOT_ENOUGH
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ELGAMAL_GET_PRV_API_TC001(Hex *q, int k_bits,int bits, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPrv prvKey = {0};
CRYPT_EAL_PkeyPara para = {0};
uint8_t prvX[600];
SetElGamalPrvKey(&prvKey, prvX, 600);
SetElGamalPara(¶, q, bits,k_bits);
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ELGAMAL, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
/* Missing private key */
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(NULL, &prvKey), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, NULL), CRYPT_NULL_INPUT);
/* x = NULL */
prvKey.key.elgamalPrv.x = NULL;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey), CRYPT_ELGAMAL_ERR_INPUT_VALUE);
prvKey.key.elgamalPrv.x = prvX;
/* x != NULL and xLen = 0 */
prvKey.key.elgamalPrv.xLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey), CRYPT_BN_BUFF_LEN_NOT_ENOUGH);
prvKey.key.elgamalPrv.xLen = 600;
/* x != NULL, xLen != 0 */
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey), CRYPT_SUCCESS);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ELGAMAL_SET_PRV_API_TC001
* @title ELGAMAL CRYPT_EAL_PkeySetPrv: Bad private key.
* @precon Create the contexts of the elgamal algorithm and set para:
* pkey1: Generate a key pair.
* pkey2: set the private key.
* @brief
* 1. Call the CRYPT_EAL_PkeySetPrv method:
* (1) pKey is NULL, expected result 1.
* (2) prv is NULL, expected result 1.
* (3) p = NULL, expected result 2.
* (4) g = NULL, expected result 2.
* (5) x = NULL, expected result 2.
* (6) pLen = 0, expected result 2.
* (7) gLen = 0, expected result 2.
* (8) xLen = 0, expected result 2.
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_ELGAMAL_ERR_INPUT_VALUE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ELGAMAL_SET_PRV_API_TC001(Hex *q,int k_bits, int bits, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyCtx *pkey2 = NULL;
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPrv prvKey = {0};
uint8_t prvP[600];
uint8_t prvG[600];
uint8_t prvX[600];
SetElGamalPrvKey(&prvKey, prvX, 600);
SetElGamalPara(¶, q, bits,k_bits);
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ELGAMAL, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_ELGAMAL, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL && pkey2 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey2, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
/*pKey is NULL*/
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(NULL, &prvKey) == CRYPT_NULL_INPUT);
/*prvKey is NULL*/
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey2, NULL) == CRYPT_NULL_INPUT);
prvKey.key.elgamalPrv.p = prvP;
prvKey.key.elgamalPrv.pLen = 600;
prvKey.key.elgamalPrv.g= prvG;
prvKey.key.elgamalPrv.gLen = 600;
/*p = NULL*/
prvKey.key.elgamalPrv.p = NULL;
ASSERT_TRUE_AND_LOG("p is NULL", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_ELGAMAL_ERR_INPUT_VALUE);
prvKey.key.elgamalPrv.p = prvP;
/*g = NULL*/
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
prvKey.key.elgamalPrv.g = NULL;
ASSERT_TRUE_AND_LOG("g is NULL", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_ELGAMAL_ERR_INPUT_VALUE);
prvKey.key.elgamalPrv.g = prvG;
/*x = NULL*/
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
prvKey.key.elgamalPrv.x = NULL;
ASSERT_TRUE_AND_LOG("x is NULL", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_ELGAMAL_ERR_INPUT_VALUE);
prvKey.key.elgamalPrv.x = prvX;
/*pLen = 0*/
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
prvKey.key.elgamalPrv.pLen = 0;
ASSERT_TRUE_AND_LOG("pLen is 0", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_ELGAMAL_ERR_INPUT_VALUE);
prvKey.key.elgamalPrv.pLen = 600;
/*gLen = 0*/
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
prvKey.key.elgamalPrv.gLen = 0;
ASSERT_TRUE_AND_LOG("gLen is 0", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_ELGAMAL_ERR_INPUT_VALUE);
prvKey.key.elgamalPrv.gLen = 600;
/*xLen = 0*/
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
prvKey.key.elgamalPrv.xLen = 0;
ASSERT_TRUE_AND_LOG("xLen is 0", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_ELGAMAL_ERR_INPUT_VALUE);
prvKey.key.elgamalPrv.xLen = 600;
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(pkey2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ELGAMAL_SET_PUB_API_TC001
* @title ELGAMAL CRYPT_EAL_PkeyGetPub: Bad public key.
* @precon Create the contexts of the elgamal algorithm and set para:
* pkey1: Generate a key pair.
* pkey2: Set the public key.
* @brief
* 1. Call the CRYPT_EAL_PkeyGetPub method:
* (1) pKey is NULL, expected result 1.
* (2) prv is NULL, expected result 1.
* (3) p = NULL, expected result 1.
* (4) g = NULL, expected result 1.
* (5) y = NULL, expected result 1.
* @expect
* 1. CRYPT_NULL_INPUT
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ELGAMAL_SET_PUB_API_TC001( Hex *q,int k_bits, int bits, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyCtx *pkey2 = NULL;
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPub pubKey;
uint8_t pubG[600];
uint8_t pubP[600];
uint8_t pubY[600];
uint8_t pubQ[600];
SetElGamalPara(¶, q, bits,k_bits);
SetElGamalPubKey(&pubKey, pubP, 600, pubG, 600, pubY, 600, pubQ, 600);
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ELGAMAL, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_ELGAMAL, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL && pkey2 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey2, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS);
/*pKey is NULL*/
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(NULL, &pubKey) == CRYPT_NULL_INPUT);
/*pubKey is NULL*/
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey2, NULL) == CRYPT_NULL_INPUT);
/*p = NULL*/
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pubKey) == CRYPT_SUCCESS);
pubKey.key.elgamalPub.p = NULL;
ASSERT_TRUE_AND_LOG("p is NULL", CRYPT_EAL_PkeySetPub(pkey2, &pubKey) == CRYPT_NULL_INPUT);
pubKey.key.elgamalPub.p = pubP;
/*g = NULL*/
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pubKey) == CRYPT_SUCCESS);
pubKey.key.elgamalPub.g = NULL;
ASSERT_TRUE_AND_LOG("g is NULL", CRYPT_EAL_PkeySetPub(pkey2, &pubKey) == CRYPT_NULL_INPUT);
pubKey.key.elgamalPub.g = pubG;
/*q = NULL*/
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pubKey) == CRYPT_SUCCESS);
pubKey.key.elgamalPub.q = NULL;
ASSERT_TRUE_AND_LOG("g is NULL", CRYPT_EAL_PkeySetPub(pkey2, &pubKey) == CRYPT_NULL_INPUT);
pubKey.key.elgamalPub.q = pubQ;
/*y = NULL*/
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pubKey) == CRYPT_SUCCESS);
pubKey.key.elgamalPub.y = NULL;
ASSERT_TRUE_AND_LOG("y is NULL", CRYPT_EAL_PkeySetPub(pkey2, &pubKey) == CRYPT_NULL_INPUT);
pubKey.key.elgamalPub.y = pubY;
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pubKey) == CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("set prvKey success", CRYPT_EAL_PkeySetPub(pkey2, &pubKey) == CRYPT_SUCCESS);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(pkey2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ELGAMAL_ENC_API_TC001
* @title ELGAMAL CRYPT_EAL_PkeyEncrypt: Test the validity of input parameters.
* @precon Create the context of the elgamal algorithm:
* @brief
* 1. Call the CRYPT_EAL_PkeyEncrypt method without public key, expected result 1
* 2. Set pubkey, expected result 2
* 3. Call the CRYPT_EAL_PkeyEncrypt method:
* (1) pkey = NULL, expected result 3
* (2) data = NULL, expected result 3
* (3) data != NULL dataLen > bytes of ctx, expected result 4
* (4) out = NULL, expected result 3
* (5) outLen = NULL, expected result 3
* (6) outLen = 0, expected result 5
* (7) no modification, expected result 2
* @expect
* 1. CRYPT_ELGAMAL_NO_KEY_INFO
* 2. CRYPT_SUCCESS
* 3. CRYPT_NULL_INPUT
* 4. CRYPT_ELGAMAL_ERR_ENC_BITS
* 5. CRYPT_ELGAMAL_BUFF_LEN_NOT_ENOUGH
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ELGAMAL_ENC_API_TC001(Hex *q,Hex *p, Hex *g, Hex *y, Hex *in, int isProvider)
{
uint8_t crypt[512];
uint32_t cryptLen = 512;
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPub pubkey = {0};
SetElGamalPubKey(&pubkey, g->x, g->len, p->x, p->len, y->x, y->len,q->x,q->len);
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ELGAMAL, CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyEncrypt(pkey, in->x, in->len, crypt, &cryptLen), CRYPT_ELGAMAL_NO_KEY_INFO);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey, &pubkey) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(NULL, in->x, in->len, crypt, &cryptLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, NULL, in->len, crypt, &cryptLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, in->x, 257, crypt, &cryptLen) == CRYPT_ELGAMAL_ERR_ENC_BITS);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, in->x, in->len, NULL, &cryptLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, in->x, in->len, crypt, NULL) == CRYPT_NULL_INPUT);
cryptLen = 0;
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, in->x, in->len, crypt, &cryptLen) == CRYPT_ELGAMAL_BUFF_LEN_NOT_ENOUGH);
cryptLen = 512;
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, in->x, in->len, crypt, &cryptLen) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ELGAMAL_DEC_API_TC001
* @title ELGAMAL CRYPT_EAL_PkeyDecrypt: Test the validity of input parameters.
* @precon Create the context of the elgamal algorithm:
* @brief
* 1. Call the CRYPT_EAL_PkeyDecrypt method without private key, expected result 1
* 2. Set private key, expected result 2
* 4. Call the CRYPT_EAL_PkeyDecrypt method:
* (1) pkey = NULL, expected result 3
* (2) data = NULL, expected result 3
* (3) data != NULL, dataLen = 0, expected result 4
* (4) data != NULL, dataLen is invalid , expected result 4
* (5) out = NULL, expected result 3
* (6) outLen = NULL, expected result 3
* (7) outLen = 0, expected result 5
* (8) no modification, expected result 2
* @expect
* 1. CRYPT_ELGAMAL_NO_KEY_INFO
* 2. CRYPT_SUCCESS
* 3. CRYPT_NULL_INPUT
* 4. CRYPT_ELGAMAL_ERR_DEC_BITS
* 5. CRYPT_ELGAMAL_BUFF_LEN_NOT_ENOUGH
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ELGAMAL_DEC_API_TC001(Hex *p, Hex *g ,Hex *x, Hex *in, int isProvider)
{
uint8_t crypt[512];
uint32_t cryptLen = 512;
CRYPT_EAL_PkeyPrv prvkey = {0};
CRYPT_EAL_PkeyCtx *pkey = NULL;
SetElGamalPrvKey(&prvkey, x->x, x->len);
prvkey.key.elgamalPrv.p = p->x;
prvkey.key.elgamalPrv.pLen = p->len;
prvkey.key.elgamalPrv.g = g->x;
prvkey.key.elgamalPrv.gLen = g->len;
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ELGAMAL, CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, in->x, in->len, crypt, &cryptLen) == CRYPT_ELGAMAL_NO_KEY_INFO);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey, &prvkey) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(NULL, in->x, in->len, crypt, &cryptLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, NULL, in->len, crypt, &cryptLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, in->x, 0, crypt, &cryptLen) == CRYPT_ELGAMAL_ERR_DEC_BITS);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, in->x, 257, crypt, &cryptLen) == CRYPT_ELGAMAL_ERR_DEC_BITS);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, in->x, in->len, NULL, &cryptLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, in->x, in->len, crypt, NULL) == CRYPT_NULL_INPUT);
cryptLen = 0;
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, in->x, in->len, crypt, &cryptLen) == CRYPT_ELGAMAL_BUFF_LEN_NOT_ENOUGH);
cryptLen = 512;
ASSERT_EQ(CRYPT_EAL_PkeyDecrypt(pkey, in->x, in->len, crypt, &cryptLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
int Compare_PubKey(CRYPT_EAL_PkeyPub *pubKey1, CRYPT_EAL_PkeyPub *pubKey2)
{
if (pubKey1->key.elgamalPub.pLen != pubKey2->key.elgamalPub.pLen || pubKey1->key.elgamalPub.gLen != pubKey2->key.elgamalPub.gLen||
pubKey1->key.elgamalPub.qLen != pubKey2->key.elgamalPub. qLen || pubKey1->key.elgamalPub.yLen != pubKey2->key.elgamalPub.yLen) {
return -1; // -1 indicates failure
}
if (memcmp(pubKey1->key.elgamalPub.p, pubKey2->key.elgamalPub.p, pubKey1->key.elgamalPub.pLen) != 0 ||
memcmp(pubKey1->key.elgamalPub.g, pubKey2->key.elgamalPub.g, pubKey1->key.elgamalPub.gLen) != 0 ||
memcmp(pubKey1->key.elgamalPub.q, pubKey2->key.elgamalPub.q, pubKey1->key.elgamalPub.qLen) != 0 ||
memcmp(pubKey1->key.elgamalPub.y, pubKey2->key.elgamalPub.y, pubKey1->key.elgamalPub.yLen) != 0 ) {
return -1; // -1 indicates failure
}
return 0;
}
int Compare_PrvKey(CRYPT_EAL_PkeyPrv *prvKey1, CRYPT_EAL_PkeyPrv *prvKey2)
{
if (prvKey1->key.elgamalPrv.pLen != prvKey2->key.elgamalPrv.pLen || prvKey1->key.elgamalPrv.gLen != prvKey2->key.elgamalPrv.gLen ||
prvKey1->key.elgamalPrv.xLen != prvKey2->key.elgamalPrv.xLen ) {
return -1; // -1 indicates failure
}
if (memcmp(prvKey1->key.elgamalPrv.g, prvKey2->key.elgamalPrv.g, prvKey1->key.elgamalPrv.gLen) != 0 ||
memcmp(prvKey1->key.elgamalPrv.p, prvKey2->key.elgamalPrv.p, prvKey1->key.elgamalPrv.pLen) != 0 ||
memcmp(prvKey1->key.elgamalPrv.x, prvKey2->key.elgamalPrv.x, prvKey1->key.elgamalPrv.xLen) != 0) {
return -1; // -1 indicates failure
}
return 0;
}
/**
* @test SDV_CRYPTO_ELGAMAL_SET_KEY_API_TC001
* @title ELGAMAL Set the public key and private key multiple times.
* @precon Create the contexts of the elgamal algorithm and:
* pkey1: Set paran and generate a key pair: test obtaining the key.
* pkey2: Test set keys, and verify that the public and private keys can exist at the same time.
* @brief
* 1. pkey1: Get public key and get private key, expected result 1
* 2. pkey2:
* (1) Set public key and set private key, expected result 1
* (2) Get public key, get private key and check private key, expected result 2
* (3) Set private key and set public key, expected result 3
* (4) Get private key, get public key and check public key, expected result 4
* @expect
* 1. CRYPT_SUCCESS
* 2. The obtained private key is equal to the set private key.
* 3. CRYPT_SUCCESS
* 4. The obtained public key is equal to the set public key.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ELGAMAL_SET_KEY_API_TC001( Hex *q, int k_bits, int bits, int isProvider)
{
uint8_t pubP[600];
uint8_t pubG[600];
uint8_t pubQ[600];
uint8_t pubY[600];
uint8_t prvP[600];
uint8_t prvG[600];
uint8_t prvX[600];
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPub pubKey = {0};
CRYPT_EAL_PkeyPrv prvKey = {0};
SetElGamalPara(¶, q, bits, k_bits);
SetElGamalPubKey(&pubKey, pubG, 600, pubP, 600, pubY, 600, pubQ, 600);
SetElGamalPrvKey(&prvKey, prvX, 600);
prvKey.key.elgamalPrv.p = prvP;
prvKey.key.elgamalPrv.pLen = 600;
prvKey.key.elgamalPrv.g = prvG;
prvKey.key.elgamalPrv.gLen = 600;
TestMemInit();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
CRYPT_EAL_PkeyCtx *pkey1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_ELGAMAL, CRYPT_EAL_PKEY_KEYMGMT_OPERATE,
"provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_ELGAMAL, CRYPT_EAL_PKEY_KEYMGMT_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pkey1 != NULL && pkey2 != NULL);
/* pkey1 */
/* Generate a key pair. */
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey1, ¶) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey1), CRYPT_SUCCESS);
/* Get keys. */
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey1, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey1, &prvKey), CRYPT_SUCCESS);
/* pkey2 */
/* Set public key and set private key. */
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey2, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey2, &prvKey), CRYPT_SUCCESS);
/* Get public key, get private key and check private key.*/
SetElGamalPubKey(&pubKey, pubG, 600, pubP, 600, pubY, 600, pubQ, 600);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey2, &pubKey), CRYPT_SUCCESS);
SetElGamalPrvKey(&prvKey, prvX, 600);
prvKey.key.elgamalPrv.p = prvP;
prvKey.key.elgamalPrv.pLen = 600;
prvKey.key.elgamalPrv.g = prvG;
prvKey.key.elgamalPrv.gLen = 600;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey2, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(Compare_PrvKey(&prvKey, &prvKey), 0);
/* Set private key and set public key. */
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey2, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey2, &pubKey), CRYPT_SUCCESS);
/* Get private key, get public key and check public key.*/
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey2, &prvKey), CRYPT_SUCCESS);
SetElGamalPubKey(&pubKey, pubG, 600, pubP, 600, pubY, 600, pubQ, 600);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey2, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(Compare_PubKey(&pubKey, &pubKey), 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ELGAMAL_DUP_CTX_API_TC001
* @title ELGAMAL CRYPT_EAL_PkeyDupCtx test.
* @precon Create the contexts of the elgamal algorithm, set para and generate a key pair.
* @brief
* 1. Call the CRYPT_EAL_PkeyDupCtx mehod to dup elgamal, expected result 1
* @expect
* 1. Success.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ELGAMAL_DUP_CTX_API_TC001( Hex *q,int k_bits, int bits, int isProvider)
{
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyCtx *newPkey = NULL;
CRYPT_EAL_PkeyCtx *pkey = NULL;
SetElGamalPara(¶, q,bits, k_bits);
TestMemInit();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ELGAMAL, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), 0);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
CRYPT_ELGAMAL_Ctx *elgamalCtx = (CRYPT_ELGAMAL_Ctx *)pkey->key;
ASSERT_TRUE(elgamalCtx != NULL);
newPkey = CRYPT_EAL_PkeyDupCtx(pkey);
ASSERT_TRUE(newPkey != NULL);
ASSERT_EQ(newPkey->references.count, 1);
CRYPT_ELGAMAL_Ctx *elgamalCtx2 = (CRYPT_ELGAMAL_Ctx *)newPkey->key;
ASSERT_TRUE(elgamalCtx2 != NULL);
ASSERT_COMPARE("elgamal compare x",
elgamalCtx->prvKey->x->data,
elgamalCtx->prvKey->x->size * sizeof(BN_UINT),
elgamalCtx2->prvKey->x->data,
elgamalCtx2->prvKey->x->size * sizeof(BN_UINT));
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(newPkey);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_ELGAMAL_GET_SECURITY_BITS_FUNC_TC001
* @title ELGAMAL CRYPT_EAL_PkeyGetSecurityBits test.
* @precon nan
* @brief
* 1. Create the context of the elgamal algorithm, expected result 1
* 2. Set public key, expected result 2
* 3. Call the CRYPT_EAL_PkeyVerify method and the parameter is correct, expected result 3
* @expect
* 1. Success, and the context is not null.
* 2. CRYPT_SUCCESS
* 3. The return value is not 0.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_ELGAMAL_GET_SECURITY_BITS_FUNC_TC001(Hex *q,Hex *p, Hex *g, Hex *y, int securityBits, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPub pubkey = {0};
SetElGamalPubKey(&pubkey, g->x, g->len, p->x, p->len, y->x, y->len, q->x, q->len);
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_ELGAMAL, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pubkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetSecurityBits(pkey), securityBits);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
} | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/elgamal/test_suite_sdv_eal_elgamal.c | C | unknown | 32,586 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_asn1_internal.h"
#include "bsl_err.h"
#include "bsl_log.h"
#include "bsl_init.h"
#include "sal_file.h"
#include "crypt_eal_pkey.h"
#include "crypt_errno.h"
#include "crypt_eal_codecs.h"
#include "crypt_eal_init.h"
#include "crypt_encode_decode_local.h"
#include "crypt_encode_decode_key.h"
#include "crypt_util_rand.h"
#include "bsl_obj_internal.h"
#include "crypt_eal_rand.h"
#include "bsl_params.h"
#include "crypt_params_key.h"
/* END_HEADER */
// clang-format off
/* They are placed in their respective implementations and belong to specific applications, not asn1 modules */
#define BSL_ASN1_CTX_SPECIFIC_TAG_VER 0
#define BSL_ASN1_CTX_SPECIFIC_TAG_ISSUERID 1
#define BSL_ASN1_CTX_SPECIFIC_TAG_SUBJECTID 2
#define BSL_ASN1_CTX_SPECIFIC_TAG_EXTENSION 3
BSL_ASN1_TemplateItem rsaPrvTempl[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0}, /* seq */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* version */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* n */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* e */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* d */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* p */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* q */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* d mod (p-1) */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* d mod (q-1) */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* q^-1 mod p */
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE,
BSL_ASN1_FLAG_OPTIONAL | BSL_ASN1_FLAG_HEADERONLY | BSL_ASN1_FLAG_SAME, 1}, /* OtherPrimeInfos OPTIONAL */
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 2}, /* OtherPrimeInfo */
{BSL_ASN1_TAG_INTEGER, 0, 3}, /* ri */
{BSL_ASN1_TAG_INTEGER, 0, 3}, /* di */
{BSL_ASN1_TAG_INTEGER, 0, 3} /* ti */
};
typedef enum {
RSA_PRV_VERSION_IDX = 0,
RSA_PRV_N_IDX = 1,
RSA_PRV_E_IDX = 2,
RSA_PRV_D_IDX = 3,
RSA_PRV_P_IDX = 4,
RSA_PRV_Q_IDX = 5,
RSA_PRV_DP_IDX = 6,
RSA_PRV_DQ_IDX = 7,
RSA_PRV_QINV_IDX = 8,
RSA_PRV_OTHER_PRIME_IDX = 9
} RSA_PRV_TEMPL_IDX;
// clang-format on
#define BSL_ASN1_TIME_UTC_1 14
#define BSL_ASN1_TIME_UTC_2 15
#define BSL_ASN1_ID_ANY_1 7
#define BSL_ASN1_ID_ANY_2 24
#define BSL_ASN1_ID_ANY_3 34
int32_t BSL_ASN1_CertTagGetOrCheck(int32_t type, uint32_t idx, void *data, void *expVal)
{
switch (type) {
case BSL_ASN1_TYPE_CHECK_CHOICE_TAG: {
if (idx == BSL_ASN1_TIME_UTC_1 || idx == BSL_ASN1_TIME_UTC_2) {
uint8_t tag = *(uint8_t *)data;
if (tag & BSL_ASN1_TAG_UTCTIME || tag & BSL_ASN1_TAG_GENERALIZEDTIME) {
*(uint8_t *)expVal = tag;
return BSL_SUCCESS;
}
}
return BSL_ASN1_FAIL;
}
case BSL_ASN1_TYPE_GET_ANY_TAG: {
BSL_ASN1_Buffer *param = (BSL_ASN1_Buffer *)data;
BslOidString oidStr = {param->len, (char *)param->buff, 0};
BslCid cid = BSL_OBJ_GetCID(&oidStr);
if (idx == BSL_ASN1_ID_ANY_1 || idx == BSL_ASN1_ID_ANY_3) {
if (cid == BSL_CID_RSASSAPSS) {
// note: any It can be encoded empty or it can be null
*(uint8_t *)expVal = BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE;
return BSL_SUCCESS;
} else {
*(uint8_t *)expVal = BSL_ASN1_TAG_NULL; // is null
return BSL_SUCCESS;
}
}
if (idx == BSL_ASN1_ID_ANY_2) {
if (cid == BSL_CID_EC_PUBLICKEY) {
// note: any It can be encoded empty or it can be null
*(uint8_t *)expVal = BSL_ASN1_TAG_OBJECT_ID;
return BSL_SUCCESS;
} else { //
*(uint8_t *)expVal = BSL_ASN1_TAG_NULL; // is null
return BSL_SUCCESS;
}
return BSL_ASN1_FAIL;
}
}
default:
break;
}
return BSL_ASN1_FAIL;
}
int32_t BSL_ASN1_SubKeyInfoTagGetOrCheck(int32_t type, int32_t idx, void *data, void *expVal)
{
switch (type) {
case BSL_ASN1_TYPE_CHECK_CHOICE_TAG: {
if (idx == BSL_ASN1_TIME_UTC_1 || idx == BSL_ASN1_TIME_UTC_2) {
uint8_t tag = *(uint8_t *)data;
if (tag & BSL_ASN1_TAG_UTCTIME || tag & BSL_ASN1_TAG_GENERALIZEDTIME) {
return BSL_SUCCESS;
}
}
return BSL_ASN1_FAIL;
}
case BSL_ASN1_TYPE_GET_ANY_TAG: {
BSL_ASN1_Buffer *param = (BSL_ASN1_Buffer *)data;
BslOidString oidStr = {param->len, (char *)param->buff, 0};
BslCid cid = BSL_OBJ_GetCID(&oidStr);
if (cid == BSL_CID_EC_PUBLICKEY) {
// note: any It can be encoded empty or it can be null
*(uint8_t *)expVal = BSL_ASN1_TAG_OBJECT_ID;
return BSL_SUCCESS;
} else { //
*(uint8_t *)expVal = BSL_ASN1_TAG_NULL; // is null
return BSL_SUCCESS;
}
}
default:
break;
}
return BSL_ASN1_FAIL;
}
static int32_t ReadCert(const char *path, uint8_t **buff, uint32_t *len)
{
size_t readLen;
size_t fileLen = 0;
int32_t ret = BSL_SAL_FileLength(path, &fileLen);
if (ret != BSL_SUCCESS) {
return ret;
}
bsl_sal_file_handle stream = NULL;
ret = BSL_SAL_FileOpen(&stream, path, "rb");
if (ret != BSL_SUCCESS) {
return ret;
}
uint8_t *fileBuff = BSL_SAL_Malloc(fileLen);
if (fileBuff == NULL) {
BSL_SAL_FileClose(stream);
return BSL_MALLOC_FAIL;
}
do {
ret = BSL_SAL_FileRead(stream, fileBuff, 1, fileLen, &readLen);
BSL_SAL_FileClose(stream);
if (ret != BSL_SUCCESS) {
break;
}
*buff = fileBuff;
*len = (uint32_t)fileLen;
return ret;
} while (0);
BSL_SAL_FREE(fileBuff);
return ret;
}
void BinLogFixLenFunc(uint32_t logId, uint32_t logLevel, uint32_t logType, void *format, void *para1, void *para2,
void *para3, void *para4)
{
(void)logLevel;
(void)logType;
printf("logId:%u\t", logId);
printf(format, para1, para2, para3, para4);
printf("\n");
}
void BinLogVarLenFunc(uint32_t logId, uint32_t logLevel, uint32_t logType, void *format, void *para)
{
(void)logLevel;
(void)logType;
printf("logId:%u\t", logId);
printf(format, para);
printf("\n");
}
static void RegisterLogFunc()
{
BSL_LOG_BinLogFuncs func = {0};
func.fixLenFunc = BinLogFixLenFunc;
func.varLenFunc = BinLogVarLenFunc;
BSL_LOG_RegBinLogFunc(&func);
BSL_GLOBAL_Init();
}
static int32_t RandFunc(uint8_t *randNum, uint32_t randLen)
{
for (uint32_t i = 0; i < randLen; i++) {
randNum[i] = (uint8_t)rand();
}
return 0;
}
static int32_t RandFuncEx(void *libCtx, uint8_t *randNum, uint32_t randLen)
{
(void)libCtx;
for (uint32_t i = 0; i < randLen; i++) {
randNum[i] = (uint8_t)rand();
}
return 0;
}
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_RSA_PRV_TC001(char *path, Hex *version, Hex *n, Hex *e, Hex *d, Hex *p, Hex *q, Hex *dp,
Hex *dq, Hex *qinv, int mdId, Hex *msg, Hex *sign)
{
RegisterLogFunc();
uint32_t fileLen = 0;
uint8_t *fileBuff = NULL;
int32_t ret = ReadCert(path, &fileBuff, &fileLen);
ASSERT_EQ(ret, BSL_SUCCESS);
uint8_t *rawBuff = fileBuff;
uint8_t *signdata = NULL;
BSL_ASN1_Buffer asnArr[RSA_PRV_OTHER_PRIME_IDX + 1] = {0};
BSL_ASN1_Template templ = {rsaPrvTempl, sizeof(rsaPrvTempl) / sizeof(rsaPrvTempl[0])};
ret = BSL_ASN1_DecodeTemplate(&templ, BSL_ASN1_CertTagGetOrCheck, &fileBuff, &fileLen, asnArr,
RSA_PRV_OTHER_PRIME_IDX + 1);
ASSERT_EQ(ret, BSL_SUCCESS);
ASSERT_EQ(fileLen, 0);
// version
if (version->len != 0) {
ASSERT_EQ_LOG("version compare tag", asnArr[RSA_PRV_VERSION_IDX].tag, BSL_ASN1_TAG_INTEGER);
ASSERT_COMPARE("version compare", version->x, version->len, asnArr[RSA_PRV_VERSION_IDX].buff,
asnArr[RSA_PRV_VERSION_IDX].len);
}
// n
ASSERT_EQ_LOG("n compare tag", asnArr[RSA_PRV_N_IDX].tag, BSL_ASN1_TAG_INTEGER);
ASSERT_COMPARE("n compare", n->x, n->len, asnArr[RSA_PRV_N_IDX].buff, asnArr[RSA_PRV_N_IDX].len);
// e
ASSERT_EQ_LOG("e compare tag", asnArr[RSA_PRV_E_IDX].tag, BSL_ASN1_TAG_INTEGER);
ASSERT_COMPARE("e compare", e->x, e->len, asnArr[RSA_PRV_E_IDX].buff, asnArr[RSA_PRV_E_IDX].len);
// d
ASSERT_EQ_LOG("d compare tag", asnArr[RSA_PRV_D_IDX].tag, BSL_ASN1_TAG_INTEGER);
ASSERT_COMPARE("d compare", d->x, d->len, asnArr[RSA_PRV_D_IDX].buff, asnArr[RSA_PRV_D_IDX].len);
// p
ASSERT_EQ_LOG("p compare tag", asnArr[RSA_PRV_P_IDX].tag, BSL_ASN1_TAG_INTEGER);
ASSERT_COMPARE("p compare", p->x, p->len, asnArr[RSA_PRV_P_IDX].buff, asnArr[RSA_PRV_P_IDX].len);
// q
ASSERT_EQ_LOG("q compare tag", asnArr[RSA_PRV_Q_IDX].tag, BSL_ASN1_TAG_INTEGER);
ASSERT_COMPARE("q compare", q->x, q->len, asnArr[RSA_PRV_Q_IDX].buff, asnArr[RSA_PRV_Q_IDX].len);
// d mod (p-1)
ASSERT_EQ_LOG("dp compare tag", asnArr[RSA_PRV_DP_IDX].tag, BSL_ASN1_TAG_INTEGER);
ASSERT_COMPARE("dp compare", dp->x, dp->len, asnArr[RSA_PRV_DP_IDX].buff, asnArr[RSA_PRV_DP_IDX].len);
// d mod (q-1)
ASSERT_EQ_LOG("dq compare tag", asnArr[RSA_PRV_DQ_IDX].tag, BSL_ASN1_TAG_INTEGER);
ASSERT_COMPARE("dq compare", dq->x, dq->len, asnArr[RSA_PRV_DQ_IDX].buff, asnArr[RSA_PRV_DQ_IDX].len);
// qinv
ASSERT_EQ_LOG("qinv compare tag", asnArr[RSA_PRV_QINV_IDX].tag, BSL_ASN1_TAG_INTEGER);
ASSERT_COMPARE("qinv compare", qinv->x, qinv->len, asnArr[RSA_PRV_QINV_IDX].buff, asnArr[RSA_PRV_QINV_IDX].len);
// create
CRYPT_EAL_PkeyPrv rsaPrv = {0};
rsaPrv.id = CRYPT_PKEY_RSA;
rsaPrv.key.rsaPrv.d = asnArr[RSA_PRV_D_IDX].buff;
rsaPrv.key.rsaPrv.dLen = asnArr[RSA_PRV_D_IDX].len;
rsaPrv.key.rsaPrv.n = asnArr[RSA_PRV_N_IDX].buff;
rsaPrv.key.rsaPrv.nLen = asnArr[RSA_PRV_N_IDX].len;
rsaPrv.key.rsaPrv.e = asnArr[RSA_PRV_E_IDX].buff;
rsaPrv.key.rsaPrv.eLen = asnArr[RSA_PRV_E_IDX].len;
rsaPrv.key.rsaPrv.p = asnArr[RSA_PRV_P_IDX].buff;
rsaPrv.key.rsaPrv.pLen = asnArr[RSA_PRV_P_IDX].len;
rsaPrv.key.rsaPrv.q = asnArr[RSA_PRV_Q_IDX].buff;
rsaPrv.key.rsaPrv.qLen = asnArr[RSA_PRV_Q_IDX].len;
rsaPrv.key.rsaPrv.dP = asnArr[RSA_PRV_DP_IDX].buff;
rsaPrv.key.rsaPrv.dPLen = asnArr[RSA_PRV_DP_IDX].len;
rsaPrv.key.rsaPrv.dQ = asnArr[RSA_PRV_DQ_IDX].buff;
rsaPrv.key.rsaPrv.dQLen = asnArr[RSA_PRV_DQ_IDX].len;
rsaPrv.key.rsaPrv.qInv = asnArr[RSA_PRV_QINV_IDX].buff;
rsaPrv.key.rsaPrv.qInvLen = asnArr[RSA_PRV_QINV_IDX].len;
CRYPT_EAL_PkeyCtx *pkeyCtx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_RSA);
ASSERT_TRUE(pkeyCtx != NULL);
int32_t pkcsv15 = mdId;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkeyCtx, &rsaPrv), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)), 0);
/* Malloc signature buffer */
uint32_t signLen = CRYPT_EAL_PkeyGetSignLen(pkeyCtx);
signdata = (uint8_t *)BSL_SAL_Malloc(signLen);
ASSERT_TRUE(signdata != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, mdId, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);
ASSERT_COMPARE("CRYPT_EAL_PkeySign Compare", sign->x, sign->len, signdata, signLen);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
BSL_SAL_FREE(signdata);
BSL_SAL_FREE(rawBuff);
BSL_GLOBAL_DeInit();
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_PUBKEY_FILE_TC001(char *path, int fileType, int mdId, Hex *msg, Hex *sign)
{
RegisterLogFunc();
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
ASSERT_EQ(CRYPT_EAL_DecodeFileKey(BSL_FORMAT_ASN1, fileType, path, NULL, 0, &pkeyCtx), CRYPT_SUCCESS);
if (fileType == CRYPT_PUBKEY_RSA) {
int32_t pkcsv15 = mdId;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)),
0);
}
/* verify signature */
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkeyCtx, mdId, msg->x, msg->len, sign->x, sign->len), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
BSL_GLOBAL_DeInit();
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_SUBPUBKEY_TC001(int encodeType, Hex *subKeyInfo)
{
RegisterLogFunc();
(void)encodeType;
CRYPT_EAL_PkeyCtx *pctx = NULL;
ASSERT_EQ(CRYPT_EAL_ParseAsn1SubPubkey(subKeyInfo->x, subKeyInfo->len, (void **)&pctx, false), 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pctx);
BSL_GLOBAL_DeInit();
}
/* END_CASE */
static int32_t DecodeKeyFile(int isProvider, const char *path, int format, const char *formatStr, int fileType,
const char *fileTypeStr, uint8_t *pwd, uint32_t pwdLen, CRYPT_EAL_PkeyCtx **pkeyCtx)
{
#ifdef HITLS_CRYPTO_PROVIDER
(void)format;
(void)fileType;
if (isProvider) {
BSL_Buffer pwdBuff = {pwd, pwdLen};
return CRYPT_EAL_ProviderDecodeFileKey(NULL, NULL, BSL_CID_UNKNOWN, formatStr, fileTypeStr, path,
&pwdBuff, pkeyCtx);
}
else
#endif
{
(void)isProvider;
(void)formatStr;
(void)fileTypeStr;
return CRYPT_EAL_DecodeFileKey(format, fileType, path, pwd, pwdLen, pkeyCtx);
}
}
static int32_t DecodeKeyBuff(int isProvider, BSL_Buffer *encode, int format, const char *formatStr, int fileType,
const char *fileTypeStr, uint8_t *pwd, uint32_t pwdLen, CRYPT_EAL_PkeyCtx **pkeyCtx)
{
#ifdef HITLS_CRYPTO_PROVIDER
(void)format;
(void)fileType;
if (isProvider) {
BSL_Buffer pwdBuff = {pwd, pwdLen};
return CRYPT_EAL_ProviderDecodeBuffKey(NULL, NULL, BSL_CID_UNKNOWN, formatStr, fileTypeStr, encode,
&pwdBuff, pkeyCtx);
} else
#endif
{
(void)isProvider;
(void)formatStr;
(void)fileTypeStr;
return CRYPT_EAL_DecodeBuffKey(format, fileType, encode, pwd, pwdLen, pkeyCtx);
}
}
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_PRIKEY_FILE_TC001(int isProvider, char *path, int fileType, char *fileTypeStr, int mdId,
Hex *msg, Hex *sign)
{
RegisterLogFunc();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
uint8_t *signdata = NULL;
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
ASSERT_EQ(DecodeKeyFile(isProvider, path, BSL_FORMAT_ASN1, "ASN1", fileType, fileTypeStr, NULL, 0, &pkeyCtx), 0);
if (fileType == CRYPT_PRIKEY_RSA || strcmp(fileTypeStr, "PRIKEY_RSA") == 0 ||
CRYPT_EAL_PkeyGetId(pkeyCtx) == CRYPT_PKEY_RSA) {
int32_t pkcsv15 = mdId;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)), 0);
}
/* Malloc signature buffer */
uint32_t signLen = CRYPT_EAL_PkeyGetSignLen(pkeyCtx);
signdata = (uint8_t *)BSL_SAL_Malloc(signLen);
ASSERT_TRUE(signdata != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, mdId, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);
if (sign->len != 0) {
ASSERT_COMPARE("Signature Compare", sign->x, sign->len, signdata, signLen);
}
EXIT:
BSL_SAL_Free(signdata);
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
BSL_GLOBAL_DeInit();
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_ECCPRIKEY_FILE_TC001(int isProvider, char *path, int fileType, char *fileTypeStr,
int mdId, Hex *msg, int alg, Hex *rawKey, int paraId)
{
RegisterLogFunc();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
uint8_t rawPriKey[100] = {0};
uint32_t rawPriKeyLen = 100;
uint8_t *signdata = NULL;
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
ASSERT_EQ(DecodeKeyFile(isProvider, path, BSL_FORMAT_ASN1, "ASN1", fileType, fileTypeStr, NULL, 0, &pkeyCtx), 0);
CRYPT_EAL_PkeyPrv pkeyPrv = {0};
pkeyPrv.id = alg;
pkeyPrv.key.eccPrv.data = rawPriKey;
pkeyPrv.key.eccPrv.len = rawPriKeyLen;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkeyCtx, &pkeyPrv), CRYPT_SUCCESS);
ASSERT_COMPARE("key cmp", rawKey->x, rawKey->len, rawPriKey, rawKey->len);
ASSERT_EQ(CRYPT_EAL_PkeyGetId(pkeyCtx), alg);
if (alg != CRYPT_PKEY_SM2) { // sm2 is null
ASSERT_EQ(CRYPT_EAL_PkeyGetParaId(pkeyCtx), paraId);
}
/* Malloc signature buffer */
uint32_t signLen = CRYPT_EAL_PkeyGetSignLen(pkeyCtx);
signdata = (uint8_t *)BSL_SAL_Malloc(signLen);
ASSERT_TRUE(signdata != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, mdId, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);
EXIT:
BSL_SAL_Free(signdata);
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
BSL_GLOBAL_DeInit();
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_ED25519PRIKEY_FILE_TC001(int alg, char *path, int format, int type, Hex *prv)
{
RegisterLogFunc();
uint8_t rawPriKey[32] = {0};
uint32_t rawPriKeyLen = 32;
CRYPT_EAL_PkeyPrv pkeyPrv = {0};
pkeyPrv.id = alg;
pkeyPrv.key.eccPrv.data = rawPriKey;
pkeyPrv.key.eccPrv.len = rawPriKeyLen;
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
ASSERT_EQ(CRYPT_EAL_DecodeFileKey(format, type, path, NULL, 0, &pkeyCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkeyCtx, &pkeyPrv), CRYPT_SUCCESS);
ASSERT_COMPARE("key cmp", prv->x, prv->len, pkeyPrv.key.eccPrv.data, pkeyPrv.key.eccPrv.len);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_ED25519PRIKEY_FILE_TC002(char *path, int format, int type, int ret)
{
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
ASSERT_EQ(CRYPT_EAL_DecodeFileKey(format, type, path, NULL, 0, &pkeyCtx), ret);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_ENCPK8_TC001(int isProvider, char *path, int fileType, char *fileTypeStr, Hex *pass,
int mdId, Hex *msg, Hex *sign)
{
RegisterLogFunc();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
uint8_t *signdata = NULL;
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
ASSERT_EQ(DecodeKeyFile(isProvider, path, BSL_FORMAT_ASN1, "ASN1", fileType, fileTypeStr,
pass->x, pass->len, &pkeyCtx), 0);
if (fileType == CRYPT_PRIKEY_RSA || CRYPT_EAL_PkeyGetId(pkeyCtx) == CRYPT_PKEY_RSA) {
int32_t pkcsv15 = mdId;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)),
0);
}
/* Malloc signature buffer */
uint32_t signLen = CRYPT_EAL_PkeyGetSignLen(pkeyCtx);
signdata = (uint8_t *)BSL_SAL_Malloc(signLen);
ASSERT_TRUE(signdata != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, mdId, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);
if (sign->len != 0) {
ASSERT_COMPARE("Signature Compare", sign->x, sign->len, signdata, signLen);
}
EXIT:
BSL_SAL_Free(signdata);
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
BSL_GLOBAL_DeInit();
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_BUFF_TC001(int isProvider, char *typeStr, int type, Hex *pass, Hex *data)
{
RegisterLogFunc();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
BSL_Buffer encode = {data->x, data->len};
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
int32_t ret;
#ifdef HITLS_CRYPTO_PROVIDER
ret = isProvider ? CRYPT_DECODE_ERR_NO_USABLE_DECODER : CRYPT_NULL_INPUT;
#else
ret = CRYPT_NULL_INPUT;
#endif
ASSERT_EQ(DecodeKeyBuff(isProvider, &encode, BSL_FORMAT_ASN1, "ASN1", type, typeStr, pass->x, pass->len, &pkeyCtx),
ret);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_PUBKEY_BUFF_TC001(char *path, int fileType, int isComplete, Hex *asn1)
{
RegisterLogFunc();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
BSL_Buffer encodeAsn1 = {0};
ASSERT_EQ(CRYPT_EAL_DecodeFileKey(BSL_FORMAT_UNKNOWN, fileType, path, NULL, 0, &pkeyCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_EncodePubKeyBuffInternal(pkeyCtx, BSL_FORMAT_ASN1,
fileType, isComplete, &encodeAsn1), CRYPT_SUCCESS);
ASSERT_COMPARE("asn1 compare.", encodeAsn1.data, encodeAsn1.dataLen, asn1->x, asn1->len);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
BSL_SAL_FREE(encodeAsn1.data);
BSL_GLOBAL_DeInit();
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_PEM_ENCODE_PUBKEY_BUFF_TC001(char *path, int fileType, int isComplete, char *pemPath)
{
RegisterLogFunc();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
BSL_Buffer encodePem = {0};
ASSERT_EQ(CRYPT_EAL_DecodeFileKey(BSL_FORMAT_UNKNOWN, fileType, path, NULL, 0, &pkeyCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_EncodePubKeyBuffInternal(pkeyCtx, BSL_FORMAT_PEM,
fileType, isComplete, &encodePem), CRYPT_SUCCESS);
uint8_t *pem = NULL;
uint32_t pemLen = 0;
ASSERT_EQ(BSL_SAL_ReadFile(pemPath, &pem, &pemLen), CRYPT_SUCCESS);
ASSERT_COMPARE("pem compare.", encodePem.data, encodePem.dataLen, pem, pemLen);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
BSL_SAL_FREE(encodePem.data);
BSL_SAL_FREE(pem);
BSL_GLOBAL_DeInit();
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_PRIKEY_BUFF_TC001(char *path, int fileType, Hex *asn1)
{
RegisterLogFunc();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
BSL_Buffer encodeAsn1 = {0};
ASSERT_EQ(CRYPT_EAL_DecodeFileKey(BSL_FORMAT_UNKNOWN, fileType, path, NULL, 0, &pkeyCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkeyCtx, NULL, BSL_FORMAT_ASN1, fileType, &encodeAsn1), CRYPT_SUCCESS);
ASSERT_COMPARE("asn1 compare.", encodeAsn1.data, encodeAsn1.dataLen, asn1->x, asn1->len);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
BSL_SAL_FREE(encodeAsn1.data);
BSL_GLOBAL_DeInit();
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_ENCRYPTED_PRIKEY_BUFF_TC001(char *path, int fileType, int hmacId, int symId, int saltLen,
Hex *pwd, int itCnt, Hex *asn1)
{
RegisterLogFunc();
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
BSL_Buffer encodeAsn1 = {0};
BSL_Buffer encodeAsn1Out = {0};
CRYPT_Pbkdf2Param param = {0};
param.pbesId = BSL_CID_PBES2;
param.pbkdfId = BSL_CID_PBKDF2;
param.hmacId = hmacId;
param.symId = symId;
param.pwd = pwd->x;
param.pwdLen = pwd->len;
param.saltLen = saltLen;
param.itCnt = itCnt;
CRYPT_EncodeParam paramEx = {CRYPT_DERIVE_PBKDF2, ¶m};
ASSERT_EQ(CRYPT_EAL_DecodeFileKey(BSL_FORMAT_UNKNOWN, fileType, path, pwd->x, pwd->len, &pkeyCtx), CRYPT_SUCCESS);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkeyCtx, ¶mEx, BSL_FORMAT_ASN1, fileType, &encodeAsn1), CRYPT_SUCCESS);
CRYPT_EAL_PkeyCtx *decodeCtx = NULL;
ASSERT_EQ(CRYPT_EAL_DecodeBuffKey(BSL_FORMAT_ASN1, fileType, &encodeAsn1, pwd->x, pwd->len, &decodeCtx),
CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(decodeCtx, NULL, BSL_FORMAT_ASN1, CRYPT_PRIKEY_PKCS8_UNENCRYPT, &encodeAsn1Out),
CRYPT_SUCCESS);
ASSERT_COMPARE("asn1 compare.", encodeAsn1Out.data, encodeAsn1Out.dataLen, asn1->x, asn1->len);
EXIT:
CRYPT_EAL_PkeyFreeCtx(decodeCtx);
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
BSL_SAL_FREE(encodeAsn1.data);
BSL_SAL_FREE(encodeAsn1Out.data);
BSL_GLOBAL_DeInit();
TestRandDeInit();
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_PRAPSSPRIKEY_BUFF_TC001(char *path, int fileType, int saltLen, int mdId, int mgfId, Hex *asn1)
{
RegisterLogFunc();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
BSL_Buffer encodeAsn1 = {0};
ASSERT_EQ(CRYPT_EAL_DecodeFileKey(BSL_FORMAT_UNKNOWN, fileType, path, NULL, 0, &pkeyCtx), CRYPT_SUCCESS);
BSL_Param pssParam[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mgfId, sizeof(mgfId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &saltLen, sizeof(saltLen), 0},
BSL_PARAM_END};
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PSS, pssParam, 0),
CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkeyCtx, NULL, BSL_FORMAT_ASN1, fileType, &encodeAsn1), CRYPT_SUCCESS);
ASSERT_COMPARE("asn1 compare.", encodeAsn1.data, encodeAsn1.dataLen, asn1->x, asn1->len);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
BSL_SAL_FREE(encodeAsn1.data);
BSL_GLOBAL_DeInit();
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_AND_DECODE_RSAPSS_PUBLICKEY_TC001(int keyLen, int saltLen)
{
TestMemInit();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
RegisterLogFunc();
uint8_t e[] = {1, 0, 1}; // RSA public exponent
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyCtx *decodedPkey = NULL;
int32_t mdId = CRYPT_MD_SHA256;
BSL_Buffer encode = {0};
// set rsa para
para.id = CRYPT_PKEY_RSA;
para.para.rsaPara.e = e;
para.para.rsaPara.eLen = 3; // public exponent length = 3
para.para.rsaPara.bits = keyLen;
// pss param
BSL_Param pssParam[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &saltLen, sizeof(saltLen), 0},
BSL_PARAM_END};
// create new pkey ctx
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_RSA);
ASSERT_TRUE(pkey != NULL);
// set para and generate key pair
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_SUCCESS);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PSS, pssParam, 0), CRYPT_SUCCESS);
// encode key
ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkey, NULL, BSL_FORMAT_ASN1, CRYPT_PUBKEY_SUBKEY, &encode),
CRYPT_SUCCESS);
// decode key
ASSERT_EQ(CRYPT_EAL_DecodeBuffKey(BSL_FORMAT_ASN1, CRYPT_PUBKEY_SUBKEY, &encode, NULL, 0, &decodedPkey),
CRYPT_SUCCESS);
ASSERT_TRUE(decodedPkey != NULL);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(decodedPkey);
BSL_SAL_FREE(encode.data);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_RSAPSS_PUBLICKEY_BUFF_TC002(char *path, Hex *asn1)
{
RegisterLogFunc();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
BSL_Buffer encodeAsn1 = {0};
ASSERT_EQ(CRYPT_EAL_DecodeFileKey(BSL_FORMAT_UNKNOWN, CRYPT_PUBKEY_SUBKEY, path, NULL, 0, &pkeyCtx),
CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkeyCtx, NULL, BSL_FORMAT_ASN1, CRYPT_PUBKEY_SUBKEY, &encodeAsn1), CRYPT_SUCCESS);
ASSERT_COMPARE("asn1 compare.", encodeAsn1.data, encodeAsn1.dataLen, asn1->x, asn1->len);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
BSL_SAL_FREE(encodeAsn1.data);
BSL_GLOBAL_DeInit();
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_ECCPRIKEY_FAIL_TC001(Hex *asn1)
{
RegisterLogFunc();
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
uint8_t *buff = (uint8_t *)BSL_SAL_Calloc(asn1->len + 1, 1);
ASSERT_TRUE(buff != NULL);
(void)memcpy_s(buff, asn1->len, asn1->x, asn1->len);
BSL_Buffer encode = {buff, asn1->len};
ASSERT_EQ(CRYPT_EAL_DecodeBuffKey(BSL_FORMAT_UNKNOWN, CRYPT_PRIKEY_ECC, &encode, NULL, 0, &pkeyCtx),
CRYPT_DECODE_ASN1_BUFF_FAILED);
EXIT:
BSL_SAL_FREE(buff);
BSL_GLOBAL_DeInit();
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_BUFF_PROVIDER_TC001(char *formatStr, char *typeStr, char *path, Hex *password)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)formatStr;
(void)typeStr;
(void)path;
(void)password;
SKIP_TEST();
#else
RegisterLogFunc();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
uint8_t *data = NULL;
uint32_t dataLen = 0;
ASSERT_EQ(BSL_SAL_ReadFile(path, &data, &dataLen), BSL_SUCCESS);
BSL_Buffer encode = {data, dataLen};
BSL_Buffer pass = {password->x, password->len};
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
ASSERT_EQ(CRYPT_EAL_ProviderDecodeBuffKey(NULL, NULL, BSL_CID_UNKNOWN, NULL, NULL, &encode,
&pass, &pkeyCtx), CRYPT_SUCCESS);
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
pkeyCtx = NULL;
encode.data = data;
encode.dataLen = dataLen;
ASSERT_EQ(CRYPT_EAL_ProviderDecodeBuffKey(NULL, NULL, BSL_CID_UNKNOWN, formatStr, typeStr, &encode, &pass,
&pkeyCtx), 0);
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
pkeyCtx = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
/* default provider not loading */
CRYPT_EAL_Cleanup(9); // 9 denotes to deinit CRYPT_EAL_INIT_CPU and CRYPT_EAL_INIT_PROVIDER
encode.data = data;
encode.dataLen = dataLen;
ASSERT_EQ(CRYPT_EAL_ProviderDecodeBuffKey(NULL, NULL, BSL_CID_UNKNOWN, NULL, NULL, &encode,
&pass, &pkeyCtx), CRYPT_PROVIDER_INVALID_LIB_CTX);
encode.data = data;
encode.dataLen = dataLen;
ASSERT_NE(CRYPT_EAL_ProviderDecodeBuffKey(NULL, NULL, BSL_CID_UNKNOWN, formatStr, typeStr, &encode, &pass,
&pkeyCtx), 0);
CRYPT_EAL_Init(9); // 9 denotes to deinit CRYPT_EAL_INIT_CPU and CRYPT_EAL_INIT_PROVIDER
encode.data = data;
encode.dataLen = dataLen;
ASSERT_EQ(CRYPT_EAL_ProviderDecodeBuffKey(NULL, NULL, BSL_CID_UNKNOWN, formatStr, typeStr, &encode, &pass,
&pkeyCtx), CRYPT_SUCCESS);
#endif
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
BSL_SAL_FREE(data);
BSL_GLOBAL_DeInit();
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_ASN1_PARSE_BUFF_PROVIDER_TC002
* title 1. Test the decode provider and key provider are not same
* 2. Test the JSON2Key
*
*/
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_BUFF_PROVIDER_TC002(char *providerPath, char *providerName, int cmd, char *attrName,
char *formatStr, char *typeStr, char *path)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)providerPath;
(void)providerName;
(void)cmd;
(void)attrName;
(void)formatStr;
(void)typeStr;
(void)path;
SKIP_TEST();
#else
RegisterLogFunc();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
CRYPT_EAL_LibCtx *libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, providerPath), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, BSL_SAL_LIB_FMT_OFF, "default", NULL, NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, providerName, NULL, NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderDecodeFileKey(libCtx, attrName, BSL_CID_UNKNOWN, formatStr, typeStr, path,
NULL, &pkeyCtx), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
CRYPT_EAL_LibCtxFree(libCtx);
BSL_GLOBAL_DeInit();
#endif
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/encode/test_suite_sdv_asn1_certkey.c | C | unknown | 31,665 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "crypt_encode_decode_key.h"
#include "crypt_encode_internal.h"
#include "crypt_sm2.h"
#include "crypt_bn.h"
#include "crypt_errno.h"
#define MAX_ENCODE_LEN 1024
#define SM2_POINT_COORDINATE_LEN 65
#define SM2_POINT_SINGLE_COORDINATE_LEN 32
#define SM3_MD_SIZE 32
#define MAX_BN_BITS 2048
#define BITS_IN_A_BYTE 8
/* END_HEADER */
/**
* @test SDV_ENCODE_SIGN_BN_FUNC_TC001
* @title Test CRYPT_EAL_EncodeSign normal encode function
*/
/* BEGIN_CASE */
void SDV_ENCODE_SIGN_BN_FUNC_TC001(Hex *r, Hex *s, Hex *expect)
{
uint8_t encode[MAX_ENCODE_LEN] = {0};
uint32_t encodeLen = sizeof(encode);
BN_BigNum *bnR = NULL;
BN_BigNum *bnS = NULL;
ASSERT_TRUE((bnR = BN_Create(MAX_BN_BITS)) != NULL);
ASSERT_TRUE((bnS = BN_Create(MAX_BN_BITS)) != NULL);
ASSERT_TRUE(r->len * BITS_IN_A_BYTE <= MAX_BN_BITS);
ASSERT_TRUE(s->len * BITS_IN_A_BYTE <= MAX_BN_BITS);
ASSERT_EQ(BN_Bin2Bn(bnR, r->x, r->len), CRYPT_SUCCESS);
ASSERT_EQ(BN_SetSign(bnR, false), CRYPT_SUCCESS);
ASSERT_EQ(BN_Bin2Bn(bnS, s->x, s->len), CRYPT_SUCCESS);
ASSERT_EQ(BN_SetSign(bnS, false), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, bnS, encode, &encodeLen), CRYPT_SUCCESS);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_TRUE(memcmp(encode, expect->x, expect->len) == 0);
EXIT:
BN_Destroy(bnR);
BN_Destroy(bnS);
}
/* END_CASE */
/**
* @test SDV_ENCODE_SIGN_BN_API_TC001
* @title Test CRYPT_EAL_EncodeSign abnormal input parameter
*/
/* BEGIN_CASE */
void SDV_ENCODE_SIGN_BN_API_TC001(Hex *r, Hex *s)
{
uint8_t encode[MAX_ENCODE_LEN] = {0};
uint32_t encodeLen = sizeof(encode);
BN_BigNum *bnR = NULL;
BN_BigNum *bnS = NULL;
ASSERT_TRUE((bnR = BN_Create(MAX_BN_BITS)) != NULL);
ASSERT_TRUE((bnS = BN_Create(MAX_BN_BITS)) != NULL);
// Test big number is zero
ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, bnS, encode, &encodeLen), CRYPT_INVALID_ARG);
ASSERT_TRUE(BN_Bin2Bn(bnR, r->x, r->len) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, bnS, encode, &encodeLen), CRYPT_INVALID_ARG);
ASSERT_TRUE(BN_Bin2Bn(bnS, s->x, s->len) == CRYPT_SUCCESS);
// Test null pointer
ASSERT_EQ(CRYPT_EAL_EncodeSign(NULL, bnS, encode, &encodeLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, NULL, encode, &encodeLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, bnS, NULL, &encodeLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, bnS, encode, NULL), CRYPT_NULL_INPUT);
// Test big number is negative
ASSERT_EQ(BN_SetSign(bnR, true), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, bnS, encode, &encodeLen), CRYPT_INVALID_ARG);
ASSERT_EQ(BN_SetSign(bnR, false), CRYPT_SUCCESS);
ASSERT_EQ(BN_SetSign(bnS, true), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, bnS, encode, &encodeLen), CRYPT_INVALID_ARG);
ASSERT_EQ(BN_SetSign(bnS, false), CRYPT_SUCCESS);
// Test buffer length is not enough
encodeLen = 1;
ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, bnS, encode, &encodeLen), CRYPT_ENCODE_BUFF_NOT_ENOUGH);
EXIT:
BN_Destroy(bnR);
BN_Destroy(bnS);
}
/* END_CASE */
/**
* @test SDV_DECODE_SIGN_BN_FUNC_TC001
* @title Test CRYPT_EAL_DecodeSign normal decode function
*/
/* BEGIN_CASE */
void SDV_DECODE_SIGN_BN_FUNC_TC001(Hex *encode, Hex *expectR, Hex *expectS, int ret)
{
BN_BigNum *bnR = NULL;
BN_BigNum *bnS = NULL;
uint8_t rBuf[MAX_ENCODE_LEN] = {0};
uint8_t sBuf[MAX_ENCODE_LEN] = {0};
uint32_t rLen = sizeof(rBuf);
uint32_t sLen = sizeof(sBuf);
ASSERT_TRUE((bnR = BN_Create(MAX_BN_BITS)) != NULL);
ASSERT_TRUE((bnS = BN_Create(MAX_BN_BITS)) != NULL);
ASSERT_EQ(CRYPT_EAL_DecodeSign(encode->x, encode->len, bnR, bnS), ret);
if (ret == CRYPT_SUCCESS) {
ASSERT_TRUE(!BN_IsNegative(bnR));
ASSERT_TRUE(!BN_IsNegative(bnS));
ASSERT_EQ(BN_Bn2Bin(bnR, rBuf, &rLen), CRYPT_SUCCESS);
ASSERT_EQ(BN_Bn2Bin(bnS, sBuf, &sLen), CRYPT_SUCCESS);
ASSERT_EQ(rLen, expectR->len);
ASSERT_EQ(sLen, expectS->len);
ASSERT_TRUE(memcmp(rBuf, expectR->x, rLen) == 0);
ASSERT_TRUE(memcmp(sBuf, expectS->x, sLen) == 0);
}
EXIT:
BN_Destroy(bnR);
BN_Destroy(bnS);
}
/* END_CASE */
/**
* @test SDV_DECODE_SIGN_BN_API_TC001
* @title Test CRYPT_EAL_DecodeSign abnormal input parameter
*/
/* BEGIN_CASE */
void SDV_DECODE_SIGN_BN_API_TC001(Hex *encode)
{
BN_BigNum *bnR = NULL;
BN_BigNum *bnS = NULL;
ASSERT_TRUE((bnR = BN_Create(MAX_BN_BITS)) != NULL);
ASSERT_TRUE((bnS = BN_Create(MAX_BN_BITS)) != NULL);
// Test null pointer
ASSERT_EQ(CRYPT_EAL_DecodeSign(NULL, encode->len, bnR, bnS), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_DecodeSign(encode->x, 0, bnR, bnS), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_DecodeSign(encode->x, encode->len, NULL, bnS), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_DecodeSign(encode->x, encode->len, bnR, NULL), CRYPT_NULL_INPUT);
EXIT:
BN_Destroy(bnR);
BN_Destroy(bnS);
}
/* END_CASE */
/**
* @test SDV_ENCODE_SM2_ENCRYPT_DATA_FUNC_TC001
* @title Test CRYPT_EAL_EncodeSm2EncryptData normal encode function
*/
/* BEGIN_CASE */
void SDV_ENCODE_SM2_ENCRYPT_DATA_FUNC_TC001(Hex *x, Hex *y, Hex *hash, Hex *cipher, Hex *expect, int ret)
{
uint8_t encode[MAX_ENCODE_LEN] = {0};
uint32_t encodeLen = sizeof(encode);
CRYPT_SM2_EncryptData data = {
.x = x->x, .xLen = x->len,
.y = y->x, .yLen = y->len,
.hash = hash->x, .hashLen = hash->len,
.cipher = cipher->x, .cipherLen = cipher->len
};
ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), ret);
if (ret == CRYPT_SUCCESS) {
ASSERT_EQ(encodeLen, expect->len);
ASSERT_TRUE(memcmp(encode, expect->x, expect->len) == 0);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_ENCODE_SM2_ENCRYPT_DATA_API_TC001
* @title Test CRYPT_EAL_EncodeSm2EncryptData abnormal input parameter
*/
/* BEGIN_CASE */
void SDV_ENCODE_SM2_ENCRYPT_DATA_API_TC001(Hex *x, Hex *y, Hex *hash, Hex *cipher)
{
uint8_t encode[MAX_ENCODE_LEN] = {0};
uint32_t encodeLen = sizeof(encode);
CRYPT_SM2_EncryptData data = {
.x = x->x, .xLen = x->len,
.y = y->x, .yLen = y->len,
.hash = hash->x, .hashLen = hash->len,
.cipher = cipher->x, .cipherLen = cipher->len
};
// Test null pointer
ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(NULL, encode, &encodeLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, NULL, &encodeLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, NULL), CRYPT_NULL_INPUT);
// Test invalid x
data.x = NULL;
ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), CRYPT_INVALID_ARG);
data.x = x->x;
data.xLen = 0;
ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), CRYPT_INVALID_ARG);
data.xLen = x->len;
// Test invalid y
data.y = NULL;
ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), CRYPT_INVALID_ARG);
data.y = y->x;
data.yLen = 0;
ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), CRYPT_INVALID_ARG);
data.yLen = y->len;
// Test invalid hash
data.hash = NULL;
ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), CRYPT_INVALID_ARG);
data.hash = hash->x;
data.hashLen = 0;
ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), CRYPT_INVALID_ARG);
data.hashLen = hash->len;
// Test invalid cipher
data.cipher = NULL;
ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), CRYPT_INVALID_ARG);
data.cipher = cipher->x;
data.cipherLen = 0;
ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), CRYPT_INVALID_ARG);
data.cipherLen = cipher->len;
// Test buffer length is not enough
data.xLen = x->len;
encodeLen = 1;
ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), CRYPT_ENCODE_BUFF_NOT_ENOUGH);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_DECODE_SM2_ENCRYPT_DATA_FUNC_TC001
* @title Test CRYPT_EAL_DecodeSm2EncryptData normal decode function
*/
/* BEGIN_CASE */
void SDV_DECODE_SM2_ENCRYPT_DATA_FUNC_TC001(Hex *encode, Hex *expectX, Hex *expectY, Hex *expectHash, Hex *expectCipher,
int ret)
{
uint8_t decode[MAX_ENCODE_LEN] = {0};
CRYPT_SM2_EncryptData data = {
.x = decode,
.xLen = SM2_POINT_SINGLE_COORDINATE_LEN,
.y = decode + SM2_POINT_SINGLE_COORDINATE_LEN,
.yLen = SM2_POINT_SINGLE_COORDINATE_LEN,
.hash = decode + SM2_POINT_COORDINATE_LEN,
.hashLen = SM3_MD_SIZE,
.cipher = decode + SM2_POINT_COORDINATE_LEN + SM3_MD_SIZE,
.cipherLen = sizeof(decode) - SM2_POINT_COORDINATE_LEN - SM3_MD_SIZE
};
ASSERT_EQ(CRYPT_EAL_DecodeSm2EncryptData(encode->x, encode->len, &data), ret);
if (ret == CRYPT_SUCCESS) {
ASSERT_EQ(data.hashLen, expectHash->len);
ASSERT_EQ(data.cipherLen, expectCipher->len);
ASSERT_TRUE(memcmp(data.x + (data.xLen - expectX->len), expectX->x, expectX->len) == 0);
ASSERT_TRUE(memcmp(data.y + (data.yLen - expectY->len), expectY->x, expectY->len) == 0);
ASSERT_TRUE(memcmp(data.hash, expectHash->x, data.hashLen) == 0);
ASSERT_TRUE(memcmp(data.cipher, expectCipher->x, data.cipherLen) == 0);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_DECODE_SM2_ENCRYPT_DATA_API_TC001
* @title Test CRYPT_EAL_DecodeSm2EncryptData abnormal input parameter
*/
/* BEGIN_CASE */
void SDV_DECODE_SM2_ENCRYPT_DATA_API_TC001(Hex *encode)
{
uint8_t x;
uint8_t y;
uint8_t hash;
uint8_t cipher;
CRYPT_SM2_EncryptData data = {
.x = &x, .xLen = 1,
.y = &y, .yLen = 1,
.hash = &hash, .hashLen = 1,
.cipher = &cipher, .cipherLen = 1
};
// Test null pointer
ASSERT_EQ(CRYPT_EAL_DecodeSm2EncryptData(NULL, encode->len, &data), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_DecodeSm2EncryptData(encode->x, encode->len, NULL), CRYPT_NULL_INPUT);
// Test invlaid data
data.x = NULL;
ASSERT_EQ(CRYPT_EAL_DecodeSm2EncryptData(encode->x, encode->len, &data), CRYPT_INVALID_ARG);
data.x = &x;
data.xLen = 0;
ASSERT_EQ(CRYPT_EAL_DecodeSm2EncryptData(encode->x, encode->len, &data), CRYPT_INVALID_ARG);
data.xLen = 1;
// Test buffer length is not enough
ASSERT_EQ(CRYPT_EAL_DecodeSm2EncryptData(encode->x, encode->len, &data), CRYPT_DECODE_BUFF_NOT_ENOUGH);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_ENCODE_GET_SIGN_LEN_API_TC001
* @title Test CRYPT_EAL_GetSignEncodeLen
*/
/* BEGIN_CASE */
void SDV_ENCODE_GET_SIGN_LEN_API_TC001(void)
{
uint32_t maxLen = 0;
// Normal case test
ASSERT_EQ(CRYPT_SUCCESS, CRYPT_EAL_GetSignEncodeLen(32, 32, &maxLen));
ASSERT_EQ(72, maxLen); // (32 + 1(leading 0x00) + 1(len) + 1(tag)) * 2(r,s) + 1(tag) + 1(len) = 72
// Invalid parameter test
ASSERT_EQ(CRYPT_EAL_GetSignEncodeLen(0, 32, &maxLen), CRYPT_INVALID_ARG);
ASSERT_EQ(CRYPT_EAL_GetSignEncodeLen(32, 0, &maxLen), CRYPT_INVALID_ARG);
ASSERT_EQ(CRYPT_EAL_GetSignEncodeLen(32, 32, NULL), CRYPT_INVALID_ARG);
// Overflow test
ASSERT_EQ(CRYPT_EAL_GetSignEncodeLen(UINT32_MAX, 32, &maxLen), CRYPT_INVALID_ARG);
ASSERT_EQ(CRYPT_EAL_GetSignEncodeLen(32, UINT32_MAX, &maxLen), CRYPT_INVALID_ARG);
ASSERT_EQ(CRYPT_EAL_GetSignEncodeLen(UINT32_MAX - 1, 32, &maxLen), BSL_ASN1_ERR_LEN_OVERFLOW);
ASSERT_EQ(CRYPT_EAL_GetSignEncodeLen(32, UINT32_MAX - 1, &maxLen), BSL_ASN1_ERR_LEN_OVERFLOW);
// 1(tag) + 1(len) + 1(integer)
// Indefinite form: 1(tag) + 1 + 1(lenNum) + 1(len)
ASSERT_EQ(CRYPT_EAL_GetSignEncodeLen(1, UINT32_MAX - (1 + 1 + 1) - (1 + 1 + 4), &maxLen),
CRYPT_ENCODE_ERR_SIGN_LEN_OVERFLOW);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_ENCODE_GET_SM2_ENC_LEN_API_TC001
* @title Test CRYPT_EAL_GetSm2EncryptDataEncodeLen
*/
/* BEGIN_CASE */
void SDV_ENCODE_GET_SM2_ENC_LEN_API_TC001(void)
{
uint32_t encodeLen = 0;
// Normal case test
ASSERT_EQ(CRYPT_EAL_GetSm2EncryptDataEncodeLen(32, 32, 32, 64, &encodeLen), CRYPT_SUCCESS);
ASSERT_EQ(encodeLen, 173); // (32 + 1 + 1 + 1) * 2 + (32+1+1) + (64+1+1) + 2(length > 127) + 1 = 173
// Minimum valid input test
ASSERT_EQ(CRYPT_EAL_GetSm2EncryptDataEncodeLen(1, 1, 1, 1, &encodeLen), CRYPT_SUCCESS);
ASSERT_EQ(encodeLen, 16); // (1 + 1 + 1 + 1) * 2 + (1+1+1) + (1+1+1) + 1 + 1 = 16
// Invalid parameter test
ASSERT_EQ(CRYPT_INVALID_ARG, CRYPT_EAL_GetSm2EncryptDataEncodeLen(32, 32, 32, 32, NULL));
// Overflow test
ASSERT_EQ(CRYPT_EAL_GetSm2EncryptDataEncodeLen(UINT32_MAX - 1, UINT32_MAX - 1, 32, 32, &encodeLen),
BSL_ASN1_ERR_LEN_OVERFLOW);
ASSERT_EQ(CRYPT_EAL_GetSm2EncryptDataEncodeLen(1000, 1000, UINT32_MAX - 2000, 32, &encodeLen),
CRYPT_ENCODE_ERR_SM2_ENCRYPT_DATA_LEN_OVERFLOW);
ASSERT_EQ(CRYPT_EAL_GetSm2EncryptDataEncodeLen(1000, 1000, 1000, UINT32_MAX - 3000, &encodeLen),
CRYPT_ENCODE_ERR_SM2_ENCRYPT_DATA_LEN_OVERFLOW);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_ENCODE_DECODE_SIGN_COMBO_TC001
* @title Test combined encode and decode for signature
*/
/* BEGIN_CASE */
void SDV_ENCODE_DECODE_SIGN_COMBO_TC001(Hex *r, Hex *s)
{
uint32_t maxLen = 0;
uint8_t *encode = NULL;
BN_BigNum *bnR = NULL;
BN_BigNum *bnS = NULL;
BN_BigNum *decR = NULL;
BN_BigNum *decS = NULL;
uint8_t rBuf[MAX_ENCODE_LEN] = {0};
uint8_t sBuf[MAX_ENCODE_LEN] = {0};
uint32_t rLen = sizeof(rBuf);
uint32_t sLen = sizeof(sBuf);
// Create big numbers
ASSERT_TRUE((bnR = BN_Create(MAX_BN_BITS)) != NULL);
ASSERT_TRUE((bnS = BN_Create(MAX_BN_BITS)) != NULL);
ASSERT_TRUE((decR = BN_Create(MAX_BN_BITS)) != NULL);
ASSERT_TRUE((decS = BN_Create(MAX_BN_BITS)) != NULL);
// Convert input hex to big numbers
ASSERT_TRUE(r->len * BITS_IN_A_BYTE <= MAX_BN_BITS);
ASSERT_TRUE(s->len * BITS_IN_A_BYTE <= MAX_BN_BITS);
ASSERT_EQ(BN_Bin2Bn(bnR, r->x, r->len), CRYPT_SUCCESS);
ASSERT_EQ(BN_SetSign(bnR, false), CRYPT_SUCCESS);
ASSERT_EQ(BN_Bin2Bn(bnS, s->x, s->len), CRYPT_SUCCESS);
ASSERT_EQ(BN_SetSign(bnS, false), CRYPT_SUCCESS);
// Get encode length and allocate buffer
ASSERT_EQ(CRYPT_EAL_GetSignEncodeLen(r->len, s->len, &maxLen), CRYPT_SUCCESS);
ASSERT_TRUE((encode = (uint8_t *)BSL_SAL_Malloc(maxLen)) != NULL);
// Encode signature
uint32_t encodeLen = maxLen;
ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, bnS, encode, &encodeLen), CRYPT_SUCCESS);
// Decode signature
ASSERT_EQ(CRYPT_EAL_DecodeSign(encode, encodeLen, decR, decS), CRYPT_SUCCESS);
// Convert decoded big numbers back to binary and compare
ASSERT_EQ(BN_Bn2Bin(decR, rBuf, &rLen), CRYPT_SUCCESS);
ASSERT_EQ(BN_Bn2Bin(decS, sBuf, &sLen), CRYPT_SUCCESS);
ASSERT_COMPARE("Compare r", rBuf, rLen, r->x, r->len);
ASSERT_COMPARE("Compare s", sBuf, sLen, s->x, s->len);
EXIT:
BSL_SAL_Free(encode);
BN_Destroy(bnR);
BN_Destroy(bnS);
BN_Destroy(decR);
BN_Destroy(decS);
}
/* END_CASE */
/**
* @test SDV_ENCODE_DECODE_SM2_ENCRYPT_COMBO_TC001
* @title Test combined encode and decode for SM2 encryption data
*/
/* BEGIN_CASE */
void SDV_ENCODE_DECODE_SM2_ENCRYPT_COMBO_TC001(Hex *x, Hex *y, Hex *hash, Hex *cipher)
{
uint32_t maxLen = 0;
uint8_t *encode = NULL;
uint8_t decBuf[MAX_ENCODE_LEN] = {0};
// Original data
CRYPT_SM2_EncryptData data = {
.x = x->x, .xLen = x->len,
.y = y->x, .yLen = y->len,
.hash = hash->x, .hashLen = hash->len,
.cipher = cipher->x, .cipherLen = cipher->len
};
// Prepare decode buffer
decBuf[0] = 0x04;
CRYPT_SM2_EncryptData decData = {
.x = decBuf + 1, .xLen = SM2_POINT_SINGLE_COORDINATE_LEN,
.y = decBuf + 1 + SM2_POINT_SINGLE_COORDINATE_LEN, .yLen = SM2_POINT_SINGLE_COORDINATE_LEN,
.hash = decBuf + SM2_POINT_COORDINATE_LEN, .hashLen = SM3_MD_SIZE,
.cipher = decBuf + SM2_POINT_COORDINATE_LEN + hash->len, .cipherLen = sizeof(decBuf) - SM3_MD_SIZE - SM2_POINT_COORDINATE_LEN
};
// Get encode length and allocate buffer
ASSERT_EQ(CRYPT_EAL_GetSm2EncryptDataEncodeLen(x->len, y->len, hash->len, cipher->len, &maxLen), CRYPT_SUCCESS);
ASSERT_TRUE((encode = (uint8_t *)BSL_SAL_Malloc(maxLen)) != NULL);
// Encode SM2 encryption data
uint32_t encodeLen = maxLen;
ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), CRYPT_SUCCESS);
// Decode SM2 encryption data
ASSERT_EQ(CRYPT_EAL_DecodeSm2EncryptData(encode, encodeLen, &decData), CRYPT_SUCCESS);
// Compare decoded data with original data
ASSERT_COMPARE("Compare x", decData.x + (decData.xLen - x->len), x->len, x->x, x->len);
ASSERT_COMPARE("Compare y", decData.y + (decData.yLen - y->len), y->len, y->x, y->len);
ASSERT_COMPARE("Compare hash", decData.hash, decData.hashLen, hash->x, hash->len);
ASSERT_COMPARE("Compare cipher", decData.cipher, decData.cipherLen, cipher->x, cipher->len);
EXIT:
BSL_SAL_Free(encode);
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/encode/test_suite_sdv_encode.c | C | unknown | 18,110 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "crypt_entropy.h"
#include "crypt_eal_rand.h"
#include "eal_entropy.h"
#include "securec.h"
#include "crypt_eal_entropy.h"
#include "crypt_algid.h"
#ifdef HITLS_CRYPTO_ENTROPY_SYS
static bool IsCollectionEntropy(void *ctx)
{
bool isWork = false;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(ctx, CRYPT_ENTROPY_GET_STATE, &isWork, 1) == CRYPT_SUCCESS);
uint32_t poolSize = 0;
uint32_t currSize = 0;
uint32_t cfSize = 0;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(ctx, CRYPT_ENTROPY_GET_POOL_SIZE, &poolSize, 4) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(ctx, CRYPT_ENTROPY_POOL_GET_CURRSIZE, &currSize, 4) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(ctx, CRYPT_ENTROPY_GET_CF_SIZE, &cfSize, 4) == CRYPT_SUCCESS);
return isWork && (cfSize <= poolSize - currSize);
EXIT:
return false;
}
static void *EsGatherAuto(void *ctx)
{
while(true) {
if (!IsCollectionEntropy(ctx)) {
break;
}
ASSERT_TRUE(CRYPT_EAL_EsCtrl(ctx, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
uint32_t size;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(ctx, CRYPT_ENTROPY_POOL_GET_CURRSIZE, (void *)&size, sizeof(uint32_t)) == CRYPT_SUCCESS);
usleep(1000);
}
EXIT:
return NULL;
}
static void *EsGetAuto(void *ctx)
{
uint8_t buf[48] = {0};
for (int32_t iter = 0; iter < 3; iter++) {
uint32_t len = CRYPT_EAL_EsEntropyGet(ctx, buf, 48);
ASSERT_TRUE(len > 0);
}
EXIT:
return NULL;
}
static const char *EsGetCfMode(uint32_t algId)
{
switch (algId) {
case CRYPT_MD_SM3:
return "sm3_df";
case CRYPT_MD_SHA224:
return "sha224_df";
case CRYPT_MD_SHA256:
return "sha256_df";
case CRYPT_MD_SHA384:
return "sha384_df";
case CRYPT_MD_SHA512:
return "sha512_df";
default:
return NULL;
}
}
static uint32_t EsGetCfLen(uint32_t algId)
{
switch (algId) {
case CRYPT_MD_SM3:
return 32u;
case CRYPT_MD_SHA224:
return 28u;
case CRYPT_MD_SHA256:
return 32u;
case CRYPT_MD_SHA384:
return 48u;
case CRYPT_MD_SHA512:
return 64u;
default:
return 0u;
}
}
static int32_t EntropyReadNormal(void *ctx, uint32_t timeout, uint8_t *buf, uint32_t bufLen)
{
(void)ctx;
(void)timeout;
memset_s(buf, bufLen, 0xff, bufLen);
return CRYPT_SUCCESS;
}
static void *EntropyInitTest(void *para)
{
(void)para;
return EntropyInitTest;
}
static void *EntropyInitError(void *para)
{
(void)para;
return NULL;
}
static int32_t EntropyReadError(void *ctx, uint32_t timeout, uint8_t *buf, uint32_t bufLen)
{
(void)ctx;
(void)timeout;
memset_s(buf, bufLen, 0xff, bufLen);
return -1;
}
static int32_t EntropyReadDiffData(void *ctx, uint32_t timeout, uint8_t *buf, uint32_t bufLen)
{
(void)ctx;
(void)timeout;
for (uint32_t iter = 0; iter < bufLen; iter++) {
buf[iter] = iter % 128;
}
return CRYPT_SUCCESS;
}
static void EntropyDeinitTest(void *ctx)
{
(void)ctx;
return;
}
static void *EsMutiAuto(void *ctx)
{
CRYPT_EAL_NsPara para = {
"aaa",
false,
7,
{
NULL,
NULL,
EntropyReadNormal,
NULL,
},
{5, 39, 512},
};
CRYPT_EAL_EsCtrl(ctx, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)"sha256_df", strlen("sha256_df"));
CRYPT_EAL_EsCtrl(ctx, CRYPT_ENTROPY_ADD_NS, (void *)¶, sizeof(CRYPT_EAL_NsPara));
uint32_t size = 512;
CRYPT_EAL_EsCtrl(ctx, CRYPT_ENTROPY_SET_POOL_SIZE, (void *)&size, sizeof(uint32_t));
ASSERT_TRUE(CRYPT_EAL_EsInit(ctx) == CRYPT_SUCCESS);
uint8_t buf[48] = {0};
for (int32_t iter = 0; iter < 3; iter++) {
uint32_t len = CRYPT_EAL_EsEntropyGet(ctx, buf, 48);
ASSERT_TRUE(len > 0);
}
EXIT:
return NULL;
}
static void EntropyESMutilTest(void *alg)
{
uint32_t poolSize = 4096;
uint32_t expectGetLen = 32;
uint8_t buf[1024] = {0};
uint32_t currPoolSize = 0;
CRYPT_EAL_Es *es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
const char *mode = EsGetCfMode((uint32_t)(*(int *)alg));
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)mode, strlen(mode)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_POOL_SIZE, (void *)&poolSize, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);
for(int iter = 0; iter < 1; iter++) {
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
}
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_POOL_GET_CURRSIZE, &currPoolSize, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(currPoolSize > expectGetLen);
uint32_t resLen = CRYPT_EAL_EsEntropyGet(es, buf, expectGetLen);
ASSERT_TRUE(resLen == expectGetLen);
EXIT:
CRYPT_EAL_EsFree(es);
}
static int32_t GetEntropyTest(void *seedCtx, CRYPT_Data *entropy, uint32_t strength, CRYPT_Range *lenRange)
{
(void)strength;
entropy->len = lenRange->min;
entropy->data = malloc(entropy->len);
ASSERT_TRUE(CRYPT_EAL_EsEntropyGet(seedCtx, entropy->data, entropy->len) == entropy->len);
EXIT:
return CRYPT_SUCCESS;
}
static void CleanEntropyTest(void *ctx, CRYPT_Data *entropy)
{
(void)ctx;
BSL_SAL_FREE(entropy->data);
}
static int32_t GetNonceTest(void *ctx, CRYPT_Data *nonce, uint32_t strength, CRYPT_Range *lenRange)
{
return GetEntropyTest(ctx, nonce, strength, lenRange);
}
static void CleanNonceTest(void *ctx, CRYPT_Data *nonce)
{
CleanEntropyTest(ctx, nonce);
}
#endif
static uint32_t EntropyGetNormal(void *ctx, uint8_t *buf, uint32_t bufLen)
{
(void)ctx;
(void)buf;
(void)bufLen;
memset_s(buf, bufLen, 'a', bufLen);
return 32 > bufLen ? bufLen : 32;
}
static uint32_t EntropyGet0Normal(void *ctx, uint8_t *buf, uint32_t bufLen)
{
(void)ctx;
(void)buf;
(void)bufLen;
memset_s(buf, bufLen, 'a', bufLen);
return 0;
}
static void *DrbgSeedTest(void *ctx)
{
CRYPT_RandSeedMethod meth = {0};
ASSERT_TRUE(EAL_SetDefaultEntropyMeth(&meth) == CRYPT_SUCCESS);
CRYPT_EAL_RndCtx *randCtx = CRYPT_EAL_DrbgNew(CRYPT_RAND_AES128_CTR_DF, &meth, ctx);
ASSERT_TRUE(randCtx != NULL);
uint32_t in = 1;
ASSERT_TRUE(CRYPT_EAL_DrbgCtrl(randCtx, CRYPT_CTRL_SET_RESEED_INTERVAL, &in, 4) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_DrbgInstantiate(randCtx, NULL, 0) == CRYPT_SUCCESS);
for (int32_t index = 0; index < 10; index++) {
uint8_t buf[32] = {0};
ASSERT_TRUE(CRYPT_EAL_Drbgbytes(randCtx, buf, 32) == CRYPT_SUCCESS);
}
EXIT:
CRYPT_EAL_DrbgDeinit(randCtx);
return NULL;
}
#ifdef HITLS_CRYPTO_ENTROPY_SYS
static uint32_t ErrorGetEsEntropy(CRYPT_EAL_Es *esCtx, uint8_t *data, uint32_t len)
{
(void)esCtx;
(void)data;
(void)len;
return 0;
}
#endif
static CRYPT_EAL_SeedPoolCtx *GetPoolCtx(uint32_t ent1, uint32_t ent2, bool pes1, bool pes2)
{
CRYPT_EAL_SeedPoolCtx *pool = CRYPT_EAL_SeedPoolNew(true);
CRYPT_EAL_EsPara para1 = {pes2, ent2, NULL, (CRYPT_EAL_EntropyGet)EntropyGetNormal};
CRYPT_EAL_EsPara para2 = {pes1, ent1, NULL, (CRYPT_EAL_EntropyGet)EntropyGetNormal};
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, ¶1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, ¶2) == CRYPT_SUCCESS);
return pool;
EXIT:
CRYPT_EAL_SeedPoolFree(pool);
return NULL;
}
/* END_HEADER */
/* @
* @test SDV_CRYPTO_ENTROPY_EsNormalTest
* @spec -
* @title Basic function test of the entropy source.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_ENTROPY_EsNormalTest(int alg, int size, int test)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_Es *es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
const char *mode = EsGetCfMode((uint32_t)alg);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)mode, strlen(mode)) == CRYPT_SUCCESS);
bool healthTest = (bool)test;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_POOL_SIZE, (void *)&size, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);
BSL_SAL_ThreadId thrd;
ASSERT_TRUE(BSL_SAL_ThreadCreate(&thrd, EsGatherAuto, es) == 0);
BSL_SAL_ThreadId thrdget;
ASSERT_TRUE(BSL_SAL_ThreadCreate(&thrdget, EsGetAuto, es) == 0);
BSL_SAL_ThreadClose(thrd);
BSL_SAL_ThreadClose(thrdget);
EXIT:
CRYPT_EAL_EsFree(es);
return;
#else
(void)alg;
(void)size;
(void)test;
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_ENTROPY_EsCtrlTest1
* @spec -
* @title Testing the entropy source setting interface.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_ENTROPY_EsCtrlTest1(int type, int state, int excRes)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_Es *es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
uint32_t len = 512;
if (state == 1) {
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)"sm3_df", strlen("sm3_df")) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_POOL_SIZE, (void *)&len, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);
}
if (excRes == 1) {
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, type, (void *)&len, sizeof(uint32_t)) == CRYPT_SUCCESS);
} else {
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, type, (void *)&len, sizeof(uint32_t)) != CRYPT_SUCCESS);
}
EXIT:
CRYPT_EAL_EsFree(es);
return;
#else
(void)type;
(void)state;
(void)excRes;
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_ENTROPY_EsCtrlTest2
* @spec -
* @title Testing the entropy source setting interface.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_ENTROPY_EsCtrlTest2(void)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_Es *es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)"sm3_df", strlen("sm3_df")) == CRYPT_SUCCESS);
bool healthTest = true;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, 1) == CRYPT_SUCCESS);
CRYPT_EAL_NsPara para = {
"aaa",
false,
7,
{
NULL,
NULL,
EntropyReadNormal,
NULL,
},
{5, 39, 512},
};
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)¶, sizeof(CRYPT_EAL_NsPara)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_REMOVE_NS, (void *)(intptr_t)para.name, strlen(para.name)) == CRYPT_SUCCESS);
bool flag = false;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_GET_STATE, &flag, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(flag == false);
ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_GET_STATE, &flag, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(flag == true);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)"sm3_df", strlen("sm3_df")) != CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, 1) != CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)¶, sizeof(CRYPT_EAL_NsPara)) != CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_REMOVE_NS, (void *)(intptr_t)para.name, strlen(para.name)) != CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_EsFree(es);
return;
#else
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_ENTROPY_EsGatherTest
* @spec -
* @title Testing the entropy source gather interface.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_ENTROPY_EsGatherTest(int gather, int length, int expRes)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_Es *es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)"sm3_df", strlen("sm3_df")) == CRYPT_SUCCESS);
bool healthTest = true;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, 1) == CRYPT_SUCCESS);
uint32_t size = 512;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_POOL_SIZE, (void *)&size, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);
if (gather == 1) {
BSL_SAL_ThreadId thrd;
ASSERT_TRUE(BSL_SAL_ThreadCreate(&thrd, EsGatherAuto, es) == 0);
BSL_SAL_ThreadClose(thrd);
}
uint8_t buf[513] = {0};
uint32_t len = CRYPT_EAL_EsEntropyGet(es, buf, length);
ASSERT_TRUE(len == (uint32_t)expRes);
EXIT:
CRYPT_EAL_EsFree(es);
return;
#else
(void)gather;
(void)length;
(void)expRes;
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_ENTROPY_EsWithoutNsTest
* @spec -
* @title No or no available noise source test.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_ENTROPY_EsWithoutNsTest()
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_Es *es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)"sm3_df", strlen("sm3_df")) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_REMOVE_NS, (void *)(uintptr_t)"timestamp", 9) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_REMOVE_NS, (void *)(uintptr_t)"CPU-Jitter", 10) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es) != CRYPT_SUCCESS);
CRYPT_EAL_NsPara para = {
"aaa",
false,
7,
{
NULL,
EntropyInitError,
EntropyReadError,
EntropyDeinitTest,
},
{5, 39, 512},
};
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)¶, sizeof(CRYPT_EAL_NsPara)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es) != CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_EsFree(es);
return;
#else
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_ENTROPY_EsMultiNsTest
* @spec -
* @title Test with available and various unavailable noise sources.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_ENTROPY_EsMultiNsTest()
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_Es *es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)"sm3_df", strlen("sm3_df")) == CRYPT_SUCCESS);
bool healthTest = true;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, 1) == CRYPT_SUCCESS);
CRYPT_EAL_NsPara errPara = {
"read-err-ns",
false,
7,
{
NULL,
NULL,
EntropyReadError,
NULL,
},
{5, 39, 512},
};
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)&errPara, sizeof(CRYPT_EAL_NsPara)) == CRYPT_SUCCESS);
CRYPT_EAL_NsPara initPara = {
"init-err-ns",
false,
7,
{
NULL,
EntropyInitError,
EntropyReadDiffData,
EntropyDeinitTest,
},
{5, 39, 512},
};
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)&initPara, sizeof(CRYPT_EAL_NsPara)) == CRYPT_SUCCESS);
CRYPT_EAL_NsPara heaPara = {
"health-err-ns",
false,
7,
{
NULL,
EntropyInitTest,
EntropyReadNormal,
EntropyDeinitTest,
},
{5, 39, 512},
};
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)&heaPara, sizeof(CRYPT_EAL_NsPara)) == CRYPT_SUCCESS);
CRYPT_EAL_NsPara norPara = {
"normal-ns",
false,
7,
{
NULL,
EntropyInitTest,
EntropyReadDiffData,
EntropyDeinitTest,
},
{5, 39, 512},
};
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)&norPara, sizeof(CRYPT_EAL_NsPara)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);
uint8_t buf[32] = {0};
ASSERT_TRUE(CRYPT_EAL_EsEntropyGet(es, buf, 32) == 32);
EXIT:
CRYPT_EAL_EsFree(es);
return;
#else
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_ENTROPY_EsNsNumberTest
* @spec -
* @title Test with available and various unavailable noise sources.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_ENTROPY_EsNsNumberTest(int number, int minEn, int expLen)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_Es *es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)"sm3_df", strlen("sm3_df")) == CRYPT_SUCCESS);
bool healthTest = true;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, 1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_REMOVE_NS, (void *)(uintptr_t)"timestamp", 9) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_REMOVE_NS, (void *)(uintptr_t)"CPU-Jitter", 10) == CRYPT_SUCCESS);
CRYPT_EAL_NsPara errPara = {
NULL,
false,
minEn,
{
NULL,
NULL,
EntropyReadDiffData,
NULL,
},
{5, 39, 512},
};
const char *name = "ns-normal-";
errPara.name = BSL_SAL_Malloc(strlen(name) + 3);
ASSERT_TRUE(errPara.name != NULL);
for(int32_t iter = 0; iter < number; iter++) {
char str[3] = {0};
strncpy_s((char *)(intptr_t)errPara.name, strlen(name) + 3, name, strlen(name));
sprintf_s(str, 3, "%d", iter);
strcat_s((char *)(intptr_t)errPara.name, strlen(name) + 3, str);
if (iter >= 16) {
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)&errPara, sizeof(CRYPT_EAL_NsPara)) != CRYPT_SUCCESS);
} else {
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)&errPara, sizeof(CRYPT_EAL_NsPara)) == CRYPT_SUCCESS);
}
}
ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);
uint8_t buf[32] = {0};
ASSERT_TRUE(CRYPT_EAL_EsEntropyGet(es, buf, 32) == (uint32_t)expLen);
EXIT:
BSL_SAL_Free((void *)(intptr_t)errPara.name);
CRYPT_EAL_EsFree(es);
return;
#else
(void)number;
(void)minEn;
(void)expLen;
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_ENTROPY_EorTest
* @spec -
* @title Test with available and various unavailable noise sources.
* @brief 1.conditioning function not set, expected result 1
2.entropy source not initialized, expected result 2
3.repeated setting of conditioning function, expected result 3
* @expect 1. result 1: failed
2. result 2: failed
3. result 3: failed
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_ENTROPY_EorTest(void)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_Es *es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
ASSERT_TRUE(CRYPT_EAL_EsInit(es) != CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)"sm3_df", strlen("sm3_df")) == CRYPT_SUCCESS);
uint8_t buf[32] = {0};
ASSERT_TRUE(CRYPT_EAL_EsEntropyGet(es, buf, 32) == 0);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)"sm3_df", strlen("sm3_df")) != CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_EsFree(es);
return;
#else
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_ENTROPY_MutiTest
* @spec -
* @title Test with available and various unavailable noise sources.
* @brief
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_ENTROPY_MutiTest(void)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_Es *es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)"sha256_df", strlen("sha256_df")) == CRYPT_SUCCESS);
uint32_t size = 512;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_POOL_SIZE, (void *)&size, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);
BSL_SAL_ThreadId thrd;
ASSERT_TRUE(BSL_SAL_ThreadCreate(&thrd, EsGatherAuto, es) == 0);
BSL_SAL_ThreadClose(thrd);
for (int32_t iter = 0; iter < 3; iter++) {
BSL_SAL_ThreadId thrdget;
ASSERT_TRUE(BSL_SAL_ThreadCreate(&thrdget, EsGetAuto, es) == 0);
BSL_SAL_ThreadClose(thrdget);
}
EXIT:
CRYPT_EAL_EsFree(es);
return;
#else
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_ENTROPY_MutiBeforeInitTest
* @spec -
* @title Test with available and various unavailable noise sources.
* @brief
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_ENTROPY_MutiBeforeInitTest(void)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_Es *es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
for (int32_t iter = 0; iter < 3; iter++) {
BSL_SAL_ThreadId thrdget;
ASSERT_TRUE(BSL_SAL_ThreadCreate(&thrdget, EsMutiAuto, es) == 0);
BSL_SAL_ThreadClose(thrdget);
}
BSL_SAL_ThreadId thrd;
ASSERT_TRUE(BSL_SAL_ThreadCreate(&thrd, EsGatherAuto, es) == 0);
BSL_SAL_ThreadClose(thrd);
EXIT:
CRYPT_EAL_EsFree(es);
return;
#else
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_ENTROPY_ES_FUNC_0001
* @spec -
* @title Function test with the health test disabled, noise source not added, and entropy not added.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_ENTROPY_ES_FUNC_0001(int enableTest)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_Es *es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)"sha512_df", strlen("sha512_df")) == CRYPT_SUCCESS);
if(enableTest) {
bool healthTest = true;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, 1) == CRYPT_SUCCESS);
}
ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);
uint32_t size;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_POOL_GET_CURRSIZE, (void *)&size, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_EQ(size, 0);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_POOL_GET_CURRSIZE, (void *)&size, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_EQ(size, 64);
uint8_t buf[8192] = {0};
uint32_t resLen = CRYPT_EAL_EsEntropyGet(es, buf, 8192);
ASSERT_TRUE(resLen == 64);
EXIT:
CRYPT_EAL_EsFree(es);
return;
#else
(void)enableTest;
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_ENTROPY_ES_FUNC_0002
* @spec -
* @title Function test of adding noise sources and entropy by pressing Ctrl when the health check mode is disabled.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_ENTROPY_ES_FUNC_0002(int enableTest)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_Es *es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)"sm3_df", strlen("sm3_df")) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_REMOVE_NS, (void *)(uintptr_t)"timestamp", 9) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_REMOVE_NS, (void *)(uintptr_t)"CPU-Jitter", 10) == CRYPT_SUCCESS);
CRYPT_EAL_NsPara norPara = {
"normal-ns",
enableTest,
7,
{
NULL,
EntropyInitTest,
EntropyReadDiffData,
EntropyDeinitTest,
},
{5, 39, 512},
};
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)&norPara, sizeof(CRYPT_EAL_NsPara)) == CRYPT_SUCCESS);
if(enableTest) {
bool healthTest = true;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, 1) == CRYPT_SUCCESS);
}
ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);
uint32_t size;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_POOL_GET_CURRSIZE, (void *)&size, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_EQ(size, 0);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_POOL_GET_CURRSIZE, (void *)&size, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_EQ(size, 32);
uint8_t buf[8192] = {0};
uint32_t resLen = CRYPT_EAL_EsEntropyGet(es, buf, 8192);
ASSERT_TRUE(resLen == 32);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_POOL_GET_CURRSIZE, (void *)&size, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_EQ(size, 0);
EXIT:
CRYPT_EAL_EsFree(es);
return;
#else
(void)enableTest;
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_ENTROPY_ES_FUNC_0003
* @spec -
* @title Entropy source traversal test with the health test disabled, no noise source added, and different compression functions enabled.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_ENTROPY_ES_FUNC_0003(int alg, int enableTest)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_Es *es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
const char *mode = EsGetCfMode((uint32_t)alg);
uint32_t expectGetLen = EsGetCfLen((uint32_t)alg);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)mode, strlen(mode)) == CRYPT_SUCCESS);
if(enableTest) {
bool healthTest = true;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, 1) == CRYPT_SUCCESS);
}
ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);
uint32_t size;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_POOL_GET_CURRSIZE, (void *)&size, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_EQ(size, 0);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_POOL_GET_CURRSIZE, (void *)&size, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_EQ(size, expectGetLen);
uint8_t buf[8192] = {0};
uint32_t resLen = CRYPT_EAL_EsEntropyGet(es, buf, 8192);
ASSERT_TRUE(resLen == expectGetLen);
EXIT:
CRYPT_EAL_EsFree(es);
return;
#else
(void)alg;
(void)enableTest;
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_ENTROPY_ES_FUNC_0004
* @spec -
* @title Function test of adding noise source and removing noise source after obtaining entropy source in health test disabled mode.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_ENTROPY_ES_FUNC_0004(int enableTest)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
uint32_t expectGetLen = 32;
CRYPT_EAL_Es *es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)"sm3_df", strlen("sm3_df")) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_REMOVE_NS, (void *)(uintptr_t)"timestamp", 9) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_REMOVE_NS, (void *)(uintptr_t)"CPU-Jitter", 10) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_ENTROPY_ES_NO_NS);
CRYPT_EAL_NsPara norPara1 = {
"normal-ns",
enableTest,
7,
{
NULL,
EntropyInitTest,
EntropyReadDiffData,
EntropyDeinitTest,
},
{0, 0, 512},
};
CRYPT_EAL_NsPara norPara2 = {
"timestamp",
enableTest,
7,
{
NULL,
EntropyInitTest,
EntropyReadDiffData,
EntropyDeinitTest,
},
{5, 39, 512},
};
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)&norPara1, sizeof(CRYPT_EAL_NsPara)) == CRYPT_SUCCESS);
if(enableTest) {
bool healthTest = true;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, 1) == CRYPT_SUCCESS);
}
ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);
uint32_t size;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_POOL_GET_CURRSIZE, (void *)&size, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_EQ(size, 0);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_POOL_GET_CURRSIZE, (void *)&size, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_EQ(size, expectGetLen);
uint8_t buf[8192] = {0};
uint32_t resLen = CRYPT_EAL_EsEntropyGet(es, buf, 8192);
ASSERT_TRUE(resLen == expectGetLen);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_POOL_GET_CURRSIZE, (void *)&size, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_EQ(size, 0);
(void)BSL_SAL_ThreadWriteLock(es->lock);
ENTROPY_EsDeinit(es->es);
(void)BSL_SAL_ThreadUnlock(es->lock);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_REMOVE_NS, (void *)(uintptr_t)"normal-ns", 10) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_ENTROPY_ES_NO_NS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)&norPara2, sizeof(CRYPT_EAL_NsPara)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
resLen = CRYPT_EAL_EsEntropyGet(es, buf, 8192);
ASSERT_TRUE(resLen == expectGetLen);
EXIT:
CRYPT_EAL_EsFree(es);
return;
#else
(void)enableTest;
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_ENTROPY_ES_FUNC_0005
* @spec -
* @title Functional testing of boundary values for different entropy pool sizes.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_ENTROPY_ES_FUNC_0005(void)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
uint32_t poolErrorSize[] = {511, 4097, 1024};
uint32_t poolSize = 512;
int32_t ret = 1;
CRYPT_EAL_Es *es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)"sm3_df", strlen("sm3_df")) == CRYPT_SUCCESS);
for (uint32_t i = 0; i < sizeof(poolErrorSize)/sizeof(uint32_t); i++) {
ret = CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_POOL_SIZE, (void *)&poolErrorSize[i], sizeof(uint32_t));
if (ret == CRYPT_SUCCESS) {
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_GET_POOL_SIZE, &poolSize, sizeof(uint32_t)) == CRYPT_ENTROPY_ES_STATE_ERROR);
ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_GET_POOL_SIZE, &poolSize, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_EQ(poolSize, poolErrorSize[i]);
} else {
ASSERT_TRUE(ret == CRYPT_ENTROPY_CTRL_INVALID_PARAM);
}
}
EXIT:
CRYPT_EAL_EsFree(es);
return;
#else
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_ENTROPY_ES_FUNC_0006
* @spec -
* @title Entropy source function test in the multi-thread concurrency scenario.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_ENTROPY_ES_FUNC_0006(int alg)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
const uint32_t threadNum = 5;
pthread_t threadId[threadNum];
for(uint32_t i = 0; i < threadNum; i++) {
int ret = pthread_create(&threadId[i], NULL, (void *)EntropyESMutilTest, &alg);
ASSERT_TRUE(ret == 0);
}
for(uint32_t i = 0; i < threadNum; i++) {
pthread_join(threadId[i], NULL);
}
EXIT:
return;
#else
(void)alg;
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_ENTROPY_ES_FUNC_0007
* @spec -
* @title Adding an Existing Noise Source Control Test.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_ENTROPY_ES_FUNC_0007(int enableTest)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_NsPara norPara = {
"timestamp",
enableTest,
7,
{
NULL,
EntropyInitTest,
EntropyReadDiffData,
EntropyDeinitTest,
},
{5, 39, 512},
};
CRYPT_EAL_Es *es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)"sm3_df", strlen("sm3_df")) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)&norPara, sizeof(CRYPT_EAL_NsPara)) == CRYPT_ENTROPY_ES_DUP_NS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_REMOVE_NS, (void *)(uintptr_t)"notExistNs", 10) == CRYPT_ENTROPY_ES_NS_NOT_FOUND);
EXIT:
CRYPT_EAL_EsFree(es);
return;
#else
(void)enableTest;
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_EAL_SEEDPOOL_GetTest
* @spec -
* @title seedpool_GetTest
* @precon nan
* @brief 1. Entropy data length: 32 - 512, entropy amount: 384, npes not available, return length: 48
2. Entropy data length: 32 - 512, entropy amount: 384, npes available, return length: 64
3. entropy data length: 64 - 512, entropy: 380, npes not available, return length: 64
4. Entropy data length: 64 - 512, entropy amount: 380, npes available, return length: 64
5. Entropy data length: 48 - 512, entropy amount: 384, npes available, return length: 54
6. entropy data length: 32 - 32, entropy amount: 256, npes not available, return length: 32
7. entropy data length: 48 - 48, entropy amount: 256, npes available, return length: 48
8. entropy data length: 48 - 512, entropy amount: 680, npes available, return length: 48
* @expect
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_SEEDPOOL_GetTest(int min, int max, int entropy, int npes, int exp)
{
uint8_t *buf = NULL;
CRYPT_EAL_SeedPoolCtx *pool = CRYPT_EAL_SeedPoolNew(true);
ASSERT_TRUE(pool != NULL);
CRYPT_EAL_EsPara para1 = {false, 6, NULL, (CRYPT_EAL_EntropyGet)EntropyGetNormal};
CRYPT_EAL_EsPara para2 = {true, 8, NULL, (CRYPT_EAL_EntropyGet)EntropyGetNormal};
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, ¶1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, ¶2) == CRYPT_SUCCESS);
EAL_EntropyCtx *ctx = EAL_EntropyNewCtx(pool, (bool)npes, (uint32_t)min, (uint32_t)max, (uint32_t)entropy);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SUCCESS);
uint32_t len;
buf = EAL_EntropyDetachBuf(ctx, &len);
ASSERT_TRUE(len == (uint32_t)exp);
if (exp == 0) {
ASSERT_TRUE(buf == NULL);
} else {
ASSERT_TRUE(buf != NULL);
}
EXIT:
BSL_SAL_Free(buf);
EAL_EntropyFreeCtx(ctx);
CRYPT_EAL_SeedPoolFree(pool);
return;
}
/* END_CASE */
#if defined(HITLS_CRYPTO_ENTROPY_GETENTROPY) || defined(HITLS_CRYPTO_ENTROPY_DEVRANDOM)
#include "entropy_seed_pool.h"
typedef struct EntCtx {
uint32_t entSum;
} EntCtx;
static uint32_t EntropyGetSum(void *ctx, uint8_t *buf, uint32_t bufLen)
{
EntCtx *enctx = (EntCtx *)ctx;
uint32_t ret = ENTROPY_SysEntropyGet(ctx, buf, bufLen);
enctx->entSum += ret;
return ret;
}
#endif
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_SEEDPOOL_EntropySumTest(int minEntropy1, int minEntropy2, int min, int entropy, int exp)
{
#if defined(HITLS_CRYPTO_ENTROPY_GETENTROPY) || defined(HITLS_CRYPTO_ENTROPY_DEVRANDOM)
uint8_t *buf = NULL;
EntCtx enctx = {0};
CRYPT_EAL_SeedPoolCtx *pool = CRYPT_EAL_SeedPoolNew(true);
ASSERT_TRUE(pool != NULL);
CRYPT_EAL_EsPara para1 = {false, minEntropy1, &enctx, (CRYPT_EAL_EntropyGet)EntropyGetSum};
CRYPT_EAL_EsPara para2 = {false, minEntropy2, &enctx, (CRYPT_EAL_EntropyGet)EntropyGetSum};
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, ¶1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, ¶2) == CRYPT_SUCCESS);
EAL_EntropyCtx *ctx = EAL_EntropyNewCtx(pool, true, (uint32_t)min, (uint32_t)min, (uint32_t)entropy);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SUCCESS);
uint32_t len;
buf = EAL_EntropyDetachBuf(ctx, &len);
ASSERT_TRUE(len == (uint32_t)min);
if (exp == 0) {
ASSERT_TRUE(buf == NULL);
} else {
ASSERT_TRUE(buf != NULL);
}
ASSERT_TRUE(enctx.entSum == (uint32_t)exp);
EXIT:
BSL_SAL_Free(buf);
EAL_EntropyFreeCtx(ctx);
CRYPT_EAL_SeedPoolFree(pool);
return;
#else
(void)minEntropy1;
(void)minEntropy2;
(void)min;
(void)entropy;
(void)exp;
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_SEEDPOOL_DrbgTest
* @spec -
* @title use seedpool to construct an entropy source and generate a random number.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_SEEDPOOL_DrbgTest(int isNull, int algId)
{
#ifndef HITLS_CRYPTO_DRBG_GM
if (algId == CRYPT_RAND_SM3 || algId == CRYPT_RAND_SM4_CTR_DF) {
(void)isNull;
SKIP_TEST();
}
#endif
#ifndef HITLS_CRYPTO_DRBG_HASH
if (algId == CRYPT_RAND_SHA256) {
(void)isNull;
SKIP_TEST();
}
#endif
#ifndef HITLS_CRYPTO_DRBG_HMAC
if (algId == CRYPT_RAND_HMAC_SHA256 || algId == CRYPT_RAND_HMAC_SHA384) {
(void)isNull;
SKIP_TEST();
}
#endif
#ifndef HITLS_CRYPTO_DRBG_CTR
if (algId == CRYPT_RAND_AES128_CTR_DF || algId == CRYPT_RAND_SM4_CTR_DF) {
(void)isNull;
SKIP_TEST();
}
#endif
uint8_t output[16];
CRYPT_EAL_SeedPoolCtx *pool = CRYPT_EAL_SeedPoolNew((bool)isNull);
CRYPT_EAL_EsPara para1 = {true, 6, NULL, (CRYPT_EAL_EntropyGet)EntropyGetNormal};
CRYPT_EAL_EsPara para2 = {false, 7, NULL, (CRYPT_EAL_EntropyGet)EntropyGetNormal};
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, ¶1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, ¶2) == CRYPT_SUCCESS);
CRYPT_RandSeedMethod meth = {0};
ASSERT_TRUE(EAL_SetDefaultEntropyMeth(&meth) == CRYPT_SUCCESS);
CRYPT_EAL_RandDeinit();
ASSERT_TRUE(CRYPT_EAL_RandInit((CRYPT_RAND_AlgId)algId, &meth, (void *)pool, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_Randbytes(output, 16) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_RandDeinit();
CRYPT_EAL_SeedPoolFree(pool);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_ENTROPY_DrbgTest
* @spec -
* @title use hitls es to construct an entropy source and generate a random number.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_ENTROPY_DrbgTest(void)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
uint8_t output[256];
CRYPT_EAL_Es *es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)"sha256_df", strlen("sha256_df")) == CRYPT_SUCCESS);
CRYPT_EAL_NsPara para = {
"aaa",
true,
7,
{
NULL,
NULL,
EntropyReadNormal,
NULL,
},
{5, 39, 512},
};
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)¶, sizeof(CRYPT_EAL_NsPara)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);
for (int32_t iter = 0; iter < 5; iter++) {
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
}
CRYPT_RandSeedMethod meth = {GetEntropyTest, CleanEntropyTest, GetNonceTest, CleanNonceTest};
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, &meth, (void *)es, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_Randbytes(output, 256) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_RandDeinit();
CRYPT_EAL_EsFree(es);
return;
#else
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_SEEDPOOL_MutiTest
* @spec -
* @title use seedpool to construct the entropy source and perform the multi-thread test.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_SEEDPOOL_MutiTest(void)
{
CRYPT_EAL_SeedPoolCtx *pool = CRYPT_EAL_SeedPoolNew(false);
CRYPT_EAL_EsPara para1 = {true, 6, NULL, (CRYPT_EAL_EntropyGet)EntropyGetNormal};
CRYPT_EAL_EsPara para2 = {false, 7, NULL, (CRYPT_EAL_EntropyGet)EntropyGetNormal};
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, ¶1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, ¶2) == CRYPT_SUCCESS);
CRYPT_RandSeedMethod meth = {0};
ASSERT_TRUE(EAL_SetDefaultEntropyMeth(&meth) == CRYPT_SUCCESS);
for (int32_t index = 0; index < 3; index++) {
pthread_t thrd;
ASSERT_TRUE(pthread_create(&thrd, NULL, DrbgSeedTest, pool) == 0);
pthread_join(thrd, NULL);
}
EXIT:
CRYPT_EAL_SeedPoolFree(pool);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_SEEDPOOL_GetEntropyErrTest
* @spec -
* @title The entropy source quality is too poor to meet the requirements.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_SEEDPOOL_GetEntropyErrTest(void)
{
CRYPT_EAL_SeedPoolCtx *pool = GetPoolCtx(5, 5, true, false);
ASSERT_TRUE(pool != NULL);
EAL_EntropyCtx *ctx = EAL_EntropyNewCtx(pool, true, 32, 48, 256);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) != CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_SeedPoolFree(pool);
EAL_EntropyFreeCtx(ctx);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_SEEDPOOL_EntLenLessMinTest
* @spec -
* @title The supplied entropy source data is smaller than the minimum length.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_SEEDPOOL_EntLenLessMinTest(void)
{
CRYPT_EAL_SeedPoolCtx *pool = GetPoolCtx(5, 5, true, false);
ASSERT_TRUE(pool != NULL);
EAL_EntropyCtx *ctx = EAL_EntropyNewCtx(pool, true, 32, 48, 128);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_SeedPoolFree(pool);
EAL_EntropyFreeCtx(ctx);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_SEEDPOOL_Get0EntropyTest
* @spec -
* @title failed to obtain entropy data from the entropy pool.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_SEEDPOOL_Get0EntropyTest(void)
{
CRYPT_EAL_SeedPoolCtx *pool = CRYPT_EAL_SeedPoolNew(true);
CRYPT_EAL_EsPara para1 = {true, 6, NULL, (CRYPT_EAL_EntropyGet)EntropyGet0Normal};
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, ¶1) == CRYPT_SUCCESS);
EAL_EntropyCtx *ctx = EAL_EntropyNewCtx(pool, true, 32, 48, 256);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) != CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_SeedPoolFree(pool);
EAL_EntropyFreeCtx(ctx);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_SEEDPOOL_UnsedSeedPoolTest
* @spec -
* @title Failed to obtain the entropy data of sufficient length.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_SEEDPOOL_UnsedSeedPoolTest(void)
{
CRYPT_EAL_SeedPoolCtx *pool = GetPoolCtx(8, 8, true, false);
ASSERT_TRUE(pool != NULL);
EAL_EntropyCtx *ctx = EAL_EntropyNewCtx(pool, true, 81, 100, 128);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) != CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_SeedPoolFree(pool);
EAL_EntropyFreeCtx(ctx);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_SEEDPOOL_DiffEntropyTest
* @spec -
* @title The entropy pool used for handle creation is inconsistent with the obtained entropy pool. As a result,
the entropy source fails to be obtained.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_SEEDPOOL_DiffEntropyTest(void)
{
CRYPT_EAL_SeedPoolCtx *pool = GetPoolCtx(8, 8, true, false);
ASSERT_TRUE(pool != NULL);
EAL_EntropyCtx *ctx = EAL_EntropyNewCtx(pool, true, 32, 64, 256);
ASSERT_TRUE(ctx != NULL);
CRYPT_EAL_SeedPoolCtx *pool1 = GetPoolCtx(6, 6, true, false);
ASSERT_TRUE(pool1 != NULL);
ASSERT_TRUE(EAL_EntropyCollection(pool1, ctx) != CRYPT_SUCCESS);
CRYPT_EAL_SeedPoolFree(pool1);
EXIT:
CRYPT_EAL_SeedPoolFree(pool);
EAL_EntropyFreeCtx(ctx);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_SEEDPOOL_Get0EntropyTest
* @spec -
* @title Obtains the total entropy output without using the conditioning function.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_SEEDPOOL_FENoEcfTest(int ent)
{
CRYPT_EAL_SeedPoolCtx *pool = GetPoolCtx(8, 7, true, false);
ASSERT_TRUE(pool != NULL);
EAL_EntropyCtx *ctx = EAL_EntropyNewCtx(pool, true, 32, 32, ent);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SUCCESS);
uint32_t len;
uint8_t *data = EAL_EntropyDetachBuf(ctx, &len);
ASSERT_TRUE(data != NULL);
ASSERT_TRUE(len == 32);
BSL_SAL_Free(data);
EXIT:
CRYPT_EAL_SeedPoolFree(pool);
EAL_EntropyFreeCtx(ctx);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_SEEDPOOL_FEWithEcfTest
* @spec -
* @title Obtains the total entropy output without using the conditioning function.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_SEEDPOOL_FEWithEcfTest(void)
{
#ifndef HITLS_CRYPTO_HMAC
SKIP_TEST();
#endif
CRYPT_EAL_SeedPoolCtx *pool = GetPoolCtx(8, 7, true, false);
ASSERT_TRUE(pool != NULL);
EAL_EntropyCtx *ctx = EAL_EntropyNewCtx(pool, true, 48, 48, 384);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SUCCESS);
uint32_t len;
uint8_t *data = EAL_EntropyDetachBuf(ctx, &len);
ASSERT_TRUE(data != NULL);
ASSERT_TRUE(len == 48);
BSL_SAL_Free(data);
EXIT:
CRYPT_EAL_SeedPoolFree(pool);
EAL_EntropyFreeCtx(ctx);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_SEEDPOOL_CompleteTest
* @spec -
* @title Complete usage testing from entropy source to drbg.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_SEEDPOOL_CompleteTest(void)
{
CRYPT_EAL_RndCtx *rndCtx = NULL;
CRYPT_EAL_SeedPoolCtx *pool = CRYPT_EAL_SeedPoolNew(false);
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_Es *es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
char *mode = "sm3_df";
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)mode, strlen(mode)) == CRYPT_SUCCESS);
bool healthTest = true;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, 1) == CRYPT_SUCCESS);
uint32_t size = 512;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_POOL_SIZE, (void *)&size, sizeof(uint32_t)) == CRYPT_SUCCESS);
CRYPT_EAL_NsPara para = {
"aaa",
false,
5,
{
NULL,
NULL,
EntropyReadNormal,
NULL,
},
{5, 39, 512},
};
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ADD_NS, (void *)¶, sizeof(CRYPT_EAL_NsPara)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);
BSL_SAL_ThreadId thrd;
ASSERT_TRUE(BSL_SAL_ThreadCreate(&thrd, EsGatherAuto, es) == 0);
BSL_SAL_ThreadClose(thrd);
CRYPT_EAL_EsPara para1 = {false, 8, es, (CRYPT_EAL_EntropyGet)CRYPT_EAL_EsEntropyGet};
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, ¶1) == CRYPT_SUCCESS);
#endif
CRYPT_RandSeedMethod meth = {0};
ASSERT_TRUE(EAL_SetDefaultEntropyMeth(&meth) == CRYPT_SUCCESS);
#ifdef HITLS_CRYPTO_DRBG_GM
rndCtx = CRYPT_EAL_DrbgNew(CRYPT_RAND_SM4_CTR_DF, &meth, pool);
#else
rndCtx = CRYPT_EAL_DrbgNew(CRYPT_RAND_AES256_CTR_DF, &meth, pool);
#endif
ASSERT_TRUE(rndCtx != NULL);
ASSERT_TRUE(CRYPT_EAL_DrbgInstantiate(rndCtx, NULL, 0) == CRYPT_SUCCESS);
uint8_t out[16] = {0};
ASSERT_TRUE(CRYPT_EAL_Drbgbytes(rndCtx, out, 16) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_DrbgSeed(rndCtx) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_DrbgDeinit(rndCtx);
CRYPT_EAL_SeedPoolFree(pool);
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_EsFree(es);
#endif
return;
}
/* END_CASE */
/* @
* @test HITLS_SDV_DRBG_GM_FUNC_TC019
* @spec -
* @title Complete usage testing from entropy sources.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void HITLS_SDV_DRBG_GM_FUNC_TC019(int isCreateNullPool, int isPhysical, int minEntropy, int minL, int maxL, int entropyL, int isValid)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_Es *es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
char *mode = "sm3_df";
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)mode, strlen(mode)) == CRYPT_SUCCESS);
bool healthTest = true;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, sizeof(bool)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es) == CRYPT_SUCCESS);
if (isCreateNullPool) {
for (int i = 0; i < 16; i++) {
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
}
}
CRYPT_EAL_EsPara esPara = {isPhysical, (uint32_t)minEntropy, es, NULL};
if (isValid) {
esPara.entropyGet = (CRYPT_EAL_EntropyGet)CRYPT_EAL_EsEntropyGet;
} else {
esPara.entropyGet = (CRYPT_EAL_EntropyGet)ErrorGetEsEntropy;
}
CRYPT_EAL_SeedPoolCtx *pool = CRYPT_EAL_SeedPoolNew(isCreateNullPool);
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, &esPara) == CRYPT_SUCCESS);
uint8_t isNpesUsed = true;
uint32_t minLen = (uint32_t)minL;
uint32_t maxLen = (uint32_t)maxL;
uint32_t entropy = (uint32_t)entropyL;
EAL_EntropyCtx *ctx = EAL_EntropyNewCtx(pool, isNpesUsed, minLen, maxLen, entropy);
ASSERT_TRUE(ctx != NULL);
if (isCreateNullPool && !isValid) {
ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SEED_POOL_NOT_MEET_REQUIREMENT);
} else {
ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SUCCESS);
}
EXIT:
CRYPT_EAL_SeedPoolFree(pool);
EAL_EntropyFreeCtx(ctx);
CRYPT_EAL_EsFree(es);
return;
#else
(void)isCreateNullPool;
(void)isPhysical;
(void)minEntropy;
(void)minL;
(void)maxL;
(void)entropyL;
(void)isValid;
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test HITLS_SDV_DRBG_GM_FUNC_TC039
* @spec -
* @title Complete usage testing from entropy sources.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void HITLS_SDV_DRBG_GM_FUNC_TC039(int isCreateNullPool, int isPhysical, int minEntropy, int minL, int maxL, int entropyL)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_SeedPoolCtx *pool = CRYPT_EAL_SeedPoolNew(isCreateNullPool);
CRYPT_EAL_Es *es1 = CRYPT_EAL_EsNew();
ASSERT_TRUE(es1 != NULL);
char *mode = "sm3_df";
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es1, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)mode, strlen(mode)) == CRYPT_SUCCESS);
bool healthTest = true;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es1, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, sizeof(bool)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es1, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
CRYPT_EAL_EsPara esPara1 = {isPhysical, (uint32_t)minEntropy, es1, (CRYPT_EAL_EntropyGet)CRYPT_EAL_EsEntropyGet};
CRYPT_EAL_Es *es2 = CRYPT_EAL_EsNew();
ASSERT_TRUE(es2 != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es2, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)mode, strlen(mode)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es2, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, sizeof(bool)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es2) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es2, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
CRYPT_EAL_EsPara esPara2 = {!isPhysical, (uint32_t)minEntropy, es2, (CRYPT_EAL_EntropyGet)CRYPT_EAL_EsEntropyGet};
CRYPT_EAL_Es *es3 = CRYPT_EAL_EsNew();
ASSERT_TRUE(es3 != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es3, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)mode, strlen(mode)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es3, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, sizeof(bool)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es3) == CRYPT_SUCCESS);
if (isCreateNullPool) {
for (int i = 0; i < 3; i++) {
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es3, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
}
}
CRYPT_EAL_EsPara esPara3 = {isPhysical, (uint32_t)minEntropy, es3, (CRYPT_EAL_EntropyGet)CRYPT_EAL_EsEntropyGet};
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, &esPara1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, &esPara2) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, &esPara3) == CRYPT_SUCCESS);
EAL_EntropyCtx *ctx = EAL_EntropyNewCtx(pool, true, (uint32_t)minL, (uint32_t)maxL, (uint32_t)entropyL);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_SeedPoolFree(pool);
EAL_EntropyFreeCtx(ctx);
CRYPT_EAL_EsFree(es1);
CRYPT_EAL_EsFree(es2);
CRYPT_EAL_EsFree(es3);
return;
#else
(void)isCreateNullPool;
(void)isPhysical;
(void)minEntropy;
(void)minL;
(void)maxL;
(void)entropyL;
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test HITLS_SDV_DRBG_GM_FUNC_TC067
* @spec -
* @title Complete usage testing from entropy sources.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void HITLS_SDV_DRBG_GM_FUNC_TC067(int isCreateNullPool, int isPhysical, int minEntropy, int minL, int maxL, int entropyL)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_SeedPoolCtx *pool = CRYPT_EAL_SeedPoolNew(isCreateNullPool);
CRYPT_EAL_Es *es1 = CRYPT_EAL_EsNew();
ASSERT_TRUE(es1 != NULL);
char *mode = "sm3_df";
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es1, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)mode, strlen(mode)) == CRYPT_SUCCESS);
bool healthTest = true;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es1, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, sizeof(bool)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es1, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
CRYPT_EAL_EsPara esPara1 = {isPhysical, (uint32_t)minEntropy, es1, (CRYPT_EAL_EntropyGet)ErrorGetEsEntropy};
CRYPT_EAL_Es *es2 = CRYPT_EAL_EsNew();
ASSERT_TRUE(es2 != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es2, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)mode, strlen(mode)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es2, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, sizeof(bool)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es2) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es2, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
CRYPT_EAL_EsPara esPara2 = {!isPhysical, (uint32_t)minEntropy, es2, (CRYPT_EAL_EntropyGet)ErrorGetEsEntropy};
CRYPT_EAL_Es *es3 = CRYPT_EAL_EsNew();
ASSERT_TRUE(es3 != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es3, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)mode, strlen(mode)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es3, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, sizeof(bool)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es3) == CRYPT_SUCCESS);
CRYPT_EAL_EsPara esPara3 = {isPhysical, (uint32_t)minEntropy, es3, (CRYPT_EAL_EntropyGet)ErrorGetEsEntropy};
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, &esPara1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, &esPara2) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, &esPara3) == CRYPT_SUCCESS);
EAL_EntropyCtx *ctx = EAL_EntropyNewCtx(pool, true, (uint32_t)minL, (uint32_t)maxL, (uint32_t)entropyL);
ASSERT_TRUE(ctx != NULL);
if (isCreateNullPool) {
ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) != CRYPT_SUCCESS);
} else {
ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SUCCESS);
}
EXIT:
CRYPT_EAL_SeedPoolFree(pool);
EAL_EntropyFreeCtx(ctx);
CRYPT_EAL_EsFree(es1);
CRYPT_EAL_EsFree(es2);
CRYPT_EAL_EsFree(es3);
return;
#else
(void)isCreateNullPool;
(void)isPhysical;
(void)minEntropy;
(void)minL;
(void)maxL;
(void)entropyL;
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test HITLS_SDV_DRBG_GM_FUNC_TC071
* @spec -
* @title Complete usage testing from entropy sources.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void HITLS_SDV_DRBG_GM_FUNC_TC071(int isCreateNullPool, int isPhysical, int minEntropy, int minL, int maxL, int entropyL)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_SeedPoolCtx *pool = CRYPT_EAL_SeedPoolNew(isCreateNullPool);
CRYPT_EAL_Es *es1 = CRYPT_EAL_EsNew();
ASSERT_TRUE(es1 != NULL);
char *mode = "sm3_df";
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es1, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)mode, strlen(mode)) == CRYPT_SUCCESS);
bool healthTest = true;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es1, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, sizeof(bool)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es1, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
CRYPT_EAL_EsPara esPara1 = {!isPhysical, (uint32_t)minEntropy, es1, (CRYPT_EAL_EntropyGet)ErrorGetEsEntropy};
CRYPT_EAL_Es *es2 = CRYPT_EAL_EsNew();
ASSERT_TRUE(es2 != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es2, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)mode, strlen(mode)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es2, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, sizeof(bool)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es2) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es2, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
CRYPT_EAL_EsPara esPara2 = {isPhysical, (uint32_t)minEntropy, es2, (CRYPT_EAL_EntropyGet)ErrorGetEsEntropy};
CRYPT_EAL_Es *es3 = CRYPT_EAL_EsNew();
ASSERT_TRUE(es3 != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es3, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)mode, strlen(mode)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es3, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, sizeof(bool)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es3) == CRYPT_SUCCESS);
if (isCreateNullPool) {
for (int i = 0; i < 13; i++) {
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es3, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
}
}
CRYPT_EAL_EsPara esPara3 = {isPhysical, (uint32_t)minEntropy, es3, (CRYPT_EAL_EntropyGet)CRYPT_EAL_EsEntropyGet};
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, &esPara1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, &esPara2) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, &esPara3) == CRYPT_SUCCESS);
EAL_EntropyCtx *ctx = EAL_EntropyNewCtx(pool, true, (uint32_t)minL, (uint32_t)maxL, (uint32_t)entropyL);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_SeedPoolFree(pool);
EAL_EntropyFreeCtx(ctx);
CRYPT_EAL_EsFree(es1);
CRYPT_EAL_EsFree(es2);
CRYPT_EAL_EsFree(es3);
return;
#else
(void)isCreateNullPool;
(void)isPhysical;
(void)minEntropy;
(void)minL;
(void)maxL;
(void)entropyL;
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test HITLS_SDV_DRBG_GM_FUNC_TC051
* @spec -
* @title Complete usage testing from entropy sources.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void HITLS_SDV_DRBG_GM_FUNC_TC051(int isCreateNullPool, int isPhysical, int minEntropy1,
int minEntropy2, int minEntropy3, int minL, int maxL, int entropyL)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_SeedPoolCtx *pool = CRYPT_EAL_SeedPoolNew(isCreateNullPool);
CRYPT_EAL_Es *es1 = CRYPT_EAL_EsNew();
ASSERT_TRUE(es1 != NULL);
char *mode = "sm3_df";
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es1, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)mode, strlen(mode)) == CRYPT_SUCCESS);
bool healthTest = true;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es1, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, sizeof(bool)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es1) == CRYPT_SUCCESS);
if (isCreateNullPool) {
for (int i = 0; i < 1; i++) {
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es1, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
}
}
CRYPT_EAL_EsPara esPara1 = {!isPhysical, (uint32_t)minEntropy1, es1, (CRYPT_EAL_EntropyGet)ErrorGetEsEntropy};
CRYPT_EAL_Es *es2 = CRYPT_EAL_EsNew();
ASSERT_TRUE(es2 != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es2, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)mode, strlen(mode)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es2, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, sizeof(bool)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es2) == CRYPT_SUCCESS);
if (isCreateNullPool) {
for (int i = 0; i < 2; i++) {
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es2, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
}
}
CRYPT_EAL_EsPara esPara2 = {isPhysical, (uint32_t)minEntropy2, es2, (CRYPT_EAL_EntropyGet)ErrorGetEsEntropy};
CRYPT_EAL_Es *es3 = CRYPT_EAL_EsNew();
ASSERT_TRUE(es3 != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es3, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)mode, strlen(mode)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es3, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, sizeof(bool)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es3) == CRYPT_SUCCESS);
if (isCreateNullPool) {
for (int i = 0; i < 13; i++) {
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es3, CRYPT_ENTROPY_GATHER_ENTROPY, NULL, 0) == CRYPT_SUCCESS);
}
}
CRYPT_EAL_EsPara esPara3 = {isPhysical, (uint32_t)minEntropy3, es3, (CRYPT_EAL_EntropyGet)CRYPT_EAL_EsEntropyGet};
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, &esPara1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, &esPara2) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, &esPara3) == CRYPT_SUCCESS);
EAL_EntropyCtx *ctx = EAL_EntropyNewCtx(pool, true, (uint32_t)minL, (uint32_t)maxL, (uint32_t)entropyL);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_SeedPoolFree(pool);
EAL_EntropyFreeCtx(ctx);
CRYPT_EAL_EsFree(es1);
CRYPT_EAL_EsFree(es2);
CRYPT_EAL_EsFree(es3);
return;
#else
(void)isCreateNullPool;
(void)isPhysical;
(void)minEntropy1;
(void)minEntropy2;
(void)minEntropy3;
(void)minL;
(void)maxL;
(void)entropyL;
SKIP_TEST();
#endif
}
/* END_CASE */
/* @
* @test HITLS_SDV_DRBG_GM_FUNC_TC056
* @spec -
* @title Complete usage testing from entropy sources.
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void HITLS_SDV_DRBG_GM_FUNC_TC056(int isCreateNullPool, int isPhysical, int minEntropy1,
int minEntropy2, int minEntropy3, int minL, int maxL, int entropyL)
{
#ifdef HITLS_CRYPTO_ENTROPY_SYS
CRYPT_EAL_SeedPoolCtx *pool = CRYPT_EAL_SeedPoolNew(isCreateNullPool);
CRYPT_EAL_Es *es1 = CRYPT_EAL_EsNew();
ASSERT_TRUE(es1 != NULL);
char *mode = "sm3_df";
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es1, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)mode, strlen(mode)) == CRYPT_SUCCESS);
bool healthTest = true;
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es1, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, sizeof(bool)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es1) == CRYPT_SUCCESS);
CRYPT_EAL_EsPara esPara1 = {!isPhysical, (uint32_t)minEntropy1, es1, (CRYPT_EAL_EntropyGet)ErrorGetEsEntropy};
CRYPT_EAL_Es *es2 = CRYPT_EAL_EsNew();
ASSERT_TRUE(es2 != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es2, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)mode, strlen(mode)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es2, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, sizeof(bool)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es2) == CRYPT_SUCCESS);
CRYPT_EAL_EsPara esPara2 = {isPhysical, (uint32_t)minEntropy2, es2, (CRYPT_EAL_EntropyGet)ErrorGetEsEntropy};
CRYPT_EAL_Es *es3 = CRYPT_EAL_EsNew();
ASSERT_TRUE(es3 != NULL);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es3, CRYPT_ENTROPY_SET_CF, (void *)(intptr_t)mode, strlen(mode)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsCtrl(es3, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, sizeof(bool)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_EsInit(es3) == CRYPT_SUCCESS);
CRYPT_EAL_EsPara esPara3 = {isPhysical, (uint32_t)minEntropy3, es3, (CRYPT_EAL_EntropyGet)ErrorGetEsEntropy};
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, &esPara1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, &esPara2) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_SeedPoolAddEs(pool, &esPara3) == CRYPT_SUCCESS);
EAL_EntropyCtx *ctx = EAL_EntropyNewCtx(pool, true, (uint32_t)minL, (uint32_t)maxL, (uint32_t)entropyL);
ASSERT_TRUE(ctx != NULL);
if (isCreateNullPool && minL != maxL) {
ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SEED_POOL_NO_ENTROPY_OBTAINED);
} else if (isCreateNullPool) {
ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SEED_POOL_NOT_MEET_REQUIREMENT);
} else {
ASSERT_TRUE(EAL_EntropyCollection(pool, ctx) == CRYPT_SUCCESS);
}
EXIT:
CRYPT_EAL_SeedPoolFree(pool);
EAL_EntropyFreeCtx(ctx);
CRYPT_EAL_EsFree(es1);
CRYPT_EAL_EsFree(es2);
CRYPT_EAL_EsFree(es3);
return;
#else
(void)isCreateNullPool;
(void)isPhysical;
(void)minEntropy1;
(void)minEntropy2;
(void)minEntropy3;
(void)minL;
(void)maxL;
(void)entropyL;
SKIP_TEST();
#endif
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/entropy/test_suite_sdv_entropy.c | C | unknown | 66,541 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include "securec.h"
#include "bsl_err.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "crypt_dsa.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_rand.h"
#include "crypt_bn.h"
#include "crypt_util_rand.h"
#include "crypt_eal_md.h"
#include "crypt_eal_cipher.h"
/* END_HEADER */
#define SUCCESS 0
#define ERROR (-1)
typedef struct {
uint8_t *key;
uint8_t *iv;
uint8_t *aad;
uint8_t *pt;
uint8_t *ct;
uint8_t *tag;
uint32_t keyLen;
uint32_t ivLen;
uint32_t aadLen;
uint32_t ptLen;
uint32_t ctLen;
uint32_t tagLen;
int algId;
} ThreadParameter;
void MultiThreadTest(void *arg)
{
ThreadParameter *threadParameter = (ThreadParameter *)arg;
uint32_t outLen = threadParameter->ctLen;
uint32_t tagLen = threadParameter->tagLen;
uint8_t out[threadParameter->ctLen];
uint8_t tag[threadParameter->tagLen];
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(threadParameter->algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, threadParameter->key, threadParameter->keyLen, threadParameter->iv,
threadParameter->ivLen, true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, threadParameter->aad, threadParameter->aadLen) ==
CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, threadParameter->pt, threadParameter->ptLen, (uint8_t *)out, &outLen) ==
CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)tag, tagLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("Compare Ct", out, threadParameter->ctLen, threadParameter->ct, threadParameter->ctLen);
ASSERT_COMPARE("Compare Enc Tag", tag, tagLen, threadParameter->tag, threadParameter->tagLen);
CRYPT_EAL_CipherDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, threadParameter->key, threadParameter->keyLen, threadParameter->iv,
threadParameter->ivLen, false) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, threadParameter->aad, threadParameter->aadLen) ==
CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, threadParameter->ct, threadParameter->ctLen, (uint8_t *)out, &outLen) ==
CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)tag, tagLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("Compare Pt", out, threadParameter->ptLen, threadParameter->pt, threadParameter->ptLen);
ASSERT_COMPARE("Compare Dec Tag", tag, tagLen, threadParameter->tag, threadParameter->tagLen);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* BEGIN_CASE */
void SDV_CRYPTO_GCM_API_TC001(int id, int keyLen, int ivLen)
{
uint8_t key[32] = { 0 }; // The maximum length of the key is 32 bytes.
uint8_t iv[256] = { 0 }; // The maximum length of the iv is 256 bytes.
TestMemInit();
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(id);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, (uint8_t *)key, keyLen, (uint8_t *)iv, ivLen, true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, (uint8_t *)iv, 0) != CRYPT_SUCCESS);
// Repeat the settings.
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, (uint8_t *)iv, ivLen) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_GCM_API_TC002(int id, int keyLen)
{
CRYPT_EAL_CipherCtx *ctx = NULL;
uint8_t key[32] = { 0 }; // The maximum length of the key is 32 bytes.
uint8_t iv[256] = { 0 }; // The maximum length of the iv is 256 bytes.
TestMemInit();
ASSERT_TRUE(CRYPT_EAL_CipherNewCtx(99) == NULL); // 99 Indicates an invalid algorithm ID.
ctx = CRYPT_EAL_CipherNewCtx(id);
ASSERT_TRUE(ctx != NULL);
// 256 indicates the IV length.
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, NULL, keyLen, (uint8_t *)iv, 256, true) != CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, (uint8_t *)key, 0, (uint8_t *)iv, 256, true) !=
CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, (uint8_t *)key, keyLen, NULL, 256, true) !=
CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, (uint8_t *)key, keyLen, (uint8_t *)iv, 0, true) != CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(NULL, (uint8_t *)iv, 256) != CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, NULL, 256) != CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(NULL, (uint8_t *)iv, 0) != CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_GCM_API_TC003(int id, int keyLen)
{
TestMemInit();
uint8_t key[32] = { 0 }; // The maximum length of the key is 32 bytes.
uint8_t iv[256] = { 0 }; // The maximum length of the iv is 256 bytes.
uint8_t data[256];
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(id);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, (uint8_t *)key, keyLen, iv, sizeof(iv), true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, data, sizeof(data)) != CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_GCM_API_TC004(int id, int keyLen)
{
TestMemInit();
uint8_t key[32] = { 0 }; // The maximum length of the key is 32 bytes.
uint8_t iv[13] = { 0 };
uint8_t data[256] = { 0 };
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(id);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, (uint8_t *)key, keyLen, iv, sizeof(iv), true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, data, sizeof(data)) != CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_GCM_API_TC005(int id, int keyLen)
{
TestMemInit();
uint8_t key[32] = { 0 }; // The maximum length of the key is 32 bytes.
uint8_t iv[13] = { 0 };
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(id);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, (uint8_t *)key, keyLen, iv, sizeof(iv), true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, NULL, 0) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, NULL, 0), CRYPT_EAL_ERR_STATE);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_GCM_API_TC006(int id, int keyLen)
{
TestMemInit();
uint8_t key[32] = { 0 }; // The maximum length of the key is 32 bytes.
uint8_t iv[13] = { 0 };
uint8_t data[256] = { 0 };
uint8_t out[256] = { 0 };
uint32_t outLen = sizeof(out);
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(id);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, (uint8_t *)key, keyLen, iv, sizeof(iv), true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, data, sizeof(data), out, &outLen) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_GCM_FUNC_TC001
* @title Test on the same address in plaintext and ciphertext
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the Ctrl interface, ctx is not NULL, and set tag len. Expected result 3 is obtained.
* 4.Call the Ctrl interface, ctx is not NULL, and set aad. Expected result 4 is obtained.
* 5.Call the Update interface, ctx is not NULL, and encrypt data. Expected result 5 is obtained.
* 6.Compare the ciphertext. Expected result 6 is obtained.
* 7.Compare the tag. Expected result 7 is obtained.
* 8.Call the Deinit interface and Call the Init interface. Expected result 8 is obtained.
* 9.Call the Ctrl interface set tag len. Expected result 9 is obtained.
* 10.Call the Ctrl interface set aad. Expected result 10 is obtained.
* 11.Call the Update interface to decrypt data. Expected result 11 is obtained.
* 12.Compare the plaintext. Expected result 12 is obtained.
* 13.Compare the tag. Expected result 13 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.Success. Return CRYPT_SUCCESS.
* 3.Success. Return CRYPT_SUCCESS.
* 4.Success. Return CRYPT_SUCCESS.
* 5.Success. Return CRYPT_SUCCESS.
* 6.Consistent with expected vector.
* 7.Consistent with expected vector.
* 8.Success, Return CRYPT_SUCCESS
* 9.Success, Return CRYPT_SUCCESS
* 10.Success, Return CRYPT_SUCCESS
* 11.Success, Return CRYPT_SUCCESS
* 12.Consistent with expected vector.
* 13.Consistent with expected vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_GCM_FUNC_TC001(int algId, Hex *key, Hex *iv, Hex *aad, Hex *pt, Hex *ct, Hex *tag)
{
TestMemInit();
CRYPT_EAL_CipherCtx *ctx = NULL;
uint8_t *outTag = NULL;
uint8_t *out = NULL;
uint32_t tagLen = tag->len;
uint32_t outLen = ct->len;
out = (uint8_t *)malloc(outLen * sizeof(uint8_t));
ASSERT_TRUE(out != NULL);
outTag = (uint8_t *)malloc(sizeof(uint8_t) * tagLen);
ASSERT_TRUE(outTag != NULL);
ASSERT_TRUE(memcpy_s(out, outLen, pt->x, pt->len) == EOK);
ctx = CRYPT_EAL_CipherNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, out, pt->len, (uint8_t *)out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("Compare Ct", out, ct->len, ct->x, ct->len);
ASSERT_COMPARE("Compare Enc Tag", outTag, tagLen, tag->x, tag->len);
CRYPT_EAL_CipherDeinit(ctx);
ASSERT_TRUE(memcpy_s(out, outLen, ct->x, ct->len) == EOK);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, false) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad->x, aad->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, out, ct->len, (uint8_t *)out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, (uint8_t *)outTag, tagLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("Compare Pt", out, pt->len, pt->x, pt->len);
ASSERT_COMPARE("Compare Dec Tag", outTag, tagLen, tag->x, tag->len);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
free(out);
free(outTag);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_GCM_FUNC_TC002
* @title Multi-thread Test
* @precon Registering memory-related functions.
* @brief
* 1.Start three threads. Expected result 1 is obtained.
* 2.Call the eal interface in the thread for encryption. Expected result 2 is obtained.
* 3.Call the eal interface in the thread for decryption. Expected result 2 is obtained.
* @expect
* 1.Success.
* 2.The encryption is successful. The ciphertext and tag are the same as the vector.
* 3.The decryption is successful. The plaintext and tag are consistent with the vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_GCM_FUNC_TC002(int algId, Hex *key, Hex *iv, Hex *aad, Hex *pt, Hex *ct, Hex *tag)
{
int ret;
TestMemInit();
const uint32_t threadNum = 3; // Number of threads.
pthread_t thrd[threadNum];
ThreadParameter arg[3] = {
// 3 threads.
{.key = key->x, .iv = iv->x, .aad = aad->x, .pt = pt->x, .ct = ct->x, .tag = tag->x,
.keyLen = key->len, .ivLen = iv->len, .aadLen = aad->len,
.ptLen = pt->len, .ctLen = ct->len, .tagLen = tag->len,
.algId = algId},
{.key = key->x, .iv = iv->x, .aad = aad->x, .pt = pt->x, .ct = ct->x, .tag = tag->x,
.keyLen = key->len, .ivLen = iv->len, .aadLen = aad->len,
.ptLen = pt->len, .ctLen = ct->len, .tagLen = tag->len,
.algId = algId},
{.key = key->x, .iv = iv->x, .aad = aad->x, .pt = pt->x, .ct = ct->x, .tag = tag->x,
.keyLen = key->len, .ivLen = iv->len, .aadLen = aad->len,
.ptLen = pt->len, .ctLen = ct->len, .tagLen = tag->len,
.algId = algId},
};
for (uint32_t i = 0; i < threadNum; i++) {
ret = pthread_create(&thrd[i], NULL, (void *)MultiThreadTest, &arg[i]);
ASSERT_TRUE(ret == 0);
}
for (uint32_t i = 0; i < threadNum; i++) {
pthread_join(thrd[i], NULL);
}
EXIT:
return;
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/gcm/test_suite_sdv_gcm.c | C | unknown | 13,645 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <limits.h>
#include <pthread.h>
#include "securec.h"
#include "stub_replace.h"
#include "crypt_algid.h"
#include "crypt_errno.h"
#include "crypt_eal_mac.h"
#include "bsl_sal.h"
#include "eal_mac_local.h"
/* END_HEADER */
#define GMAC_DEFAULT_TAGLEN 16
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_GMAC_FUNC_TC001(int id, Hex *key, Hex *iv, Hex *msg, Hex *mac)
{
uint32_t outLen = mac->len;
uint8_t *output = NULL;
CRYPT_EAL_MacCtx *gmacCtx = NULL;
ASSERT_TRUE((output = malloc(outLen)) != NULL);
TestMemInit();
ASSERT_TRUE((gmacCtx = CRYPT_EAL_MacNewCtx(id)) != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(gmacCtx, key->x, key->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacCtrl(gmacCtx, CRYPT_CTRL_SET_IV, iv->x, iv->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacCtrl(gmacCtx, CRYPT_CTRL_SET_TAGLEN, &outLen, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(gmacCtx, msg->x, msg->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(gmacCtx, output, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(output, mac->x, outLen) == 0);
EXIT:
free(output);
CRYPT_EAL_MacDeinit(gmacCtx);
CRYPT_EAL_MacFreeCtx(gmacCtx);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_GMAC_API_TC001(Hex *key, Hex *iv)
{
TestMemInit();
CRYPT_EAL_MacCtx *gmacCtx = CRYPT_EAL_MacNewCtx(CRYPT_MAC_GMAC_AES128);
ASSERT_TRUE(gmacCtx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(gmacCtx, key->x, key->len) == CRYPT_SUCCESS);
// ctrl abnormal parameter
ASSERT_TRUE(CRYPT_EAL_MacCtrl(NULL, CRYPT_CTRL_SET_IV, iv->x, iv->len) == CRYPT_NULL_INPUT);
// ctrl abnormal parameter
ASSERT_TRUE(
CRYPT_EAL_MacCtrl(gmacCtx, CRYPT_CTRL_SET_AAD, iv->x, iv->len) == CRYPT_EAL_MAC_CTRL_TYPE_ERROR);
// ctrl abnormal parameter
ASSERT_TRUE(CRYPT_EAL_MacCtrl(gmacCtx, CRYPT_CTRL_SET_IV, NULL, iv->len) == CRYPT_NULL_INPUT);
// ctrl abnormal parameter
ASSERT_TRUE(CRYPT_EAL_MacCtrl(gmacCtx, CRYPT_CTRL_SET_IV, iv->x, 0) == CRYPT_NULL_INPUT);
CRYPT_EAL_MacDeinit(gmacCtx);
ASSERT_TRUE(CRYPT_EAL_MacCtrl(gmacCtx, CRYPT_CTRL_SET_IV, iv->x, iv->len) == CRYPT_EAL_ERR_STATE);
EXIT:
CRYPT_EAL_MacDeinit(gmacCtx);
CRYPT_EAL_MacFreeCtx(gmacCtx);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_GMAC_API_TC002(Hex *key, Hex *iv, Hex *msg, Hex *mac)
{
TestMemInit();
unsigned char output[GMAC_DEFAULT_TAGLEN];
uint32_t outLen = GMAC_DEFAULT_TAGLEN;
CRYPT_EAL_MacCtx *gmacCtx = CRYPT_EAL_MacNewCtx(CRYPT_MAC_GMAC_AES128);
ASSERT_TRUE(gmacCtx != NULL);
// GMAC init abnormal parameter
ASSERT_TRUE(CRYPT_EAL_MacInit(gmacCtx, key->x, 0) == CRYPT_AES_ERR_KEYLEN);
ASSERT_TRUE(CRYPT_EAL_MacInit(gmacCtx, key->x, key->len) == CRYPT_SUCCESS);
// GMAC Ctrl abnormal parameter
ASSERT_TRUE(CRYPT_EAL_MacCtrl(gmacCtx, CRYPT_CTRL_SET_IV, iv->x, 0) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacCtrl(gmacCtx, CRYPT_CTRL_SET_IV, iv->x, iv->len) == CRYPT_SUCCESS);
// GMAC update abnormal parameter
ASSERT_TRUE(CRYPT_EAL_MacUpdate(gmacCtx, NULL, msg->len) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(gmacCtx, msg->x, msg->len) == CRYPT_SUCCESS);
// GMAC final abnormal parameter
outLen = 0;
ASSERT_TRUE(CRYPT_EAL_MacFinal(gmacCtx, output, &outLen) == CRYPT_MODES_TAGLEN_ERROR);
outLen = GMAC_DEFAULT_TAGLEN;
ASSERT_TRUE(CRYPT_EAL_MacFinal(gmacCtx, output, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(output, mac->x, outLen) == 0);
EXIT:
CRYPT_EAL_MacDeinit(gmacCtx);
CRYPT_EAL_MacFreeCtx(gmacCtx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_GMAC_STATE_FUNC_TC001
* @title Gmac state test
* @precon nan
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_GMAC_STATE_FUNC_TC001(int algId, Hex *key, Hex *iv, Hex *msg, Hex *mac)
{
uint32_t outLen = mac->len;
unsigned char output[outLen];
CRYPT_EAL_MacCtx *gmacCtx = NULL;
TestMemInit();
// ctrl, update, final and deinit after new.
ASSERT_TRUE((gmacCtx = CRYPT_EAL_MacNewCtx(algId)) != NULL);
ASSERT_EQ(CRYPT_EAL_MacCtrl(gmacCtx, CRYPT_CTRL_SET_IV, iv->x, iv->len), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_MacUpdate(gmacCtx, msg->x, msg->len), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_MacFinal(gmacCtx, output, &outLen), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_MacReinit(gmacCtx), CRYPT_EAL_ERR_STATE);
CRYPT_EAL_MacDeinit(gmacCtx);
// init after new, repeat the init
ASSERT_EQ(CRYPT_EAL_MacInit(gmacCtx, key->x, key->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacInit(gmacCtx, key->x, key->len), CRYPT_SUCCESS);
// reinit after init
ASSERT_EQ(CRYPT_EAL_MacReinit(gmacCtx), CRYPT_EAL_ALG_NOT_SUPPORT);
// final after init
ASSERT_EQ(CRYPT_EAL_MacFinal(gmacCtx, output, &outLen), CRYPT_MODES_TAGLEN_ERROR);
// update after init, repeat the update
ASSERT_EQ(CRYPT_EAL_MacUpdate(gmacCtx, msg->x, msg->len), CRYPT_SUCCESS);
if (msg->len == 0) {
ASSERT_EQ(CRYPT_EAL_MacUpdate(gmacCtx, msg->x, msg->len), CRYPT_SUCCESS);
} else {
ASSERT_EQ(CRYPT_EAL_MacUpdate(gmacCtx, msg->x, msg->len), CRYPT_MODES_AAD_REPEAT_SET_ERROR);
}
// ctrl after update
ASSERT_EQ(CRYPT_EAL_MacCtrl(gmacCtx, CRYPT_CTRL_SET_IV, iv->x, iv->len), CRYPT_EAL_ERR_STATE);
// final after update
ASSERT_EQ(CRYPT_EAL_MacFinal(gmacCtx, output, &outLen), CRYPT_MODES_TAGLEN_ERROR);
// init
ASSERT_EQ(CRYPT_EAL_MacInit(gmacCtx, key->x, key->len), CRYPT_SUCCESS);
// ctrl after init, repeat to taglen
ASSERT_EQ(CRYPT_EAL_MacCtrl(gmacCtx, CRYPT_CTRL_SET_TAGLEN, &outLen, sizeof(uint32_t)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacCtrl(gmacCtx, CRYPT_CTRL_SET_TAGLEN, &outLen, sizeof(uint32_t)), CRYPT_SUCCESS);
// final after ctrl,repeat the final
ASSERT_EQ(CRYPT_EAL_MacFinal(gmacCtx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacFinal(gmacCtx, output, &outLen), CRYPT_EAL_ERR_STATE);
// ctrl after final
ASSERT_EQ(CRYPT_EAL_MacCtrl(gmacCtx, CRYPT_CTRL_SET_IV, iv->x, iv->len), CRYPT_EAL_ERR_STATE);
// update after final
ASSERT_EQ(CRYPT_EAL_MacUpdate(gmacCtx, msg->x, msg->len), CRYPT_EAL_ERR_STATE);
EXIT:
CRYPT_EAL_MacDeinit(gmacCtx);
CRYPT_EAL_MacFreeCtx(gmacCtx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_GMAC_SAMEADDR_FUNC_TC001
* @title GMAC in/out same address test
* @precon nan
* @brief
* 1.Use the EAL-layer interface to perform GMAC calculation. The input and output addresses are the same.
* Expected result 1 is displayed.
* @expect
* 1. success
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_GMAC_SAMEADDR_FUNC_TC001(int algId, Hex *key, Hex *iv, Hex *data, Hex *mac)
{
uint32_t outLen = data->len > mac->len ? data->len : mac->len;
uint32_t tagLen = mac->len;
uint8_t *out = NULL;
CRYPT_EAL_MacCtx *ctx = NULL;
ASSERT_TRUE((out = malloc(outLen)) != NULL);
ASSERT_EQ(memcpy_s(out, outLen, data->x, data->len), 0);
ASSERT_TRUE((ctx = CRYPT_EAL_MacNewCtx(algId)) != NULL);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key->x, key->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_IV, iv->x, iv->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(uint32_t)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, out, data->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, out, &tagLen), CRYPT_SUCCESS);
ASSERT_COMPARE("gmac result cmp", out, tagLen, mac->x, mac->len);
EXIT:
free(out);
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_GMAC_ADDR_NOT_ALIGN_FUNC_TC001
* @title GMAC non-address alignment test
* @precon nan
* @brief
* 1.Use the EAL layer interface to perform GMAC calculation. All buffer addresses are not aligned.
* Expected result 1 is obtained.
* @expect
* 1.success.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_GMAC_ADDR_NOT_ALIGN_FUNC_TC001(int algId, Hex *key, Hex *iv, Hex *data, Hex *mac)
{
uint32_t outLen = data->len > mac->len ? data->len : mac->len;
uint8_t *out = NULL;
uint32_t tagLen = mac->len;
CRYPT_EAL_MacCtx *ctx = NULL;
uint8_t *keyTmp = NULL;
uint8_t *ivTmp = NULL;
uint8_t *dataTmp = NULL;
ASSERT_TRUE((out = malloc(outLen)) != NULL);
ASSERT_TRUE((keyTmp = malloc(key->len + 1)) != NULL);
ASSERT_TRUE((ivTmp = malloc(iv->len + 1)) != NULL);
ASSERT_TRUE((dataTmp = malloc(data->len + 1)) != NULL);
uint8_t *pKey = keyTmp + 1;
uint8_t *pIv = ivTmp + 1;
uint8_t *pData = dataTmp + 1;
ASSERT_TRUE(memcpy_s(pKey, key->len, key->x, key->len) == 0);
ASSERT_TRUE(memcpy_s(pIv, iv->len, iv->x, iv->len) == 0);
ASSERT_TRUE(memcpy_s(pData, data->len, data->x, data->len) == 0);
TestMemInit();
ASSERT_TRUE((ctx = CRYPT_EAL_MacNewCtx(algId)) != NULL);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, pKey, key->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_IV, pIv, iv->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(uint32_t)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, pData, data->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, out, &tagLen), CRYPT_SUCCESS);
ASSERT_COMPARE("mac result cmp", out, tagLen, mac->x, mac->len);
EXIT:
free(out);
free(keyTmp);
free(ivTmp);
free(dataTmp);
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/gmac/test_suite_sdv_eal_gmac.c | C | unknown | 10,016 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "securec.h"
#include "crypt_eal_kdf.h"
#include "crypt_errno.h"
#include "bsl_sal.h"
#include "bsl_params.h"
#include "crypt_params_key.h"
/* END_HEADER */
#define DATA_LEN (64)
static uint32_t GetMaxKeyLen(int algId)
{
switch (algId) {
case CRYPT_MAC_HMAC_SHA1:
return 5100;
case CRYPT_MAC_HMAC_SHA224:
return 7140;
case CRYPT_MAC_HMAC_SHA256:
return 8160;
case CRYPT_MAC_HMAC_SHA384:
return 12240;
case CRYPT_MAC_HMAC_SHA512:
return 16320;
default:
return 0;
}
}
/**
* @test SDV_CRYPT_EAL_KDF_HKDF_API_TC001
* @title hkdf api test.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_KDF_HKDF_API_TC001(int algId)
{
TestMemInit();
uint32_t keyLen = DATA_LEN;
uint8_t key[DATA_LEN];
uint32_t saltLen = DATA_LEN;
uint8_t salt[DATA_LEN];
uint32_t infoLen = DATA_LEN;
uint8_t info[DATA_LEN];
uint32_t outLen = DATA_LEN;
uint8_t out[DATA_LEN];
CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
ASSERT_TRUE(ctx != NULL);
CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_FULL;
BSL_Param params[7] = {{0}, {0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&algId, sizeof(algId)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_MODE, BSL_PARAM_TYPE_UINT32,
&mode, sizeof(mode)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
key, keyLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
salt, saltLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_INFO, BSL_PARAM_TYPE_OCTETS,
info, infoLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[5], CRYPT_PARAM_KDF_PRK, BSL_PARAM_TYPE_OCTETS,
key, keyLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_INFO, BSL_PARAM_TYPE_OCTETS,
NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[5], CRYPT_PARAM_KDF_PRK, BSL_PARAM_TYPE_OCTETS,
NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, NULL, outLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, 0), CRYPT_NULL_INPUT);
outLen = GetMaxKeyLen(algId) + 1;
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_HKDF_DKLEN_OVERFLOW);
outLen = DATA_LEN;
CRYPT_MAC_AlgId macAlgIdFailed = CRYPT_MAC_MAX;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&macAlgIdFailed, sizeof(macAlgIdFailed)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_HKDF_PARAM_ERROR);
ASSERT_EQ(CRYPT_EAL_KdfDeInitCtx(ctx), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_KdfFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_KDF_HKDF_FUN_TC001
* @title Perform the vector test to check whether the calculation result is consistent with the standard output.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_KdfCTX functions get output, expected result 1.
* 2.Compare the result to the expected value, expected result 2.
* @expect
* 1.Successful.
* 2.The results are as expected.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_KDF_HKDF_FUN_TC001(int algId, Hex *key, Hex *salt, Hex *info, Hex *result)
{
if (IsHmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
uint32_t outLen = result->len;
uint8_t *out = malloc(outLen * sizeof(uint8_t));
ASSERT_TRUE(out != NULL);
CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
ASSERT_TRUE(ctx != NULL);
CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_FULL;
BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&algId, sizeof(algId)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_MODE, BSL_PARAM_TYPE_UINT32,
&mode, sizeof(mode)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
key->x, key->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
salt->x, salt->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_INFO, BSL_PARAM_TYPE_OCTETS,
info->x, info->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
EXIT:
if (out != NULL) {
free(out);
}
CRYPT_EAL_KdfFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_HKDF_DEFAULT_PROVIDER_FUNC_TC001
* @title Default provider testing
* @precon nan
* @brief
* Load the default provider and use the test vector to test its correctness
*/
/* BEGIN_CASE */
void SDV_CRYPTO_HKDF_DEFAULT_PROVIDER_FUNC_TC001(int algId, Hex *key, Hex *salt, Hex *info, Hex *result)
{
if (IsHmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
uint32_t outLen = result->len;
uint8_t *out = malloc(outLen * sizeof(uint8_t));
ASSERT_TRUE(out != NULL);
CRYPT_EAL_KdfCTX *ctx = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_HKDF, "provider=default");
#else
ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
#endif
ASSERT_TRUE(ctx != NULL);
CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_FULL;
BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&algId, sizeof(algId)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_MODE, BSL_PARAM_TYPE_UINT32,
&mode, sizeof(mode)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
key->x, key->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
salt->x, salt->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_INFO, BSL_PARAM_TYPE_OCTETS,
info->x, info->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
EXIT:
if (out != NULL) {
free(out);
}
CRYPT_EAL_KdfFreeCtx(ctx);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_HKDF_BSL_PARAM_MAKER_TC001(int algId, Hex *key, Hex *salt, Hex *info, Hex *result)
{
TestMemInit();
uint32_t outLen = result->len;
uint8_t *out = malloc(outLen * sizeof(uint8_t));
ASSERT_TRUE(out != NULL);
CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
ASSERT_TRUE(ctx != NULL);
CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_FULL;
BSL_ParamMaker *maker = BSL_PARAM_MAKER_New();
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&algId, sizeof(algId)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, CRYPT_PARAM_KDF_MODE, BSL_PARAM_TYPE_UINT32,
&mode, sizeof(mode)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
key->x, key->len), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
salt->x, salt->len), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, CRYPT_PARAM_KDF_INFO, BSL_PARAM_TYPE_OCTETS,
info->x, info->len), BSL_SUCCESS);
BSL_Param *params = BSL_PARAM_MAKER_ToParam(maker);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), BSL_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), BSL_SUCCESS);
ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
EXIT:
if (out != NULL) {
free(out);
}
CRYPT_EAL_KdfFreeCtx(ctx);
BSL_PARAM_MAKER_Free(maker);
BSL_PARAM_Free(params);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_HKDF_BSL_PARAM_MAKER_TC002(int algId, Hex *key, Hex *salt, Hex *info, Hex *result)
{
TestMemInit();
uint32_t outLen = result->len;
uint8_t *out = malloc(outLen * sizeof(uint8_t));
ASSERT_TRUE(out != NULL);
CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_HKDF);
ASSERT_TRUE(ctx != NULL);
CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_FULL;
BSL_ParamMaker *maker = BSL_PARAM_MAKER_New();
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&algId, sizeof(algId)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, CRYPT_PARAM_KDF_MODE, BSL_PARAM_TYPE_UINT32,
&mode, sizeof(mode)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_DeepPushValue(maker, CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
key->x, key->len), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_DeepPushValue(maker, CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
salt->x, salt->len), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_DeepPushValue(maker, CRYPT_PARAM_KDF_INFO, BSL_PARAM_TYPE_OCTETS,
info->x, info->len), BSL_SUCCESS);
BSL_Param *params = BSL_PARAM_MAKER_ToParam(maker);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), BSL_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), BSL_SUCCESS);
ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
EXIT:
if (out != NULL) {
free(out);
}
CRYPT_EAL_KdfFreeCtx(ctx);
BSL_PARAM_MAKER_Free(maker);
BSL_PARAM_Free(params);
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/hkdf/test_suite_sdv_eal_kdf_hkdf.c | C | unknown | 11,441 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include <pthread.h>
#include "securec.h"
#include "crypt_eal_mac.h"
#include "crypt_errno.h"
#include "bsl_sal.h"
#include "crypt_sha1.h"
#include "crypt_sha2.h"
#include "crypt_sha3.h"
#include "crypt_sm3.h"
#include "crypt_md5.h"
#define TEST_FAIL (-1)
#define TEST_SUCCESS (0)
#define DATA_MAX_LEN (65538)
uint32_t GetMacLen(int algId)
{
switch (algId) {
#ifdef HITLS_CRYPTO_MD5
case CRYPT_MAC_HMAC_MD5:
return CRYPT_MD5_DIGESTSIZE;
#endif
#ifdef HITLS_CRYPTO_SHA1
case CRYPT_MAC_HMAC_SHA1:
return CRYPT_SHA1_DIGESTSIZE;
#endif
#ifdef HITLS_CRYPTO_SHA224
case CRYPT_MAC_HMAC_SHA224:
return CRYPT_SHA2_224_DIGESTSIZE;
#endif
#ifdef HITLS_CRYPTO_SHA256
case CRYPT_MAC_HMAC_SHA256:
return CRYPT_SHA2_256_DIGESTSIZE;
#endif
#ifdef HITLS_CRYPTO_SHA384
case CRYPT_MAC_HMAC_SHA384:
return CRYPT_SHA2_384_DIGESTSIZE;
#endif
#ifdef HITLS_CRYPTO_SHA512
case CRYPT_MAC_HMAC_SHA512:
return CRYPT_SHA2_512_DIGESTSIZE;
#endif
#ifdef HITLS_CRYPTO_SM3
case CRYPT_MAC_HMAC_SM3:
return CRYPT_SM3_DIGESTSIZE;
#endif
#ifdef HITLS_CRYPTO_SHA3
case CRYPT_MAC_HMAC_SHA3_224:
return CRYPT_SHA3_224_DIGESTSIZE;
case CRYPT_MAC_HMAC_SHA3_256:
return CRYPT_SHA3_256_DIGESTSIZE;
case CRYPT_MAC_HMAC_SHA3_384:
return CRYPT_SHA3_384_DIGESTSIZE;
case CRYPT_MAC_HMAC_SHA3_512:
return CRYPT_SHA3_512_DIGESTSIZE;
#endif
default:
return 0;
}
}
typedef struct {
uint8_t *data;
uint8_t *mac;
uint8_t *key;
uint32_t dataLen;
uint32_t macLen;
uint32_t keyLen;
int algId;
} ThreadParameter;
void MultiThreadTest(void *arg)
{
ThreadParameter *threadParameter = (ThreadParameter *)arg;
uint32_t outLen = GetMacLen(threadParameter->algId);
uint8_t out[outLen];
CRYPT_EAL_MacCtx *ctx = NULL;
ctx = CRYPT_EAL_MacNewCtx(threadParameter->algId);
ASSERT_TRUE(ctx != NULL);
for (uint32_t i = 0; i < 10; i++) {
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, threadParameter->key, threadParameter->keyLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, threadParameter->data, threadParameter->dataLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, out, &outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("hash result cmp", out, outLen, threadParameter->mac, threadParameter->macLen);
}
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/hmac/test_suite_sdv_eal_mac_hmac.base.c | C | unknown | 3,052 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* INCLUDE_BASE test_suite_sdv_eal_mac_hmac */
/* BEGIN_HEADER */
/* END_HEADER */
#define HMAC_MAX_BUFF_LEN (64 + 1) // CRYPT_SHA2_512_DIGESTSIZE + 1
/**
* @test SDV_CRYPT_EAL_HMAC_API_TC001
* @title Create hmac context test.
* @precon nan
* @brief
* 1.Create context with invalid id, expected result 1.
* 2.Create context using CRYPT_MAC_AlgId, expected result 2.
* @expect
* 1.The result is NULL.
* 2.Create successful.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HMAC_API_TC001(void)
{
TestMemInit();
CRYPT_MAC_AlgId testIds[] = { CRYPT_MAC_HMAC_MD5, CRYPT_MAC_HMAC_SHA1, CRYPT_MAC_HMAC_SHA224,
CRYPT_MAC_HMAC_SHA256, CRYPT_MAC_HMAC_SHA384, CRYPT_MAC_HMAC_SHA512, CRYPT_MAC_HMAC_SM3,
CRYPT_MAC_HMAC_SHA3_224, CRYPT_MAC_HMAC_SHA3_256, CRYPT_MAC_HMAC_SHA3_384, CRYPT_MAC_HMAC_SHA3_512 };
CRYPT_EAL_MacCtx *ctx = NULL;
for (int i = 0; i < (int)(sizeof(testIds) / sizeof(CRYPT_MAC_AlgId)); i++) {
ctx = CRYPT_EAL_MacNewCtx(testIds[i]);
ASSERT_TRUE(ctx != NULL);
CRYPT_EAL_MacFreeCtx(ctx);
}
ctx = CRYPT_EAL_MacNewCtx(CRYPT_MAC_MAX);
ASSERT_TRUE(ctx == NULL);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_HMAC_API_TC002
* @title hmac init test.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdNewCtx create the CTX, expected result 1.
* 2.Call CRYPT_EAL_MacInit,ctx is NULL or key is NULL but keylen not 0, expected result 2.
* 3.Call CRYPT_EAL_MacInit,key is NULL and keyLen is 0, expected result 3.
* 4.Call CRYPT_EAL_MacInit normally, expected result 4.
* @expect
* 1.Create successful.
* 2.Return CRYPT_NULL_INPUT.
* 3.Successful.
* 4.Successful.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HMAC_API_TC002(int algId)
{
TestMemInit();
const uint32_t len = GetMacLen(algId);
uint8_t key[HMAC_MAX_BUFF_LEN];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MacInit(NULL, key, len), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, NULL, len), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, (uint8_t *)key, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key, len), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_HMAC_API_TC003
* @title hmac init test.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdNewCtx create the CTX, expected result 1.
* 2.Call CRYPT_EAL_MacInit repeatedly, expected result 2.
* 3.Call CRYPT_EAL_MacInit after update, expected result 3.
* 4.Call CRYPT_EAL_MacReinit, expected result 4.
* @expect
* 1.Create successful.
* 2.Successful.
* 3.Successful.
* 4.Successful.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HMAC_API_TC003(int algId)
{
TestMemInit();
const uint32_t len = GetMacLen(algId);
uint32_t macLen = len;
const uint32_t dataLen = HMAC_MAX_BUFF_LEN;
uint8_t key[HMAC_MAX_BUFF_LEN];
uint8_t mac[HMAC_MAX_BUFF_LEN];
uint8_t data[HMAC_MAX_BUFF_LEN];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key, len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key, len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data, dataLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key, len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key, len), CRYPT_SUCCESS);
CRYPT_EAL_MacDeinit(ctx);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key, len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacReinit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key, len), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_HMAC_API_TC004
* @title hmac init test.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdNewCtx create the CTX, expected result 1.
* 2.Call CRYPT_EAL_MacUpdate before init, expected result 2.
* 3.Call CRYPT_EAL_MacUpdate,ctx or data is NULL, expected result 3.
* 4.Call CRYPT_EAL_MacUpdate,dataLen is 0, expected result 4.
* 5.Call CRYPT_EAL_MacUpdate normally, expected result 5.
* @expect
* 1.Create successful.
* 2.Return CRYPT_EAL_ERR_STATE.
* 3.Return CRYPT_NULL_INPUT.
* 4.Successful.
* 5.Successful.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HMAC_API_TC004(int algId)
{
TestMemInit();
const uint32_t len = GetMacLen(algId);
const uint32_t dataLen = HMAC_MAX_BUFF_LEN;
uint8_t key[HMAC_MAX_BUFF_LEN];
uint8_t data[HMAC_MAX_BUFF_LEN];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data, dataLen), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key, len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacUpdate(NULL, data, dataLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, NULL, dataLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data, dataLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_HMAC_API_TC005
* @title hmac final test.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdNewCtx create the CTX, expected result 1.
* 2.Call CRYPT_EAL_MacFinal before init, expected result 2.
* 3.Call CRYPT_EAL_MacFinal,ctx or mac is NULL, expected result 3.
* 4.Call CRYPT_EAL_MacFinal,macLen not enough, expected result 4.
* 5.Call CRYPT_EAL_MacFinal normally, expected result 5.
* @expect
* 1.Create successful.
* 2.Return CRYPT_EAL_ERR_STATE.
* 3.Return CRYPT_NULL_INPUT.
* 4.Return CRYPT_HMAC_OUT_BUFF_LEN_NOT_ENOUGH.
* 5.Successful.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HMAC_API_TC005(int algId)
{
TestMemInit();
const uint32_t len = GetMacLen(algId);
uint32_t macLen = len;
uint8_t key[HMAC_MAX_BUFF_LEN];
uint8_t mac[HMAC_MAX_BUFF_LEN];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key, len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacFinal(NULL, mac, &macLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, NULL, &macLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, NULL), CRYPT_NULL_INPUT);
macLen = GetMacLen(algId) - 1;
ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_HMAC_OUT_BUFF_LEN_NOT_ENOUGH);
macLen = GetMacLen(algId) + 1;
ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_EAL_ERR_STATE);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_HMAC_API_TC006
* @title get mac len test.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdNewCtx create the ctx and init, expected result 1.
* 2.Call CRYPT_EAL_GetMacLen,the input parameter is null, expected result 2.
* 3.Call CRYPT_EAL_GetMacLen after init,update final and deinit, expected result 3.
* @expect
* 1.Create successful.
* 2.Return 0.
* 3.Successful.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HMAC_API_TC006(int algId)
{
TestMemInit();
const uint32_t len = GetMacLen(algId);
uint8_t key[HMAC_MAX_BUFF_LEN];
const uint32_t dataLen = HMAC_MAX_BUFF_LEN;
uint8_t data[HMAC_MAX_BUFF_LEN];
uint32_t macLen = len;
uint8_t mac[HMAC_MAX_BUFF_LEN];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_EQ(CRYPT_EAL_GetMacLen(NULL), 0);
ASSERT_EQ(CRYPT_EAL_GetMacLen(ctx), GetMacLen(algId));
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key, len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_GetMacLen(ctx), GetMacLen(algId));
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data, dataLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_GetMacLen(ctx), GetMacLen(algId));
ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_GetMacLen(ctx), GetMacLen(algId));
CRYPT_EAL_MacDeinit(ctx);
ASSERT_EQ(CRYPT_EAL_GetMacLen(ctx), GetMacLen(algId));
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_HMAC_API_TC007
* @title reinit ctx test.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdNewCtx create the ctx and init, expected result 1.
* 2.Call CRYPT_EAL_MacReinit,the input parameter is null, expected result 2.
* 3.Call CRYPT_EAL_MacReinit after init,update final, expected result 3.
* 3.Call CRYPT_EAL_MacReinit after deinit, expected result 4.
* @expect
* 1.Create successful.
* 2.Return 0.
* 3.Successful.
* 4.Return CRYPT_EAL_ERR_STATE.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HMAC_API_TC007(int algId)
{
TestMemInit();
const uint32_t len = GetMacLen(algId);
uint32_t macLen = len;
const uint32_t dataLen = HMAC_MAX_BUFF_LEN;
uint8_t key[HMAC_MAX_BUFF_LEN];
uint8_t mac[HMAC_MAX_BUFF_LEN];
uint8_t data[HMAC_MAX_BUFF_LEN];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MacReinit(NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MacReinit(ctx), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key, len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacReinit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data, dataLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacReinit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacReinit(ctx), CRYPT_SUCCESS);
CRYPT_EAL_MacDeinit(ctx);
ASSERT_EQ(CRYPT_EAL_MacReinit(ctx), CRYPT_EAL_ERR_STATE);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_HMAC_FUN_TC001
* @title Perform the vector test to check whether the calculation result is consistent with the standard output.
* @precon nan
* @brief
* 1.Calculate the hmac of each group of data, expected result 1.
* 2.Compare the result to the expected value, expected result 2.
* @expect
* 1.Hmac calculation succeeded.
* 2.The results are as expected.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HMAC_FUN_TC001(int algId, Hex *key, Hex *data, Hex *vecMac)
{
if (IsHmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
uint32_t macLen = GetMacLen(algId);
uint8_t *mac = malloc(macLen);
ASSERT_TRUE(mac != NULL);
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key->x, key->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data->x, data->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_SUCCESS);
ASSERT_COMPARE("mac1 result cmp", mac, macLen, vecMac->x, vecMac->len);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
free(mac);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_HMAC_FUN_TC002
* @title Hash calculation for multiple updates,comparison with standard results.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MacNewCtx to create a ctx and initialize, expected result 1.
* 2.Call CRYPT_EAL_MacUpdate to calculate the hash of a data segmentxpected result 2.
* 3.Call CRYPT_EAL_MacUpdate to calculate the next data segmentxpected result 3.
* 4.Call CRYPT_EAL_MacUpdate to calculate the next data segmentxpected result 4.
* 5.Call CRYPT_EAL_MacFinal get the result, expected result 5.
* @expect
* 1.Successful
* 2.Successful
* 3.Successful
* 4.Successful
* 5.The results are as expected.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HMAC_FUN_TC002(int algId, Hex *key, Hex *data1, Hex *data2, Hex *data3, Hex *vecMac)
{
TestMemInit();
uint32_t macLen = GetMacLen(algId);
uint8_t *mac = malloc(macLen);
ASSERT_TRUE(mac != NULL);
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key->x, key->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data1->x, data1->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data2->x, data2->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data3->x, data3->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_SUCCESS);
ASSERT_COMPARE("mac1 result cmp", mac, macLen, vecMac->x, vecMac->len);
CRYPT_EAL_MacDeinit(ctx);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
free(mac);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SHA1_FUN_TC003
* @title Test multi-thread hmac calculation.
* @precon nan
* @brief
* 1.Create two threads and calculate the hmac, expected result 1.
* 2.Compare the result to the expected value, expected result 2.
* @expect
* 1.Hmac calculation succeeded.
* 2.The results are as expected.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HMAC_FUN_TC003(int algId, Hex *key1, Hex *data1, Hex *vecMac1, Hex *key2, Hex *data2, Hex *vecMac2)
{
int ret;
TestMemInit();
const uint32_t threadNum = 2; // 2 threads
pthread_t thrd[2];
ThreadParameter arg[2] = {
{.data = data1->x, .key = key1->x, .mac = vecMac1->x, .dataLen = data1->len,
.keyLen = key1->len, .macLen = vecMac1->len, .algId = algId},
{.data = data2->x, .key = key2->x, .mac = vecMac2->x, .dataLen = data2->len,
.keyLen = key2->len, .macLen = vecMac2->len, .algId = algId},
};
for (uint32_t i = 0; i < threadNum; i++) {
ret = pthread_create(&thrd[i], NULL, (void *)MultiThreadTest, &arg[i]);
ASSERT_TRUE(ret == 0);
}
for (uint32_t i = 0; i < threadNum; i++) {
pthread_join(thrd[i], NULL);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_HMAC_DEFAULT_PROVIDER_FUNC_TC001
* @title Default provider testing
* @precon nan
* @brief
* Load the default provider and use the test vector to test its correctness
*/
/* BEGIN_CASE */
void SDV_CRYPT_HMAC_DEFAULT_PROVIDER_FUNC_TC001(int algId, Hex *key, Hex *data, Hex *vecMac)
{
if (IsHmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
CRYPT_EAL_MacCtx *ctx = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx = CRYPT_EAL_ProviderMacNewCtx(NULL, algId, "provider=default");
#else
ctx = CRYPT_EAL_MacNewCtx(algId);
#endif
ASSERT_TRUE(ctx != NULL);
uint32_t macLen = GetMacLen(algId);
uint8_t *mac = BSL_SAL_Calloc(1, macLen);
ASSERT_TRUE(mac != NULL);
ASSERT_EQ(CRYPT_EAL_GetMacLen(ctx), GetMacLen(algId));
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key->x, key->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data->x, data->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_SUCCESS);
ASSERT_COMPARE("mac1 result cmp", mac, macLen, vecMac->x, vecMac->len);
CRYPT_EAL_MacDeinit(ctx);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key->x, key->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacReinit(ctx), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
BSL_SAL_FREE(mac);
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/hmac/test_suite_sdv_eal_mac_hmac.c | C | unknown | 15,751 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "securec.h"
#include "crypt_eal_rand.h"
#include "crypt_eal_hpke.h"
/* END_HEADER */
#define HPKE_KEM_MAX_ENCAPSULATED_KEY_LEN 133
#define HPKE_KEM_MAX_PUBLIC_KEY_LEN 133
#define HPKE_KEM_MAX_PRIVATE_KEY_LEN 66
#define HPKE_HKDF_MAX_EXTRACT_KEY_LEN 64
#define HPKE_KEM_MAX_SHARED_KEY_LEN 64
#define HPKE_AEAD_MAX_KEY_LEN 32
#define HPKE_AEAD_NONCE_LEN 12
#define HPKE_AEAD_TAG_LEN 16
#define HPKE_ERR -1
static int32_t GenerateHpkeCtxSAndCtxR(int mode, CRYPT_HPKE_CipherSuite cipherSuite, Hex *info, Hex *psk, Hex *pskId,
Hex *ikmE, Hex *ikmR, Hex *ikmS, CRYPT_EAL_HpkeCtx **ctxS, CRYPT_EAL_HpkeCtx **ctxR,
CRYPT_EAL_PkeyCtx **pkeyE, CRYPT_EAL_PkeyCtx **pkeyR, CRYPT_EAL_PkeyCtx **pkeyS,
uint8_t *encapsulatedKey, uint32_t *encapsulatedKeyLen)
{
CRYPT_EAL_HpkeCtx *ctxS1 = NULL;
CRYPT_EAL_HpkeCtx *ctxR1 = NULL;
CRYPT_EAL_PkeyCtx *pkeyE1 = NULL;
CRYPT_EAL_PkeyCtx *pkeyR1 = NULL;
CRYPT_EAL_PkeyCtx *pkeyS1 = NULL;
ASSERT_EQ(CRYPT_EAL_HpkeGenerateKeyPair(NULL, NULL, cipherSuite, ikmE->x, ikmE->len, &pkeyE1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_HpkeGenerateKeyPair(NULL, NULL, cipherSuite, ikmR->x, ikmR->len, &pkeyR1), CRYPT_SUCCESS);
if(mode == CRYPT_HPKE_MODE_AUTH || mode ==CRYPT_HPKE_MODE_AUTH_PSK) {
ASSERT_EQ(CRYPT_EAL_HpkeGenerateKeyPair(NULL, NULL, cipherSuite, ikmS->x, ikmS->len, &pkeyS1), CRYPT_SUCCESS);
}
CRYPT_EAL_PkeyPub pubR1;
pubR1.id = CRYPT_EAL_PkeyGetId(pkeyR1);
pubR1.key.eccPub.len = HPKE_KEM_MAX_PUBLIC_KEY_LEN;
uint8_t pubRKeyBuf[HPKE_KEM_MAX_PUBLIC_KEY_LEN];
pubR1.key.eccPub.data = pubRKeyBuf;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkeyR1, &pubR1), CRYPT_SUCCESS);
ctxS1 = CRYPT_EAL_HpkeNewCtx(NULL, NULL, CRYPT_HPKE_SENDER, mode, cipherSuite);
ASSERT_TRUE(ctxS1 != NULL);
if(mode == CRYPT_HPKE_MODE_PSK || mode == CRYPT_HPKE_MODE_AUTH_PSK) {
ASSERT_EQ(CRYPT_EAL_HpkeSetPsk(ctxS1, psk->x, psk->len , pskId->x, pskId->len), CRYPT_SUCCESS);
}
if(mode == CRYPT_HPKE_MODE_AUTH || mode ==CRYPT_HPKE_MODE_AUTH_PSK) {
ASSERT_EQ(CRYPT_EAL_HpkeSetAuthPriKey(ctxS1, pkeyS1),CRYPT_SUCCESS);
}
ASSERT_EQ(CRYPT_EAL_HpkeSetupSender(ctxS1, pkeyE1, info->x, info->len, pubR1.key.eccPub.data,
pubR1.key.eccPub.len, encapsulatedKey, encapsulatedKeyLen), CRYPT_SUCCESS);
ctxR1 = CRYPT_EAL_HpkeNewCtx(NULL, NULL, CRYPT_HPKE_RECIPIENT, mode, cipherSuite);
ASSERT_TRUE(ctxR1 != NULL);
if(mode == CRYPT_HPKE_MODE_PSK || mode == CRYPT_HPKE_MODE_AUTH_PSK){
ASSERT_EQ(CRYPT_EAL_HpkeSetPsk(ctxR1, psk->x, psk->len , pskId->x, pskId->len), CRYPT_SUCCESS);
}
if(mode == CRYPT_HPKE_MODE_AUTH || mode ==CRYPT_HPKE_MODE_AUTH_PSK){
CRYPT_EAL_PkeyPub pubS1;
pubS1.id = CRYPT_EAL_PkeyGetId(pkeyS1);
pubS1.key.eccPub.len = HPKE_KEM_MAX_PUBLIC_KEY_LEN;
uint8_t pubSKeyBuf[HPKE_KEM_MAX_PUBLIC_KEY_LEN];
pubS1.key.eccPub.data = pubSKeyBuf;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkeyS1, &pubS1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_HpkeSetAuthPubKey(ctxR1, pubS1.key.eccPub.data, pubS1.key.eccPub.len),CRYPT_SUCCESS);
}
ASSERT_EQ(CRYPT_EAL_HpkeSetupRecipient(ctxR1, pkeyR1, info->x, info->len, encapsulatedKey, *encapsulatedKeyLen), CRYPT_SUCCESS);
*ctxS = ctxS1;
*ctxR = ctxR1;
*pkeyS = pkeyS1;
*pkeyR = pkeyR1;
*pkeyE = pkeyE1;
return CRYPT_SUCCESS;
EXIT:
CRYPT_EAL_HpkeFreeCtx(ctxS1);
CRYPT_EAL_HpkeFreeCtx(ctxR1);
CRYPT_EAL_PkeyFreeCtx(pkeyS1);
CRYPT_EAL_PkeyFreeCtx(pkeyR1);
CRYPT_EAL_PkeyFreeCtx(pkeyE1);
return HPKE_ERR;
}
/**
* @test SDV_CRYPT_EAL_HPKE_KEM_TC001
* @title hpke key derivation test based on standard vectors.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HPKE_KEM_TC001(int mode, int kemId, int kdfId, int aeadId, Hex *info, Hex *psk, Hex *pskId,
Hex *ikmE, Hex *pkEm, Hex *skEm, Hex *ikmR, Hex *pkRm, Hex *skRm, Hex *ikmS, Hex *pkSm, Hex *skSm,
Hex *enc, Hex *sharedSecret, Hex *keyScheduleContext, Hex *secret, Hex *key, Hex *baseNonce, Hex *exporterSecret)
{
(void)secret;
(void)keyScheduleContext;
(void)key;
(void)baseNonce;
(void)exporterSecret;
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_HPKE_CipherSuite cipherSuite = {kemId, kdfId, aeadId};
CRYPT_EAL_HpkeCtx *ctxS = NULL;
CRYPT_EAL_HpkeCtx *ctxR = NULL;
CRYPT_EAL_PkeyCtx *pkeyS = NULL;
CRYPT_EAL_PkeyCtx *pkeyR = NULL;
CRYPT_EAL_PkeyCtx *pkeyE = NULL;
uint8_t encapsulatedKey[HPKE_KEM_MAX_ENCAPSULATED_KEY_LEN];
uint32_t encapsulatedKeyLen = HPKE_KEM_MAX_ENCAPSULATED_KEY_LEN;
ASSERT_EQ(GenerateHpkeCtxSAndCtxR(mode, cipherSuite, info, psk, pskId, ikmE, ikmR, ikmS, &ctxS, &ctxR, &pkeyE, &pkeyR, &pkeyS,
encapsulatedKey, &encapsulatedKeyLen), CRYPT_SUCCESS);
CRYPT_EAL_PkeyPrv priE;
priE.id = CRYPT_EAL_PkeyGetId(pkeyE);
priE.key.eccPrv.len = HPKE_KEM_MAX_PRIVATE_KEY_LEN;
uint8_t priEKeyBuf[HPKE_KEM_MAX_PRIVATE_KEY_LEN];
priE.key.eccPrv.data = priEKeyBuf;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkeyE, &priE), CRYPT_SUCCESS);
ASSERT_COMPARE("hpke priE cmp", priE.key.eccPrv.data, priE.key.eccPrv.len, skEm->x, skEm->len);
CRYPT_EAL_PkeyPub pubE;
pubE.id = CRYPT_EAL_PkeyGetId(pkeyE);
pubE.key.eccPub.len = HPKE_KEM_MAX_PUBLIC_KEY_LEN;
uint8_t pubEKeyBuf[HPKE_KEM_MAX_PUBLIC_KEY_LEN];
pubE.key.eccPub.data = pubEKeyBuf;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkeyE, &pubE), CRYPT_SUCCESS);
ASSERT_COMPARE("hpke pubE cmp", pubE.key.eccPub.data, pubE.key.eccPub.len, pkEm->x, pkEm->len);
CRYPT_EAL_PkeyPrv priR;
priR.id = CRYPT_EAL_PkeyGetId(pkeyR);
priR.key.eccPrv.len = HPKE_KEM_MAX_PRIVATE_KEY_LEN;
uint8_t priRKeyBuf[HPKE_KEM_MAX_PRIVATE_KEY_LEN];
priR.key.eccPrv.data = priRKeyBuf;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkeyR, &priR), CRYPT_SUCCESS);
ASSERT_COMPARE("hpke priR cmp", priR.key.eccPrv.data, priR.key.eccPrv.len, skRm->x, skRm->len);
CRYPT_EAL_PkeyPub pubR;
pubR.id = CRYPT_EAL_PkeyGetId(pkeyR);
pubR.key.eccPub.len = HPKE_KEM_MAX_PUBLIC_KEY_LEN;
uint8_t pubRKeyBuf[HPKE_KEM_MAX_PUBLIC_KEY_LEN];
pubR.key.eccPub.data = pubRKeyBuf;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkeyR, &pubR), CRYPT_SUCCESS);
ASSERT_COMPARE("hpke pubR cmp", pubR.key.eccPub.data, pubR.key.eccPub.len, pkRm->x, pkRm->len);
if(mode == CRYPT_HPKE_MODE_AUTH || mode ==CRYPT_HPKE_MODE_AUTH_PSK){
CRYPT_EAL_PkeyPrv priS;
priS.id = CRYPT_EAL_PkeyGetId(pkeyS);
priS.key.eccPrv.len = HPKE_KEM_MAX_PRIVATE_KEY_LEN;
uint8_t priSKeyBuf[HPKE_KEM_MAX_PRIVATE_KEY_LEN];
priS.key.eccPrv.data = priSKeyBuf;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkeyS, &priS), CRYPT_SUCCESS);
ASSERT_COMPARE("hpke priS cmp", priS.key.eccPrv.data, priS.key.eccPrv.len, skSm->x, skSm->len);
CRYPT_EAL_PkeyPub pubS;
pubS.id = CRYPT_EAL_PkeyGetId(pkeyS);
pubS.key.eccPub.len = HPKE_KEM_MAX_PUBLIC_KEY_LEN;
uint8_t pubSKeyBuf[HPKE_KEM_MAX_PUBLIC_KEY_LEN];
pubS.key.eccPub.data = pubSKeyBuf;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkeyS, &pubS), CRYPT_SUCCESS);
ASSERT_COMPARE("hpke pubS cmp", pubS.key.eccPub.data, pubS.key.eccPub.len, pkSm->x, pkSm->len);
}
// check enc
ASSERT_COMPARE("hpke enc cmp", encapsulatedKey, encapsulatedKeyLen, enc->x, enc->len);
uint8_t sharedSecretBuf[HPKE_KEM_MAX_SHARED_KEY_LEN] = {0};
uint32_t buffLen = HPKE_KEM_MAX_SHARED_KEY_LEN;
ASSERT_EQ(CRYPT_EAL_HpkeGetSharedSecret(ctxS, sharedSecretBuf, &buffLen), CRYPT_SUCCESS);
ASSERT_COMPARE("hpke S sharedSecret cmp", sharedSecretBuf, buffLen, sharedSecret->x, sharedSecret->len);
(void)memset_s(sharedSecretBuf, 0, HPKE_KEM_MAX_SHARED_KEY_LEN, 0);
buffLen = HPKE_KEM_MAX_SHARED_KEY_LEN;
ASSERT_EQ(CRYPT_EAL_HpkeGetSharedSecret(ctxR, sharedSecretBuf, &buffLen), CRYPT_SUCCESS);
ASSERT_COMPARE("hpke R sharedSecret cmp", sharedSecretBuf, buffLen, sharedSecret->x, sharedSecret->len);
EXIT:
CRYPT_EAL_HpkeFreeCtx(ctxS);
CRYPT_EAL_HpkeFreeCtx(ctxR);
CRYPT_EAL_PkeyFreeCtx(pkeyS);
CRYPT_EAL_PkeyFreeCtx(pkeyR);
CRYPT_EAL_PkeyFreeCtx(pkeyE);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_HPKE_AEAD_TC001
* @title hpke seal and open test based on standard vectors.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HPKE_AEAD_TC001(int mode, int kemId, int kdfId, int aeadId, Hex *info, Hex *psk, Hex *pskId,
Hex *ikmE, Hex *ikmR, Hex *ikmS,int seq, Hex *pt, Hex *aad, Hex *ct)
{
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_HPKE_CipherSuite cipherSuite = {kemId, kdfId, aeadId};
CRYPT_EAL_HpkeCtx *ctxS = NULL;
CRYPT_EAL_HpkeCtx *ctxR = NULL;
CRYPT_EAL_PkeyCtx *pkeyE = NULL;
CRYPT_EAL_PkeyCtx *pkeyR = NULL;
CRYPT_EAL_PkeyCtx *pkeyS = NULL;
uint8_t encapsulatedKey[HPKE_KEM_MAX_ENCAPSULATED_KEY_LEN];
uint32_t encapsulatedKeyLen = HPKE_KEM_MAX_ENCAPSULATED_KEY_LEN;
ASSERT_EQ(GenerateHpkeCtxSAndCtxR(mode, cipherSuite, info, psk, pskId, ikmE, ikmR, ikmS, &ctxS, &ctxR, &pkeyE, &pkeyR, &pkeyS,
encapsulatedKey, &encapsulatedKeyLen), CRYPT_SUCCESS);
uint8_t cipher[200] = { 0 };
uint32_t cipherLen = 200;
ASSERT_EQ(CRYPT_EAL_HpkeSetSeq(ctxS, seq), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_HpkeSeal(ctxS, aad->x, aad->len, pt->x, pt->len, cipher, &cipherLen), CRYPT_SUCCESS);
ASSERT_COMPARE("hpke seal cmp", cipher, cipherLen, ct->x, ct->len);
uint64_t nextSeq;
ASSERT_EQ(CRYPT_EAL_HpkeGetSeq(ctxS, &nextSeq), CRYPT_SUCCESS);
ASSERT_EQ(nextSeq, seq + 1);
uint8_t plain[200] = { 0 };
uint32_t plainLen = 200;
ASSERT_EQ(CRYPT_EAL_HpkeSetSeq(ctxR, seq), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_HpkeOpen(ctxR, aad->x, aad->len, cipher, cipherLen, plain, &plainLen), CRYPT_SUCCESS);
ASSERT_COMPARE("hpke open cmp", plain, plainLen, pt->x, pt->len);
ASSERT_EQ(CRYPT_EAL_HpkeGetSeq(ctxR, &nextSeq), CRYPT_SUCCESS);
ASSERT_EQ(nextSeq, seq + 1);
EXIT:
CRYPT_EAL_HpkeFreeCtx(ctxS);
CRYPT_EAL_HpkeFreeCtx(ctxR);
CRYPT_EAL_PkeyFreeCtx(pkeyE);
CRYPT_EAL_PkeyFreeCtx(pkeyR);
CRYPT_EAL_PkeyFreeCtx(pkeyS);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_HPKE_EXPORT_SECRET_TC001
* @title hpke export secret test based on standard vectors.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HPKE_EXPORT_SECRET_TC001(int mode, int kemId, int kdfId, int aeadId, Hex *info, Hex *psk, Hex *pskId,
Hex *ikmE, Hex *ikmR, Hex *ikmS, Hex *exporterContext, int L, Hex *exportedValue)
{
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_HPKE_CipherSuite cipherSuite = {kemId, kdfId, aeadId};
CRYPT_EAL_HpkeCtx *ctxS = NULL;
CRYPT_EAL_HpkeCtx *ctxR = NULL;
CRYPT_EAL_PkeyCtx *pkeyE = NULL;
CRYPT_EAL_PkeyCtx *pkeyR = NULL;
CRYPT_EAL_PkeyCtx *pkeyS = NULL;
uint8_t encapsulatedKey[HPKE_KEM_MAX_ENCAPSULATED_KEY_LEN];
uint32_t encapsulatedKeyLen = HPKE_KEM_MAX_ENCAPSULATED_KEY_LEN;
ASSERT_EQ(GenerateHpkeCtxSAndCtxR(mode, cipherSuite, info, psk, pskId, ikmE, ikmR, ikmS, &ctxS, &ctxR,
&pkeyE, &pkeyR, &pkeyS, encapsulatedKey, &encapsulatedKeyLen), CRYPT_SUCCESS);
uint8_t exportedValueBuf[HPKE_HKDF_MAX_EXTRACT_KEY_LEN] = {0};
ASSERT_EQ(CRYPT_EAL_HpkeExportSecret(ctxS, exporterContext->x, exporterContext->len, exportedValueBuf, L), CRYPT_SUCCESS);
ASSERT_COMPARE("hpke S exportedValue cmp", exportedValueBuf, exportedValue->len, exportedValue->x, exportedValue->len);
memset(exportedValueBuf, 0, HPKE_HKDF_MAX_EXTRACT_KEY_LEN);
ASSERT_EQ(CRYPT_EAL_HpkeExportSecret(ctxR, exporterContext->x, exporterContext->len, exportedValueBuf, L), CRYPT_SUCCESS);
ASSERT_COMPARE("hpke R exportedValue cmp", exportedValueBuf, exportedValue->len, exportedValue->x, exportedValue->len);
EXIT:
CRYPT_EAL_HpkeFreeCtx(ctxS);
CRYPT_EAL_HpkeFreeCtx(ctxR);
CRYPT_EAL_PkeyFreeCtx(pkeyE);
CRYPT_EAL_PkeyFreeCtx(pkeyR);
CRYPT_EAL_PkeyFreeCtx(pkeyS);
TestRandDeInit();
}
/* END_CASE */
static int32_t HpkeTestSealAndOpen(CRYPT_EAL_HpkeCtx *ctxS, CRYPT_EAL_HpkeCtx *ctxR)
{
uint8_t massage[100];
uint32_t massageLen = 100;
uint8_t plain[100];
uint32_t plainLen = 100;
uint8_t cipherText[116];
uint32_t cipherTextLen = 116;
int count = 100;
while (count--) {
#ifdef HITLS_CRYPTO_PROVIDER
ASSERT_EQ(CRYPT_EAL_RandbytesEx(NULL, massage, massageLen), CRYPT_SUCCESS);
#else
ASSERT_EQ(CRYPT_EAL_Randbytes(massage, massageLen), CRYPT_SUCCESS);
#endif
ASSERT_EQ(CRYPT_EAL_HpkeSeal(ctxS, NULL, 0, massage, massageLen, cipherText, &cipherTextLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_HpkeOpen(ctxR, NULL, 0, cipherText, cipherTextLen, plain, &plainLen), CRYPT_SUCCESS);
ASSERT_COMPARE("hpke Seal Open cmp", massage, massageLen, plain, plainLen);
}
uint64_t seqS;
uint64_t seqR;
ASSERT_EQ(CRYPT_EAL_HpkeGetSeq(ctxS, &seqS), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_HpkeGetSeq(ctxR, &seqR), CRYPT_SUCCESS);
ASSERT_EQ(seqS, seqR);
ASSERT_EQ(seqS, 100);
count = 100;
ASSERT_EQ(CRYPT_EAL_HpkeSetSeq(ctxS, 10000000), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_HpkeSetSeq(ctxR, 10000000), CRYPT_SUCCESS);
while (count--) {
#ifdef HITLS_CRYPTO_PROVIDER
ASSERT_EQ(CRYPT_EAL_RandbytesEx(NULL, massage, massageLen), CRYPT_SUCCESS);
#else
ASSERT_EQ(CRYPT_EAL_Randbytes(massage, massageLen), CRYPT_SUCCESS);
#endif
ASSERT_EQ(CRYPT_EAL_HpkeSeal(ctxS, NULL, 0, massage, massageLen, NULL, &cipherTextLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_HpkeSeal(ctxS, NULL, 0, massage, massageLen, cipherText, &cipherTextLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_HpkeOpen(ctxR, NULL, 0, cipherText, cipherTextLen, NULL, &plainLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_HpkeOpen(ctxR, NULL, 0, cipherText, cipherTextLen, plain, &plainLen), CRYPT_SUCCESS);
ASSERT_COMPARE("hpke Seal Open cmp", massage, massageLen, plain, plainLen);
}
ASSERT_EQ(CRYPT_EAL_HpkeGetSeq(ctxS, &seqS), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_HpkeGetSeq(ctxR, &seqR), CRYPT_SUCCESS);
ASSERT_EQ(seqS, seqR);
ASSERT_EQ(seqS, 10000000 + 100);
return CRYPT_SUCCESS;
EXIT:
return HPKE_ERR;
}
static int32_t HpkeRandomTest(CRYPT_HPKE_Mode mode, CRYPT_HPKE_KEM_AlgId kemId, CRYPT_HPKE_KDF_AlgId kdfId,
CRYPT_HPKE_AEAD_AlgId aeadId)
{
CRYPT_HPKE_CipherSuite cipherSuite = {kemId, kdfId, aeadId};
CRYPT_EAL_HpkeCtx *ctxS = NULL;
CRYPT_EAL_HpkeCtx *ctxR = NULL;
CRYPT_EAL_PkeyCtx *pkeyE = NULL;
CRYPT_EAL_PkeyCtx *pkeyR = NULL;
CRYPT_EAL_PkeyCtx *pkeyS = NULL;
Hex info = { 0 };
info.len = 16;
uint8_t infoData[16] = { 0 };
info.x = infoData;
int32_t ret = HPKE_ERR;
#ifdef HITLS_CRYPTO_PROVIDER
CRYPT_EAL_RandbytesEx(NULL, info.x, info.len);
#else
CRYPT_EAL_Randbytes(info.x, info.len);
#endif
Hex psk = { 0 };
psk.len = 32;
uint8_t pskData[32] = { 0 };
psk.x = pskData;
CRYPT_EAL_Randbytes(psk.x, psk.len);
Hex pskId = { 0 };
pskId.len = 16;
uint8_t pskIdData[16] = { 0 };
pskId.x = pskIdData;
CRYPT_EAL_Randbytes(pskId.x, pskId.len);
// prepare Recipient key
ASSERT_EQ(CRYPT_EAL_HpkeGenerateKeyPair(NULL, NULL, cipherSuite, NULL, 0, &pkeyE), CRYPT_SUCCESS);
// prepare Recipient key
ASSERT_EQ(CRYPT_EAL_HpkeGenerateKeyPair(NULL, NULL, cipherSuite, NULL, 0, &pkeyR), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_HpkeGenerateKeyPair(NULL, NULL, cipherSuite, NULL, 0, &pkeyS), CRYPT_SUCCESS);
CRYPT_EAL_PkeyPub pubR;
pubR.id = CRYPT_EAL_PkeyGetId(pkeyR);
pubR.key.eccPub.len = HPKE_KEM_MAX_PUBLIC_KEY_LEN;
uint8_t pubRKeyBuf[HPKE_KEM_MAX_PUBLIC_KEY_LEN];
pubR.key.eccPub.data = pubRKeyBuf;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkeyR, &pubR), CRYPT_SUCCESS);
// Sender init
ctxS = CRYPT_EAL_HpkeNewCtx(NULL, NULL, CRYPT_HPKE_SENDER, mode, cipherSuite);
ASSERT_TRUE(ctxS != NULL);
uint8_t encapsulatedKey[HPKE_KEM_MAX_ENCAPSULATED_KEY_LEN];
uint32_t encapsulatedKeyLen = HPKE_KEM_MAX_ENCAPSULATED_KEY_LEN;
if(mode == CRYPT_HPKE_MODE_AUTH || mode ==CRYPT_HPKE_MODE_AUTH_PSK){
ASSERT_EQ(CRYPT_EAL_HpkeSetAuthPriKey(ctxS, pkeyS), CRYPT_SUCCESS);
}
if (mode != CRYPT_HPKE_MODE_PSK && mode != CRYPT_HPKE_MODE_AUTH_PSK) {
ASSERT_EQ(CRYPT_EAL_HpkeSetPsk(ctxS, psk.x, psk.len, pskId.x, pskId.len), CRYPT_HPKE_ERR_CALL);
}
if(mode != CRYPT_HPKE_MODE_AUTH && mode != CRYPT_HPKE_MODE_AUTH_PSK){
ASSERT_EQ(CRYPT_EAL_HpkeSetAuthPriKey(ctxS, pkeyS), CRYPT_HPKE_ERR_CALL);
}
if(mode == CRYPT_HPKE_MODE_PSK || mode == CRYPT_HPKE_MODE_AUTH_PSK){
ASSERT_EQ(CRYPT_EAL_HpkeSetPsk(ctxS, psk.x, psk.len, pskId.x, pskId.len), CRYPT_SUCCESS);
}
ASSERT_EQ(CRYPT_EAL_HpkeSetupSender(ctxS, NULL, info.x, info.len, pubR.key.eccPub.data, pubR.key.eccPub.len,
encapsulatedKey, &encapsulatedKeyLen), CRYPT_SUCCESS);
CRYPT_EAL_HpkeFreeCtx(ctxS);
ctxS = CRYPT_EAL_HpkeNewCtx(NULL, NULL, CRYPT_HPKE_SENDER, mode, cipherSuite);
ASSERT_TRUE(ctxS != NULL);
if(mode == CRYPT_HPKE_MODE_PSK || mode == CRYPT_HPKE_MODE_AUTH_PSK){
ASSERT_EQ(CRYPT_EAL_HpkeSetPsk(ctxS, psk.x, psk.len, pskId.x, pskId.len), CRYPT_SUCCESS);
}
if(mode == CRYPT_HPKE_MODE_AUTH || mode ==CRYPT_HPKE_MODE_AUTH_PSK){
ASSERT_EQ(CRYPT_EAL_HpkeSetAuthPriKey(ctxS, pkeyS),CRYPT_SUCCESS);
}
ASSERT_EQ(CRYPT_EAL_HpkeSetupSender(ctxS, pkeyE, info.x, info.len, pubR.key.eccPub.data, pubR.key.eccPub.len,
encapsulatedKey, &encapsulatedKeyLen), CRYPT_SUCCESS);
// Recipient init
ctxR = CRYPT_EAL_HpkeNewCtx(NULL, NULL, CRYPT_HPKE_RECIPIENT, mode, cipherSuite);
ASSERT_TRUE(ctxR != NULL);
if(mode == CRYPT_HPKE_MODE_PSK || mode == CRYPT_HPKE_MODE_AUTH_PSK){
ASSERT_EQ(CRYPT_EAL_HpkeSetPsk(ctxR, psk.x, psk.len, pskId.x, pskId.len), CRYPT_SUCCESS);
}
if(mode == CRYPT_HPKE_MODE_AUTH || mode ==CRYPT_HPKE_MODE_AUTH_PSK){
CRYPT_EAL_PkeyPub pubS;
pubS.id = CRYPT_EAL_PkeyGetId(pkeyS);
pubS.key.eccPub.len = HPKE_KEM_MAX_PUBLIC_KEY_LEN;
uint8_t pubSKeyBuf[HPKE_KEM_MAX_PUBLIC_KEY_LEN];
pubS.key.eccPub.data = pubSKeyBuf;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkeyS, &pubS), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_HpkeSetAuthPubKey(ctxR,pubS.key.eccPub.data, pubS.key.eccPub.len),CRYPT_SUCCESS);
}
ASSERT_EQ(CRYPT_EAL_HpkeSetupRecipient(ctxR, pkeyR, info.x, info.len, encapsulatedKey, encapsulatedKeyLen), CRYPT_SUCCESS);
ASSERT_EQ(HpkeTestSealAndOpen(ctxS, ctxR), CRYPT_SUCCESS);
ret = CRYPT_SUCCESS;
EXIT:
CRYPT_EAL_HpkeFreeCtx(ctxS);
CRYPT_EAL_HpkeFreeCtx(ctxR);
CRYPT_EAL_PkeyFreeCtx(pkeyE);
CRYPT_EAL_PkeyFreeCtx(pkeyS);
CRYPT_EAL_PkeyFreeCtx(pkeyR);
return ret;
}
/**
* @test SDV_CRYPT_EAL_HPKE_TEST_RANDOMLY_TC001
* @title test key derivation, seal and open randomly.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HPKE_TEST_RANDOMLY_TC001(void)
{
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_HPKE_Mode modes[] = {CRYPT_HPKE_MODE_BASE};
CRYPT_HPKE_KEM_AlgId kemIds[] = {CRYPT_KEM_DHKEM_P256_HKDF_SHA256, CRYPT_KEM_DHKEM_P384_HKDF_SHA384,
CRYPT_KEM_DHKEM_P521_HKDF_SHA512, CRYPT_KEM_DHKEM_X25519_HKDF_SHA256};
CRYPT_HPKE_KDF_AlgId kdfIds[] = {CRYPT_KDF_HKDF_SHA256, CRYPT_KDF_HKDF_SHA384, CRYPT_KDF_HKDF_SHA512};
CRYPT_HPKE_AEAD_AlgId aeadIds[] = {CRYPT_AEAD_AES_128_GCM, CRYPT_AEAD_AES_256_GCM, CRYPT_AEAD_CHACHA20_POLY1305};
size_t p;
size_t i;
size_t j;
size_t k;
for (p = 0; p < sizeof(modes) / sizeof(CRYPT_HPKE_Mode); p++) {
for (i = 0; i < sizeof(kemIds) / sizeof(CRYPT_HPKE_KEM_AlgId); i++) {
for (j = 0; j < sizeof(kdfIds) / sizeof(CRYPT_HPKE_KDF_AlgId); j++) {
for (k = 0; k < sizeof(aeadIds) / sizeof(CRYPT_HPKE_AEAD_AlgId); k++) {
ASSERT_EQ(HpkeRandomTest(modes[p], kemIds[i], kdfIds[j], aeadIds[k]), CRYPT_SUCCESS);
}
}
}
}
EXIT:
TestRandDeInit();
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_HPKE_TEST_RANDOMLY_TC001
* @title test key derivation, seal and open randomly.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HPKE_TEST_RANDOMLY_TC002(void)
{
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_HPKE_Mode modes[] = {CRYPT_HPKE_MODE_PSK};
CRYPT_HPKE_KEM_AlgId kemIds[] = {CRYPT_KEM_DHKEM_P256_HKDF_SHA256, CRYPT_KEM_DHKEM_P384_HKDF_SHA384,
CRYPT_KEM_DHKEM_P521_HKDF_SHA512, CRYPT_KEM_DHKEM_X25519_HKDF_SHA256};
CRYPT_HPKE_KDF_AlgId kdfIds[] = {CRYPT_KDF_HKDF_SHA256, CRYPT_KDF_HKDF_SHA384, CRYPT_KDF_HKDF_SHA512};
CRYPT_HPKE_AEAD_AlgId aeadIds[] = {CRYPT_AEAD_AES_128_GCM, CRYPT_AEAD_AES_256_GCM, CRYPT_AEAD_CHACHA20_POLY1305};
size_t p;
size_t i;
size_t j;
size_t k;
for (p = 0; p < sizeof(modes) / sizeof(CRYPT_HPKE_Mode); p++) {
for (i = 0; i < sizeof(kemIds) / sizeof(CRYPT_HPKE_KEM_AlgId); i++) {
for (j = 0; j < sizeof(kdfIds) / sizeof(CRYPT_HPKE_KDF_AlgId); j++) {
for (k = 0; k < sizeof(aeadIds) / sizeof(CRYPT_HPKE_AEAD_AlgId); k++) {
ASSERT_EQ(HpkeRandomTest(modes[p], kemIds[i], kdfIds[j], aeadIds[k]), CRYPT_SUCCESS);
}
}
}
}
EXIT:
TestRandDeInit();
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_HPKE_TEST_RANDOMLY_TC001
* @title test key derivation, seal and open randomly.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HPKE_TEST_RANDOMLY_TC003(void)
{
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_HPKE_Mode modes[] = {CRYPT_HPKE_MODE_AUTH};
CRYPT_HPKE_KEM_AlgId kemIds[] = {CRYPT_KEM_DHKEM_P256_HKDF_SHA256, CRYPT_KEM_DHKEM_P384_HKDF_SHA384,
CRYPT_KEM_DHKEM_P521_HKDF_SHA512, CRYPT_KEM_DHKEM_X25519_HKDF_SHA256};
CRYPT_HPKE_KDF_AlgId kdfIds[] = {CRYPT_KDF_HKDF_SHA256, CRYPT_KDF_HKDF_SHA384, CRYPT_KDF_HKDF_SHA512};
CRYPT_HPKE_AEAD_AlgId aeadIds[] = {CRYPT_AEAD_AES_128_GCM, CRYPT_AEAD_AES_256_GCM, CRYPT_AEAD_CHACHA20_POLY1305};
size_t p;
size_t i;
size_t j;
size_t k;
for (p = 0; p < sizeof(modes) / sizeof(CRYPT_HPKE_Mode); p++) {
for (i = 0; i < sizeof(kemIds) / sizeof(CRYPT_HPKE_KEM_AlgId); i++) {
for (j = 0; j < sizeof(kdfIds) / sizeof(CRYPT_HPKE_KDF_AlgId); j++) {
for (k = 0; k < sizeof(aeadIds) / sizeof(CRYPT_HPKE_AEAD_AlgId); k++) {
ASSERT_EQ(HpkeRandomTest(modes[p], kemIds[i], kdfIds[j], aeadIds[k]), CRYPT_SUCCESS);
}
}
}
}
EXIT:
TestRandDeInit();
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_HPKE_TEST_RANDOMLY_TC001
* @title test key derivation, seal and open randomly.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HPKE_TEST_RANDOMLY_TC004(void)
{
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_HPKE_Mode modes[] = {CRYPT_HPKE_MODE_AUTH_PSK};
CRYPT_HPKE_KEM_AlgId kemIds[] = {CRYPT_KEM_DHKEM_P256_HKDF_SHA256, CRYPT_KEM_DHKEM_P384_HKDF_SHA384,
CRYPT_KEM_DHKEM_P521_HKDF_SHA512, CRYPT_KEM_DHKEM_X25519_HKDF_SHA256};
CRYPT_HPKE_KDF_AlgId kdfIds[] = {CRYPT_KDF_HKDF_SHA256, CRYPT_KDF_HKDF_SHA384, CRYPT_KDF_HKDF_SHA512};
CRYPT_HPKE_AEAD_AlgId aeadIds[] = {CRYPT_AEAD_AES_128_GCM, CRYPT_AEAD_AES_256_GCM, CRYPT_AEAD_CHACHA20_POLY1305};
size_t p;
size_t i;
size_t j;
size_t k;
for (p = 0; p < sizeof(modes) / sizeof(CRYPT_HPKE_Mode); p++) {
for (i = 0; i < sizeof(kemIds) / sizeof(CRYPT_HPKE_KEM_AlgId); i++) {
for (j = 0; j < sizeof(kdfIds) / sizeof(CRYPT_HPKE_KDF_AlgId); j++) {
for (k = 0; k < sizeof(aeadIds) / sizeof(CRYPT_HPKE_AEAD_AlgId); k++) {
ASSERT_EQ(HpkeRandomTest(modes[p], kemIds[i], kdfIds[j], aeadIds[k]), CRYPT_SUCCESS);
}
}
}
}
EXIT:
TestRandDeInit();
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_HPKE_ABNORMAL_TC001
* @title hpke abnormal test.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HPKE_ABNORMAL_TC001(int role)
{
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
int32_t ret;
CRYPT_EAL_HpkeCtx *hpkeCtx = NULL;
CRYPT_HPKE_CipherSuite cipherSuite = {0, 0, 0};
uint8_t massage[100];
uint32_t massageLen = 100;
uint8_t buff[100];
uint32_t buffLen = 100;
uint8_t cipherText[116];
uint32_t cipherTextLen = 116;
hpkeCtx = CRYPT_EAL_HpkeNewCtx(NULL, NULL, role, CRYPT_HPKE_MODE_BASE, cipherSuite);
ASSERT_TRUE(hpkeCtx == NULL);
// test sender
cipherSuite.kemId = CRYPT_KEM_DHKEM_P256_HKDF_SHA256;
cipherSuite.kdfId = CRYPT_KDF_HKDF_SHA256;
cipherSuite.aeadId = CRYPT_AEAD_AES_128_GCM;
#ifdef HITLS_CRYPTO_PROVIDER
hpkeCtx = CRYPT_EAL_HpkeNewCtx(NULL, "provider=none", role, CRYPT_HPKE_MODE_BASE, cipherSuite);
ASSERT_TRUE(hpkeCtx == NULL);
hpkeCtx = CRYPT_EAL_HpkeNewCtx(NULL, "provider=default", role, CRYPT_HPKE_MODE_BASE, cipherSuite);
ASSERT_TRUE(hpkeCtx != NULL);
CRYPT_EAL_HpkeFreeCtx(hpkeCtx);
#endif
hpkeCtx = CRYPT_EAL_HpkeNewCtx(NULL, NULL, role, CRYPT_HPKE_MODE_BASE, cipherSuite);
ASSERT_TRUE(hpkeCtx != NULL);
ret = CRYPT_EAL_HpkeSetupSender(hpkeCtx, NULL, NULL, 0, NULL, 0, NULL, NULL);
if (role == CRYPT_HPKE_SENDER) {
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
} else {
ASSERT_EQ(ret, CRYPT_HPKE_ERR_CALL);
}
ret = CRYPT_EAL_HpkeSetupRecipient(hpkeCtx, NULL, NULL, 0, NULL, 0);
if (role == CRYPT_HPKE_RECIPIENT) {
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
} else {
ASSERT_EQ(ret, CRYPT_HPKE_ERR_CALL);
}
ASSERT_EQ(CRYPT_EAL_HpkeSeal(hpkeCtx, NULL, 0, massage, massageLen, cipherText, &cipherTextLen), CRYPT_HPKE_ERR_CALL);
ASSERT_EQ(CRYPT_EAL_HpkeSeal(NULL, NULL, 0, massage, massageLen, cipherText, &cipherTextLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_HpkeSetSeq(NULL, 0), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_HpkeSetSeq(hpkeCtx, 0xFFFFFFFFFFFFFFFF), CRYPT_INVALID_ARG);
ASSERT_EQ(CRYPT_EAL_HpkeOpen(hpkeCtx, NULL, 0, massage, massageLen, cipherText, &cipherTextLen), CRYPT_HPKE_ERR_CALL);
ASSERT_EQ(CRYPT_EAL_HpkeExportSecret(hpkeCtx, NULL, 0, buff, 0), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_HpkeExportSecret(hpkeCtx, NULL, 0, buff, buffLen), CRYPT_HPKE_ERR_CALL);
ASSERT_EQ(CRYPT_EAL_HpkeGenerateKeyPair(NULL, NULL, cipherSuite, NULL, 0, NULL), CRYPT_NULL_INPUT);
CRYPT_EAL_PkeyCtx *pkey = NULL;
uint8_t ikm[10];
ASSERT_EQ(CRYPT_EAL_HpkeGenerateKeyPair(NULL, NULL, cipherSuite, ikm, 10, &pkey), CRYPT_INVALID_ARG);
EXIT:
CRYPT_EAL_HpkeFreeCtx(hpkeCtx);
TestRandDeInit();
}
/* END_CASE */
static CRYPT_EAL_HpkeCtx *GenHpkeCtxWithSharedSecret(CRYPT_HPKE_Role role, CRYPT_HPKE_Mode mode,
CRYPT_HPKE_CipherSuite cipherSuite, uint8_t *info, uint32_t infoLen, uint8_t* psk,uint32_t pskLen, uint8_t *pskId, uint32_t pskIdLen,
uint8_t *sharedSecret, uint32_t sharedSecretLen)
{
CRYPT_EAL_HpkeCtx *ctx = NULL;
ctx = CRYPT_EAL_HpkeNewCtx(NULL, NULL, role, mode, cipherSuite);
ASSERT_TRUE(ctx != NULL);
if(mode == CRYPT_HPKE_MODE_PSK || mode == CRYPT_HPKE_MODE_AUTH_PSK){
ASSERT_EQ(CRYPT_EAL_HpkeSetPsk(ctx, psk, pskLen, pskId, pskIdLen), CRYPT_SUCCESS);
}
ASSERT_EQ(CRYPT_EAL_HpkeSetSharedSecret(ctx, info, infoLen, sharedSecret, sharedSecretLen), CRYPT_SUCCESS);
return ctx;
EXIT:
CRYPT_EAL_HpkeFreeCtx(ctx);
return NULL;
}
static int32_t HpkeTestImportSharedSecret(CRYPT_HPKE_Mode mode, CRYPT_HPKE_CipherSuite cipherSuite)
{
CRYPT_EAL_HpkeCtx *ctxS = NULL;
CRYPT_EAL_HpkeCtx *ctxR = NULL;
uint32_t sharedSecretLen = 32; // CRYPT_KEM_DHKEM_X25519_HKDF_SHA256 CRYPT_KEM_DHKEM_P256_HKDF_SHA256
if (cipherSuite.kemId == CRYPT_KEM_DHKEM_P384_HKDF_SHA384) {
sharedSecretLen = 48;
} else if (cipherSuite.kemId == CRYPT_KEM_DHKEM_P521_HKDF_SHA512) {
sharedSecretLen = 64;
}
uint8_t psk[10]={0};
uint32_t pskLen=10;
uint8_t pskId[10]={0};
uint32_t pskIdLen=10;
uint8_t sharedSecret[HPKE_KEM_MAX_SHARED_KEY_LEN];
ctxS = GenHpkeCtxWithSharedSecret(CRYPT_HPKE_SENDER, mode, cipherSuite, NULL, 0,
psk, pskLen, pskId, pskIdLen, sharedSecret, sharedSecretLen);
ASSERT_TRUE(ctxS != NULL);
ctxR = GenHpkeCtxWithSharedSecret(CRYPT_HPKE_RECIPIENT, mode, cipherSuite, NULL, 0,
psk, pskLen, pskId, pskIdLen, sharedSecret, sharedSecretLen);
ASSERT_TRUE(ctxR != NULL);
ASSERT_EQ(HpkeTestSealAndOpen(ctxS, ctxR), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_HpkeFreeCtx(ctxS);
CRYPT_EAL_HpkeFreeCtx(ctxR);
return CRYPT_SUCCESS;
}
/**
* @test SDV_CRYPT_EAL_HPKE_SHARED_SECRET_RANDOMLY_TC001
* @title import shared secret test randomly.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HPKE_SHARED_SECRET_RANDOMLY_TC001(void)
{
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_HPKE_Mode mode = CRYPT_HPKE_MODE_BASE;
CRYPT_HPKE_KEM_AlgId kemIds[] = {CRYPT_KEM_DHKEM_P256_HKDF_SHA256, CRYPT_KEM_DHKEM_P384_HKDF_SHA384,
CRYPT_KEM_DHKEM_P521_HKDF_SHA512};
CRYPT_HPKE_KDF_AlgId kdfIds[] = {CRYPT_KDF_HKDF_SHA256, CRYPT_KDF_HKDF_SHA384, CRYPT_KDF_HKDF_SHA512};
CRYPT_HPKE_AEAD_AlgId aeadIds[] = {CRYPT_AEAD_AES_128_GCM, CRYPT_AEAD_AES_256_GCM, CRYPT_AEAD_CHACHA20_POLY1305};
size_t i;
size_t j;
size_t k;
for (i = 0; i < sizeof(kemIds) / sizeof(CRYPT_HPKE_KEM_AlgId); i++) {
for (j = 0; j < sizeof(kdfIds) / sizeof(CRYPT_HPKE_KDF_AlgId); j++) {
for (k = 0; k < sizeof(aeadIds) / sizeof(CRYPT_HPKE_AEAD_AlgId); k++) {
CRYPT_HPKE_CipherSuite cipherSuite = {kemIds[i], kdfIds[j], aeadIds[k]};
ASSERT_EQ(HpkeTestImportSharedSecret(mode, cipherSuite), CRYPT_SUCCESS);
}
}
}
EXIT:
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_HPKE_SHARED_SECRET_RANDOMLY_TC001
* @title import shared secret test randomly.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HPKE_SHARED_SECRET_RANDOMLY_TC002(void)
{
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_HPKE_Mode mode = CRYPT_HPKE_MODE_PSK;
CRYPT_HPKE_KEM_AlgId kemIds[] = {CRYPT_KEM_DHKEM_P256_HKDF_SHA256, CRYPT_KEM_DHKEM_P384_HKDF_SHA384,
CRYPT_KEM_DHKEM_P521_HKDF_SHA512};
CRYPT_HPKE_KDF_AlgId kdfIds[] = {CRYPT_KDF_HKDF_SHA256, CRYPT_KDF_HKDF_SHA384, CRYPT_KDF_HKDF_SHA512};
CRYPT_HPKE_AEAD_AlgId aeadIds[] = {CRYPT_AEAD_AES_128_GCM, CRYPT_AEAD_AES_256_GCM, CRYPT_AEAD_CHACHA20_POLY1305};
size_t i;
size_t j;
size_t k;
for (i = 0; i < sizeof(kemIds) / sizeof(CRYPT_HPKE_KEM_AlgId); i++) {
for (j = 0; j < sizeof(kdfIds) / sizeof(CRYPT_HPKE_KDF_AlgId); j++) {
for (k = 0; k < sizeof(aeadIds) / sizeof(CRYPT_HPKE_AEAD_AlgId); k++) {
CRYPT_HPKE_CipherSuite cipherSuite = {kemIds[i], kdfIds[j], aeadIds[k]};
ASSERT_EQ(HpkeTestImportSharedSecret(mode, cipherSuite), CRYPT_SUCCESS);
}
}
}
EXIT:
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_HPKE_SHARED_SECRET_RANDOMLY_TC001
* @title import shared secret test randomly.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HPKE_SHARED_SECRET_RANDOMLY_TC003(void)
{
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_HPKE_Mode mode = CRYPT_HPKE_MODE_AUTH;
CRYPT_HPKE_KEM_AlgId kemIds[] = {CRYPT_KEM_DHKEM_P256_HKDF_SHA256, CRYPT_KEM_DHKEM_P384_HKDF_SHA384,
CRYPT_KEM_DHKEM_P521_HKDF_SHA512};
CRYPT_HPKE_KDF_AlgId kdfIds[] = {CRYPT_KDF_HKDF_SHA256, CRYPT_KDF_HKDF_SHA384, CRYPT_KDF_HKDF_SHA512};
CRYPT_HPKE_AEAD_AlgId aeadIds[] = {CRYPT_AEAD_AES_128_GCM, CRYPT_AEAD_AES_256_GCM, CRYPT_AEAD_CHACHA20_POLY1305};
size_t i;
size_t j;
size_t k;
for (i = 0; i < sizeof(kemIds) / sizeof(CRYPT_HPKE_KEM_AlgId); i++) {
for (j = 0; j < sizeof(kdfIds) / sizeof(CRYPT_HPKE_KDF_AlgId); j++) {
for (k = 0; k < sizeof(aeadIds) / sizeof(CRYPT_HPKE_AEAD_AlgId); k++) {
CRYPT_HPKE_CipherSuite cipherSuite = {kemIds[i], kdfIds[j], aeadIds[k]};
ASSERT_EQ(HpkeTestImportSharedSecret(mode, cipherSuite), CRYPT_SUCCESS);
}
}
}
EXIT:
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_HPKE_SHARED_SECRET_RANDOMLY_TC001
* @title import shared secret test randomly.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HPKE_SHARED_SECRET_RANDOMLY_TC004(void)
{
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_HPKE_Mode mode = CRYPT_HPKE_MODE_AUTH_PSK;
CRYPT_HPKE_KEM_AlgId kemIds[] = {CRYPT_KEM_DHKEM_P256_HKDF_SHA256, CRYPT_KEM_DHKEM_P384_HKDF_SHA384,
CRYPT_KEM_DHKEM_P521_HKDF_SHA512};
CRYPT_HPKE_KDF_AlgId kdfIds[] = {CRYPT_KDF_HKDF_SHA256, CRYPT_KDF_HKDF_SHA384, CRYPT_KDF_HKDF_SHA512};
CRYPT_HPKE_AEAD_AlgId aeadIds[] = {CRYPT_AEAD_AES_128_GCM, CRYPT_AEAD_AES_256_GCM, CRYPT_AEAD_CHACHA20_POLY1305};
size_t i;
size_t j;
size_t k;
for (i = 0; i < sizeof(kemIds) / sizeof(CRYPT_HPKE_KEM_AlgId); i++) {
for (j = 0; j < sizeof(kdfIds) / sizeof(CRYPT_HPKE_KDF_AlgId); j++) {
for (k = 0; k < sizeof(aeadIds) / sizeof(CRYPT_HPKE_AEAD_AlgId); k++) {
CRYPT_HPKE_CipherSuite cipherSuite = {kemIds[i], kdfIds[j], aeadIds[k]};
ASSERT_EQ(HpkeTestImportSharedSecret(mode, cipherSuite), CRYPT_SUCCESS);
}
}
}
EXIT:
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_HPKE_SHARED_SECRET_TC001
* @title import sharedSecret and seal/open test based on standard vector.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HPKE_SHARED_SECRET_TC001(int mode, int kemId, int kdfId, int aeadId, Hex *info, Hex *psk, Hex *pskId, Hex *sharedSecret,
int seq, Hex *pt, Hex *aad, Hex *ct)
{
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_HPKE_CipherSuite cipherSuite = {kemId, kdfId, aeadId};
CRYPT_EAL_HpkeCtx *ctxS = NULL;
CRYPT_EAL_HpkeCtx *ctxR = NULL;
ctxS = GenHpkeCtxWithSharedSecret(CRYPT_HPKE_SENDER, mode, cipherSuite, info->x, info->len, psk->x, psk->len, pskId->x, pskId->len,
sharedSecret->x, sharedSecret->len);
ASSERT_TRUE(ctxS != NULL);
ctxR = GenHpkeCtxWithSharedSecret(CRYPT_HPKE_RECIPIENT, mode, cipherSuite, info->x, info->len, psk->x, psk->len, pskId->x, pskId->len,
sharedSecret->x, sharedSecret->len);
ASSERT_TRUE(ctxR != NULL);
uint8_t cipher[200] = { 0 };
uint32_t cipherLen = 200;
ASSERT_EQ(CRYPT_EAL_HpkeSetSeq(ctxS, seq), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_HpkeSeal(ctxS, aad->x, aad->len, pt->x, pt->len, cipher, &cipherLen), CRYPT_SUCCESS);
ASSERT_COMPARE("hpke seal cmp", cipher, cipherLen, ct->x, ct->len);
uint64_t nextSeq;
ASSERT_EQ(CRYPT_EAL_HpkeGetSeq(ctxS, &nextSeq), CRYPT_SUCCESS);
ASSERT_EQ(nextSeq, seq + 1);
uint8_t plain[200] = { 0 };
uint32_t plainLen = 200;
ASSERT_EQ(CRYPT_EAL_HpkeSetSeq(ctxR, seq), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_HpkeOpen(ctxR, aad->x, aad->len, cipher, cipherLen, plain, &plainLen), CRYPT_SUCCESS);
ASSERT_COMPARE("hpke open cmp", plain, plainLen, pt->x, pt->len);
ASSERT_EQ(CRYPT_EAL_HpkeGetSeq(ctxR, &nextSeq), CRYPT_SUCCESS);
ASSERT_EQ(nextSeq, seq + 1);
EXIT:
CRYPT_EAL_HpkeFreeCtx(ctxS);
CRYPT_EAL_HpkeFreeCtx(ctxR);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_HPKE_SHARED_SECRET_TC002
* @title import sharedSecret and export secret test based on standard vector.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HPKE_SHARED_SECRET_TC002(int mode, int kemId, int kdfId, int aeadId, Hex *info, Hex *psk,Hex *pskId,Hex *sharedSecret,
Hex *exporterContext, int L, Hex *exportedValue)
{
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_HPKE_CipherSuite cipherSuite = {kemId, kdfId, aeadId};
CRYPT_EAL_HpkeCtx *ctxS = NULL;
CRYPT_EAL_HpkeCtx *ctxR = NULL;
ctxS = GenHpkeCtxWithSharedSecret(CRYPT_HPKE_SENDER, mode, cipherSuite, info->x, info->len, psk->x, psk->len, pskId->x, pskId->len,
sharedSecret->x, sharedSecret->len);
ASSERT_TRUE(ctxS != NULL);
ctxR = GenHpkeCtxWithSharedSecret(CRYPT_HPKE_RECIPIENT, mode, cipherSuite, info->x, info->len, psk->x, psk->len, pskId->x, pskId->len,
sharedSecret->x, sharedSecret->len);
ASSERT_TRUE(ctxR != NULL);
uint8_t exportedValueBuf[HPKE_HKDF_MAX_EXTRACT_KEY_LEN] = {0};
ASSERT_EQ(CRYPT_EAL_HpkeExportSecret(ctxS, exporterContext->x, exporterContext->len, exportedValueBuf, L), CRYPT_SUCCESS);
ASSERT_COMPARE("hpke S exportedValue cmp", exportedValueBuf, exportedValue->len, exportedValue->x, exportedValue->len);
memset(exportedValueBuf, 0, HPKE_HKDF_MAX_EXTRACT_KEY_LEN);
ASSERT_EQ(CRYPT_EAL_HpkeExportSecret(ctxR, exporterContext->x, exporterContext->len, exportedValueBuf, L), CRYPT_SUCCESS);
ASSERT_COMPARE("hpke R exportedValue cmp", exportedValueBuf, exportedValue->len, exportedValue->x, exportedValue->len);
EXIT:
CRYPT_EAL_HpkeFreeCtx(ctxS);
CRYPT_EAL_HpkeFreeCtx(ctxR);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_HPKE_GENERATE_KEY_PAIR_TC001
* @title hpke generate key pair test.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_HPKE_GENERATE_KEY_PAIR_TC001(void)
{
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_HPKE_KEM_AlgId kemIds[] = {CRYPT_KEM_DHKEM_P256_HKDF_SHA256, CRYPT_KEM_DHKEM_P384_HKDF_SHA384,
CRYPT_KEM_DHKEM_P521_HKDF_SHA512};
CRYPT_HPKE_KDF_AlgId kdfIds[] = {CRYPT_KDF_HKDF_SHA256, CRYPT_KDF_HKDF_SHA384, CRYPT_KDF_HKDF_SHA512};
CRYPT_HPKE_AEAD_AlgId aeadIds[] = {CRYPT_AEAD_AES_128_GCM, CRYPT_AEAD_AES_256_GCM, CRYPT_AEAD_CHACHA20_POLY1305};
size_t i;
size_t j;
size_t k;
for (i = 0; i < sizeof(kemIds) / sizeof(CRYPT_HPKE_KEM_AlgId); i++) {
for (j = 0; j < sizeof(kdfIds) / sizeof(CRYPT_HPKE_KDF_AlgId); j++) {
for (k = 0; k < sizeof(aeadIds) / sizeof(CRYPT_HPKE_AEAD_AlgId); k++) {
CRYPT_HPKE_CipherSuite cipherSuite = {kemIds[i], kdfIds[j], aeadIds[k]};
CRYPT_EAL_PkeyCtx *pctx = NULL;
ASSERT_EQ(CRYPT_EAL_HpkeGenerateKeyPair(NULL, NULL, cipherSuite, NULL, 0, &pctx), CRYPT_SUCCESS);
CRYPT_EAL_PkeyFreeCtx(pctx);
pctx = NULL;
uint32_t ikmLen = 1024*1024;
uint8_t *ikm = (uint8_t *)malloc(ikmLen);
memset_s(ikm, ikmLen, 0xFF, ikmLen);
ASSERT_EQ(CRYPT_EAL_HpkeGenerateKeyPair(NULL, NULL, cipherSuite, ikm, ikmLen, &pctx), CRYPT_SUCCESS);
CRYPT_EAL_PkeyFreeCtx(pctx);
free(ikm);
}
}
}
EXIT:
TestRandDeInit();
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/hpke/test_suite_sdv_eal_hpke.c | C | unknown | 39,326 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "bsl_sal.h"
#include "bsl_err.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "crypt_util_rand.h"
#include "eal_pkey_local.h"
#include "securec.h"
/* END_HEADER */
/* @
* @test SDV_CRYPTO_HYBRID_API_TC001
* @spec -
* @title Check the value returned by the ctrl interface meets the expectation.
* @precon nan
* @brief
* 1.Create the context of the algorithm.
* 2.Call CRYPT_EAL_PkeyCtrl to set and get parameters in the context.
* @expect 1.success 2.success
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_HYBRID_API_TC001(int algid, int type, int ekLen, int ctLen, int skLen)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *ctxA = CRYPT_EAL_PkeyNewCtx((int32_t)algid);
ASSERT_TRUE(ctxA != NULL);
int32_t val = CRYPT_PKEY_PARAID_MAX;
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctxA, val), CRYPT_ERR_ALGID);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctxA, 0, &val, sizeof(val)), CRYPT_NOT_SUPPORT);
val = (int32_t)type;
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctxA, val), CRYPT_SUCCESS);
uint32_t encapsKeyLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctxA, CRYPT_CTRL_GET_PUBKEY_LEN, &encapsKeyLen, sizeof(encapsKeyLen)),
CRYPT_SUCCESS);
ASSERT_EQ(encapsKeyLen, ekLen);
uint32_t cipherLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctxA, CRYPT_CTRL_GET_CIPHERTEXT_LEN, &cipherLen, sizeof(cipherLen)),
CRYPT_SUCCESS);
ASSERT_EQ(cipherLen, ctLen);
uint32_t sharedLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctxA, CRYPT_CTRL_GET_SHARED_KEY_LEN, &sharedLen, sizeof(sharedLen)), CRYPT_SUCCESS);
ASSERT_EQ(sharedLen, skLen);
if (type != CRYPT_HYBRID_X25519_MLKEM512 && type != CRYPT_HYBRID_X25519_MLKEM768 && type !=
CRYPT_HYBRID_X25519_MLKEM1024) {
val = CRYPT_POINT_COMPRESSED;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctxA, CRYPT_CTRL_SET_ECC_POINT_FORMAT, &val, sizeof(val)), CRYPT_SUCCESS);
}
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctxA);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_HYBRID_ENCAPS_DECAPS_FUNC_TC001
* @spec -
* @title Generating key pairs and key exchange tests
* @precon nan
* @brief
* 1.Registers the callback function of the memory and random.
* 2.Create a context for key exchange and set parameters.
* 3.Generating a key pair.
* 4.Perform key exchange.
* 5.Check whether the shared keys are the same.
* @expect 1.success 2.success 3.success 4.success 5.The shared key is the same.
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_HYBRID_ENCAPS_DECAPS_FUNC_TC001(int algid, int type, int isProvider)
{
TestMemInit();
CRYPT_RandRegist(TestSimpleRand);
CRYPT_RandRegistEx(TestSimpleRandEx);
CRYPT_EAL_PkeyCtx *ctxA = NULL;
CRYPT_EAL_PkeyCtx *ctxB = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
if (isProvider == 1) {
ctxA = CRYPT_EAL_ProviderPkeyNewCtx(NULL, algid, CRYPT_EAL_PKEY_KEM_OPERATE, "provider=default");
ASSERT_TRUE(ctxA != NULL);
ctxB = CRYPT_EAL_ProviderPkeyNewCtx(NULL, algid, CRYPT_EAL_PKEY_KEM_OPERATE, "provider=default");
ASSERT_TRUE(ctxB != NULL);
} else
#endif
{
(void) isProvider;
ctxA = CRYPT_EAL_PkeyNewCtx(algid);
ASSERT_TRUE(ctxA != NULL);
ctxB = CRYPT_EAL_PkeyNewCtx(algid);
ASSERT_TRUE(ctxB != NULL);
}
uint32_t val = (uint32_t)type;
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctxA, val), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctxB, val), CRYPT_SUCCESS);
uint32_t encapsKeyLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctxA, CRYPT_CTRL_GET_PUBKEY_LEN, &encapsKeyLen, sizeof(encapsKeyLen)),
CRYPT_SUCCESS);
uint32_t cipherLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctxA, CRYPT_CTRL_GET_CIPHERTEXT_LEN, &cipherLen, sizeof(cipherLen)),
CRYPT_SUCCESS);
uint8_t *ciphertext = BSL_SAL_Malloc(cipherLen);
CRYPT_EAL_PkeyPub ek = { 0 };
ek.id = algid;
ek.key.kemEk.len = encapsKeyLen;
ek.key.kemEk.data = BSL_SAL_Malloc(encapsKeyLen);
ASSERT_TRUE(ek.key.kemEk.data != NULL);
uint32_t sharedLenA = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctxA, CRYPT_CTRL_GET_SHARED_KEY_LEN, &sharedLenA, sizeof(sharedLenA)), CRYPT_SUCCESS);
uint8_t *sharedKeyA = BSL_SAL_Malloc(sharedLenA);
ASSERT_TRUE(sharedKeyA != NULL);
uint32_t sharedLenB = sharedLenA;
uint8_t *sharedKeyB = BSL_SAL_Malloc(sharedLenB);
ASSERT_TRUE(sharedKeyB != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctxA), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctxA, &ek), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctxB, &ek), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyEncaps(ctxB, ciphertext, &cipherLen, sharedKeyA, &sharedLenA), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyDecaps(ctxA, ciphertext, cipherLen, sharedKeyB, &sharedLenB), CRYPT_SUCCESS);
ASSERT_COMPARE("compare sharedKey", sharedKeyB, sharedLenB, sharedKeyA, sharedLenA);
EXIT:
BSL_SAL_Free(ek.key.kemEk.data);
BSL_SAL_Free(ciphertext);
BSL_SAL_Free(sharedKeyA);
BSL_SAL_Free(sharedKeyB);
CRYPT_EAL_PkeyFreeCtx(ctxA);
CRYPT_EAL_PkeyFreeCtx(ctxB);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
return;
}
/* END_CASE */
/* Use default random numbers for end-to-end testing */
/* BEGIN_CASE */
void SDV_CRYPTO_HYBRID_ENCAPS_DECAPS_API_TC002(int algid, int type, int isProvider)
{
TestMemInit();
TestRandInit();
CRYPT_EAL_PkeyCtx *ctxA = NULL;
CRYPT_EAL_PkeyCtx *ctxB = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
if (isProvider == 1) {
ctxA = CRYPT_EAL_ProviderPkeyNewCtx(NULL, algid, CRYPT_EAL_PKEY_KEM_OPERATE, "provider=default");
ASSERT_TRUE(ctxA != NULL);
ctxB = CRYPT_EAL_ProviderPkeyNewCtx(NULL, algid, CRYPT_EAL_PKEY_KEM_OPERATE, "provider=default");
ASSERT_TRUE(ctxB != NULL);
} else
#endif
{
(void) isProvider;
ctxA = CRYPT_EAL_PkeyNewCtx(algid);
ASSERT_TRUE(ctxA != NULL);
ctxB = CRYPT_EAL_PkeyNewCtx(algid);
ASSERT_TRUE(ctxB != NULL);
}
uint32_t val = (uint32_t)type;
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctxA, val), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctxB, val), CRYPT_SUCCESS);
uint32_t encapsKeyLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctxA, CRYPT_CTRL_GET_PUBKEY_LEN, &encapsKeyLen, sizeof(encapsKeyLen)),
CRYPT_SUCCESS);
uint32_t cipherLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctxA, CRYPT_CTRL_GET_CIPHERTEXT_LEN, &cipherLen, sizeof(cipherLen)),
CRYPT_SUCCESS);
uint8_t *ciphertext = BSL_SAL_Malloc(cipherLen);
CRYPT_EAL_PkeyPub ek = { 0 };
ek.id = algid;
ek.key.kemEk.len = encapsKeyLen;
ek.key.kemEk.data = BSL_SAL_Malloc(encapsKeyLen);
ASSERT_TRUE(ek.key.kemEk.data != NULL);
uint32_t sharedLenA = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctxA, CRYPT_CTRL_GET_SHARED_KEY_LEN, &sharedLenA, sizeof(sharedLenA)), CRYPT_SUCCESS);
uint8_t *sharedKeyA = BSL_SAL_Malloc(sharedLenA);
ASSERT_TRUE(sharedKeyA != NULL);
uint32_t sharedLenB = sharedLenA;
uint8_t *sharedKeyB = BSL_SAL_Malloc(sharedLenB);
ASSERT_TRUE(sharedKeyB != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctxA), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctxA, &ek), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctxB, &ek), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyEncaps(ctxB, ciphertext, &cipherLen, sharedKeyA, &sharedLenA), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyDecaps(ctxA, ciphertext, cipherLen, sharedKeyB, &sharedLenB), CRYPT_SUCCESS);
EXIT:
BSL_SAL_Free(ek.key.kemEk.data);
BSL_SAL_Free(ciphertext);
BSL_SAL_Free(sharedKeyA);
BSL_SAL_Free(sharedKeyB);
CRYPT_EAL_PkeyFreeCtx(ctxA);
CRYPT_EAL_PkeyFreeCtx(ctxB);
TestRandDeInit();
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_HYBRID_ENCAPS_DECAPS_FUNC_TC002
* @spec -
* @title Setting the key pair and key exchange test
* @precon nan
* @brief
* 1.Registers the callback function of the memory and random.
* 2.Create a context for key exchange and set parameters.
* 3.Setting a key pair.
* 4.Perform key exchange.
* 5.Check whether the shared keys are the same.
* @expect 1.success 2.success 3.success 4.success 5.The shared key is the same.
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_HYBRID_ENCAPS_DECAPS_FUNC_TC002(int algid, int type, int isProvider, Hex *encapsKeyA, Hex *decapsKeyA)
{
TestMemInit();
CRYPT_RandRegist(TestSimpleRand);
CRYPT_RandRegistEx(TestSimpleRandEx);
CRYPT_EAL_PkeyCtx *ctxA = NULL;
CRYPT_EAL_PkeyCtx *ctxB = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
if (isProvider == 1) {
ctxA = CRYPT_EAL_ProviderPkeyNewCtx(NULL, algid, CRYPT_EAL_PKEY_KEM_OPERATE, "provider=default");
ASSERT_TRUE(ctxA != NULL);
ctxB = CRYPT_EAL_ProviderPkeyNewCtx(NULL, algid, CRYPT_EAL_PKEY_KEM_OPERATE, "provider=default");
ASSERT_TRUE(ctxB != NULL);
} else
#endif
{
(void)isProvider;
ctxA = CRYPT_EAL_PkeyNewCtx(algid);
ASSERT_TRUE(ctxA != NULL);
ctxB = CRYPT_EAL_PkeyNewCtx(algid);
ASSERT_TRUE(ctxB != NULL);
}
uint32_t val = (uint32_t)type;
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctxA, val), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctxB, val), CRYPT_SUCCESS);
uint32_t cipherLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctxA, CRYPT_CTRL_GET_CIPHERTEXT_LEN, &cipherLen, sizeof(cipherLen)),
CRYPT_SUCCESS);
uint8_t *ciphertext = BSL_SAL_Malloc(cipherLen);
uint32_t sharedLenA = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctxA, CRYPT_CTRL_GET_SHARED_KEY_LEN, &sharedLenA, sizeof(sharedLenA)), CRYPT_SUCCESS);
uint8_t *sharedKeyA = BSL_SAL_Malloc(sharedLenA);
ASSERT_TRUE(sharedKeyA != NULL);
uint32_t sharedLenB = sharedLenA;
uint8_t *sharedKeyB = BSL_SAL_Malloc(sharedLenB);
ASSERT_TRUE(sharedKeyB != NULL);
CRYPT_EAL_PkeyPub ek = { 0 };
ek.id = algid;
ek.key.kemEk.len = encapsKeyA->len;
ek.key.kemEk.data = encapsKeyA->x;
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctxA, &ek), CRYPT_SUCCESS);
CRYPT_EAL_PkeyPrv dk = { 0 };
dk.id = algid;
dk.key.kemDk.len = decapsKeyA->len;
dk.key.kemDk.data = decapsKeyA->x;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctxA, &dk), CRYPT_SUCCESS);
ek.key.kemEk.len = encapsKeyA->len;
ek.key.kemEk.data = encapsKeyA->x;
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctxB, &ek), CRYPT_SUCCESS);
uint32_t decapsLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctxA, CRYPT_CTRL_GET_PRVKEY_LEN, &decapsLen, sizeof(decapsLen)),
CRYPT_SUCCESS);
ASSERT_EQ(decapsLen, dk.key.kemDk.len);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctxA, &dk), CRYPT_SUCCESS);
ASSERT_COMPARE("compare private key", dk.key.kemDk.data, dk.key.kemDk.len, decapsKeyA->x, decapsKeyA->len);
ASSERT_EQ(CRYPT_EAL_PkeyEncaps(ctxB, ciphertext, &cipherLen, sharedKeyB, &sharedLenB), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyDecaps(ctxA, ciphertext, cipherLen, sharedKeyA, &sharedLenA), CRYPT_SUCCESS);
ASSERT_COMPARE("compare sharedKey", sharedKeyB, sharedLenB, sharedKeyA, sharedLenA);
EXIT:
BSL_SAL_Free(ciphertext);
BSL_SAL_Free(sharedKeyA);
BSL_SAL_Free(sharedKeyB);
CRYPT_EAL_PkeyFreeCtx(ctxA);
CRYPT_EAL_PkeyFreeCtx(ctxB);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
return;
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/hybridkem/test_suite_sdv_hybridkem.c | C | unknown | 11,827 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "securec.h"
#include "crypt_eal_kdf.h"
#include "crypt_errno.h"
#include "bsl_sal.h"
#include "bsl_params.h"
#include "crypt_params_key.h"
/* END_HEADER */
#define DATA_LEN (64)
/**
* @test SDV_CRYPT_EAL_KDF_TLS12_API_TC001
* @title kdftls12 interface test.
* @precon nan
* @brief
* 1.Normal parameter test,the key and label can be empty,parameter limitation see unction declaration,
expected result 1.
* @expect
* 1.The results are as expected, algId only supported CRYPT_MAC_HMAC_SHA256, CRYPT_MAC_HMAC_SHA384,
and CRYPT_MAC_HMAC_SHA512.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_KDF_TLS12_API_TC001(int algId)
{
TestMemInit();
uint32_t keyLen = DATA_LEN;
uint8_t key[DATA_LEN];
uint32_t labelLen = DATA_LEN;
uint8_t label[DATA_LEN];
uint32_t seedLen = DATA_LEN;
uint8_t seed[DATA_LEN];
uint32_t outLen = DATA_LEN;
uint8_t out[DATA_LEN];
CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_KDFTLS12);
ASSERT_TRUE(ctx != NULL);
BSL_Param params[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&algId, sizeof(algId)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
key, keyLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_LABEL, BSL_PARAM_TYPE_OCTETS,
label, labelLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_SEED, BSL_PARAM_TYPE_OCTETS,
seed, seedLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_LABEL, BSL_PARAM_TYPE_OCTETS,
NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_SEED, BSL_PARAM_TYPE_OCTETS,
NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, NULL, outLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, 0), CRYPT_NULL_INPUT);
CRYPT_MAC_AlgId macAlgIdFailed = CRYPT_MAC_HMAC_SHA224;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&macAlgIdFailed, sizeof(macAlgIdFailed)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_KDFTLS12_PARAM_ERROR);
ASSERT_EQ(CRYPT_EAL_KdfDeInitCtx(ctx), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_KdfFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_KDF_TLS12_FUN_TC001
* @title kdftls12 vector test.
* @precon nan
* @brief
* 1.Calculate the output using the given parameters, expected result 1.
* 2.Compare the calculated result with the standard value, expected result 2.
* @expect
* 1.Calculation succeeded.
* 2.The results are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_KDF_TLS12_FUN_TC001(int algId, Hex *key, Hex *label, Hex *seed, Hex *result)
{
if (IsHmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
uint32_t outLen = result->len;
uint8_t *out = malloc(outLen * sizeof(uint8_t));
ASSERT_TRUE(out != NULL);
CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_KDFTLS12);
ASSERT_TRUE(ctx != NULL);
BSL_Param params[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&algId, sizeof(algId)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
key->x, key->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_LABEL, BSL_PARAM_TYPE_OCTETS,
label->x, label->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_SEED, BSL_PARAM_TYPE_OCTETS,
seed->x, seed->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
EXIT:
if (out != NULL) {
free(out);
}
CRYPT_EAL_KdfFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_KDFTLS12_DEFAULT_PROVIDER_FUNC_TC001
* @title Default provider testing
* @precon nan
* @brief
* Load the default provider and use the test vector to test its correctness
*/
/* BEGIN_CASE */
void SDV_CRYPTO_KDFTLS12_DEFAULT_PROVIDER_FUNC_TC001(int algId, Hex *key, Hex *label, Hex *seed, Hex *result)
{
if (IsHmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
uint32_t outLen = result->len;
uint8_t *out = malloc(outLen * sizeof(uint8_t));
ASSERT_TRUE(out != NULL);
CRYPT_EAL_KdfCTX *ctx = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_KDFTLS12, "provider=default");
#else
ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_KDFTLS12);
#endif
ASSERT_TRUE(ctx != NULL);
BSL_Param params[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&algId, sizeof(algId)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
key->x, key->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_LABEL, BSL_PARAM_TYPE_OCTETS,
label->x, label->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_SEED, BSL_PARAM_TYPE_OCTETS,
seed->x, seed->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
EXIT:
if (out != NULL) {
free(out);
}
CRYPT_EAL_KdfFreeCtx(ctx);
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/kdf_tls12/test_suite_sdv_eal_kdf_tls12.c | C | unknown | 7,025 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <pthread.h>
#include <limits.h>
#include "crypt_eal_md.h"
#include "bsl_sal.h"
#include "eal_md_local.h"
#include "crypt_algid.h"
#include "crypt_errno.h"
#include "crypt_md5.h"
/* END_HEADER */
typedef struct {
uint8_t *data;
uint8_t *hash;
uint32_t dataLen;
uint32_t hashLen;
CRYPT_MD_AlgId id;
} ThreadParameter;
void Md5MultiThreadTest(void *arg)
{
ThreadParameter *threadParameter = (ThreadParameter *)arg;
uint32_t outLen = CRYPT_MD5_DIGESTSIZE;
uint8_t out[CRYPT_MD5_DIGESTSIZE];
CRYPT_EAL_MdCTX *ctx = NULL;
ctx = CRYPT_EAL_MdNewCtx(threadParameter->id);
ASSERT_TRUE(ctx != NULL);
for (uint32_t i = 0; i < 10; i++) { // Repeat 10 times
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, threadParameter->data, threadParameter->dataLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("hash result cmp", out, outLen, threadParameter->hash, threadParameter->hashLen);
}
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/**
* @test SDV_CRYPTO_MD5_API_TC001
* @title update and final test.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdDeinit the null CTX, expected result 1.
* 2.Call CRYPT_EAL_MdNewCtx create the CTX, expected result 2.
* 3.Call CRYPT_EAL_MdUpdate and CRYPT_EAL_MdFinal before initialization, expected result 3.
* 4.Call CRYPT_EAL_MdUpdate and CRYPT_EAL_MdFinal use null pointer, expected result 4.
* 5.Call CRYPT_EAL_MdUpdate and CRYPT_EAL_MdFinal normally, expected result 5.
* 6.Call CRYPT_EAL_MdDeinit the CTX, expected result 6.
* 7.Call CRYPT_EAL_MdFinal after CRYPT_EAL_MdFinal, expected result 7.
* 8.Call CRYPT_EAL_MdUpdate after CRYPT_EAL_MdFinal expected result 8.
* @expect
* 1.Return CRYPT_NULL_INPUT.
* 2.Create successful.
* 3.Return CRYPT_EAL_ERR_STATE.
* 4.Return CRYPT_NULL_INPUT.
* 5.Successful.
* 6.Successful.
* 7.Return CRYPT_EAL_ERR_STATE.
* 8.Return CRYPT_EAL_ERR_STATE.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_MD5_API_TC001(void)
{
TestMemInit();
uint8_t data[100];
uint32_t dataLen = sizeof(data);
uint8_t output[CRYPT_MD5_DIGESTSIZE + 1];
uint32_t outputLen = CRYPT_MD5_DIGESTSIZE;
CRYPT_EAL_MdCTX *md5Ctx = NULL;
ASSERT_EQ(CRYPT_EAL_MdDeinit(md5Ctx), CRYPT_NULL_INPUT);
md5Ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_MD5);
ASSERT_TRUE(md5Ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdGetDigestSize(CRYPT_MD_MD5), CRYPT_MD5_DIGESTSIZE);
ASSERT_EQ(CRYPT_EAL_MdUpdate(md5Ctx, data, dataLen), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_MdFinal(md5Ctx, output, &outputLen), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_MdInit(md5Ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(md5Ctx, NULL, dataLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdUpdate(md5Ctx, data, dataLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(NULL, output, &outputLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdFinal(md5Ctx, NULL, &outputLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdFinal(md5Ctx, output, NULL), CRYPT_NULL_INPUT);
outputLen = CRYPT_MD5_DIGESTSIZE - 1;
ASSERT_EQ(CRYPT_EAL_MdFinal(md5Ctx, output, &outputLen), CRYPT_MD5_OUT_BUFF_LEN_NOT_ENOUGH);
outputLen = CRYPT_MD5_DIGESTSIZE;
ASSERT_EQ(CRYPT_EAL_MdFinal(md5Ctx, output, &outputLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdDeinit(md5Ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdInit(md5Ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(md5Ctx, data, dataLen), CRYPT_SUCCESS);
outputLen = CRYPT_MD5_DIGESTSIZE + 1;
ASSERT_EQ(CRYPT_EAL_MdFinal(md5Ctx, output, &outputLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(md5Ctx, output, &outputLen), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_MdUpdate(md5Ctx, data, dataLen), CRYPT_EAL_ERR_STATE);
EXIT:
CRYPT_EAL_MdFreeCtx(md5Ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_MD5_FUNC_TC001
* @title CRYPT_EAL_MdFinal test without update.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdNewCtx to create ctx, expected result 1.
* 2.Call CRYPT_EAL_MdFinal get results. expected result 2.
* 3.Compare with expected results. expected result 3.
* @expect
* 1.The ctx is created successfully.
* 2.Successful.
* 2.Consistent with expected results.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_MD5_FUNC_TC001(Hex *hash)
{
TestMemInit();
uint8_t output[CRYPT_MD5_DIGESTSIZE];
uint32_t outLen = CRYPT_MD5_DIGESTSIZE;
CRYPT_EAL_MdCTX *md5Ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_MD5);
ASSERT_TRUE(md5Ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(md5Ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(md5Ctx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(outLen, CRYPT_MD5_DIGESTSIZE);
ASSERT_COMPARE("md5", output, outLen, hash->x, hash->len);
EXIT:
CRYPT_EAL_MdFreeCtx(md5Ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_MD5_FUNC_TC002
* @title Perform the vector test to check whether the calculation result is consistent with the standard output.
* @precon nan
* @brief
* 1.Calculate the hash of each group of data, expected result 1.
* 2.Compare the result to the expected value, expected result 2.
* 3.Call CRYPT_EAL_Md to calculate the hash of each group of data, expected result 3.
* @expect
* 1.Hash calculation succeeded.
* 2.The results are as expected.
* 3.The results are as expected.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_MD5_FUNC_TC002(Hex *msg, Hex *hash)
{
TestMemInit();
uint8_t output[CRYPT_MD5_DIGESTSIZE];
uint32_t outLen = CRYPT_MD5_DIGESTSIZE;
CRYPT_EAL_MdCTX *md5Ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_MD5);
ASSERT_TRUE(md5Ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(md5Ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(md5Ctx, msg->x, msg->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(md5Ctx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(outLen, CRYPT_MD5_DIGESTSIZE);
ASSERT_COMPARE("md5", output, outLen, hash->x, hash->len);
ASSERT_EQ(CRYPT_EAL_Md(CRYPT_MD_MD5, msg->x, msg->len, output, &outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("md5", output, outLen, hash->x, hash->len);
EXIT:
CRYPT_EAL_MdFreeCtx(md5Ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_MD5_FUNC_TC003
* @title Split the data and update test.
* @precon nan
* @brief
* 1.Create two ctx and initialize them, expected result 1.
* 2.Use ctx1 to update data 100 times, expected result 2.
* 3.Use ctx2 to update all data at once, expected result 3.
* 4.Compare two outputs, expected result 4.
* @expect
* 1.Successful.
* 2.Successful.
* 3.Successful.
* 4.The results are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_MD5_FUNC_TC003(void)
{
TestMemInit();
CRYPT_EAL_MdCTX *ctx1 = NULL;
CRYPT_EAL_MdCTX *ctx2 = NULL;
ctx1 = CRYPT_EAL_MdNewCtx(CRYPT_MD_MD5);
ASSERT_TRUE(ctx1 != NULL);
ctx2 = CRYPT_EAL_MdNewCtx(CRYPT_MD_MD5);
ASSERT_TRUE(ctx2 != NULL);
uint8_t input[5050];
uint32_t inLenTotal = 0;
uint32_t inLenBase;
uint8_t out1[CRYPT_MD5_DIGESTSIZE];
uint8_t out2[CRYPT_MD5_DIGESTSIZE];
uint32_t outLen = CRYPT_MD5_DIGESTSIZE;
ASSERT_EQ(CRYPT_EAL_MdInit(ctx1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx2), CRYPT_SUCCESS);
for (inLenBase = 1; inLenBase <= 100; inLenBase++) {
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx1, input + inLenTotal, inLenBase), CRYPT_SUCCESS);
inLenTotal += inLenBase;
}
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx1, out1, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(outLen, CRYPT_MD5_DIGESTSIZE);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx2, input, inLenTotal), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx2, out2, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(outLen, CRYPT_MD5_DIGESTSIZE);
ASSERT_COMPARE("md5", out1, outLen, out2, outLen);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx1);
CRYPT_EAL_MdFreeCtx(ctx2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_MD5_FUNC_TC004
* @title Hash calculation for multiple updates,comparison with standard results.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdNewCtx to create a ctx and initialize, expected result 1.
* 2.Call CRYPT_EAL_MdUpdate to calculate the hash of a data segmentxpected result 2.
* 3.Call CRYPT_EAL_MdUpdate to calculate the next data segmentxpected result 3.
* 4.Call CRYPT_EAL_MdUpdate to calculate the next data segmentxpected result 4.
* 5.Call CRYPT_EAL_MdFinal get the result, expected result 5.
* @expect
* 1.Successful
* 2.Successful
* 3.Successful
* 4.Successful
* 5.The results are as expected.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_MD5_FUNC_TC004(Hex *data1, Hex *data2, Hex *data3, Hex *hash)
{
TestMemInit();
uint8_t output[CRYPT_MD5_DIGESTSIZE];
uint32_t outLen = CRYPT_MD5_DIGESTSIZE;
CRYPT_EAL_MdCTX *md5Ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_MD5);
ASSERT_TRUE(md5Ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(md5Ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(md5Ctx, data1->x, data1->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(md5Ctx, data2->x, data2->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(md5Ctx, data3->x, data3->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(md5Ctx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(outLen, CRYPT_MD5_DIGESTSIZE);
ASSERT_COMPARE("md5", output, outLen, hash->x, hash->len);
EXIT:
CRYPT_EAL_MdFreeCtx(md5Ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_MD5_COPY_CTX_FUNC_TC001
* @title MD5 copy ctx function test.
* @precon nan
* @brief
* 1. Create the context ctx of md algorithm, expected result 1
* 2. Call to CRYPT_EAL_MdCopyCtx method to copy ctx, expected result 2
* 2. Call to CRYPT_EAL_MdCopyCtx method to copy a null ctx, expected result 3
* 3. Calculate the hash of msg, and compare the calculated result with hash vector, expected result 4
* 4. Call to CRYPT_EAL_MdDupCtx method to copy ctx, expected result 5
* 3. Calculate the hash of msg, and compare the calculated result with hash vector, expected result 6
* @expect
* 1. Success, the context is not null.
* 2. CRYPT_SUCCESS
* 3. CRYPT_NULL_INPUT
* 4. Success, the context is not null.
* 5. CRYPT_SUCCESS
* 6. Success, the hashs are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_MD5_COPY_CTX_FUNC_TC001(int id, Hex *msg, Hex *hash)
{
TestMemInit();
CRYPT_EAL_MdCTX *cpyCtx = NULL;
CRYPT_EAL_MdCTX *dupCtx = NULL;
CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdNewCtx(id);
ASSERT_TRUE(ctx != NULL);
uint8_t output[CRYPT_MD5_DIGESTSIZE];
uint32_t outLen = CRYPT_MD5_DIGESTSIZE;
dupCtx=CRYPT_EAL_MdDupCtx(cpyCtx);
ASSERT_TRUE(dupCtx == NULL);
ASSERT_EQ(CRYPT_MD_MAX, CRYPT_EAL_MdGetId(dupCtx));
ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, ctx), CRYPT_NULL_INPUT);
cpyCtx = CRYPT_EAL_MdNewCtx(id);
ASSERT_TRUE(cpyCtx != NULL);
ASSERT_TRUE(dupCtx == NULL);
ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, dupCtx), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdInit(cpyCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(cpyCtx, msg->x, msg->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(cpyCtx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(id, cpyCtx->id);
ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
dupCtx=CRYPT_EAL_MdDupCtx(ctx);
ASSERT_TRUE(dupCtx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(dupCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(dupCtx, msg->x, msg->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(dupCtx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(id, CRYPT_EAL_MdGetId(dupCtx));
ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
CRYPT_EAL_MdFreeCtx(cpyCtx);
CRYPT_EAL_MdFreeCtx(dupCtx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_MD5_FUNC_TC005
* @title Default provider testing
* @precon nan
* @brief
* Load the default provider and use the test vector to test its correctness
*/
/* BEGIN_CASE */
void SDV_CRYPTO_MD5_FUNC_TC005(int id, Hex *msg, Hex *hash)
{
TestMemInit();
uint8_t output[CRYPT_MD5_DIGESTSIZE];
uint32_t outLen = CRYPT_MD5_DIGESTSIZE;
CRYPT_EAL_MdCTX *ctx = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, id, "provider=default");
#else
ctx = CRYPT_EAL_MdNewCtx(id);
#endif
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, msg->x, msg->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_MD_MD5_FUNC_TC001
* @title Test multi-thread hash calculation.
* @precon nan
* @brief
* 1.Create two threads and calculate the hash, expected result 1.
* 2.Compare the result to the expected value, expected result 2.
* @expect
* 1.Hash calculation succeeded.
* 2.The results are as expected.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_MD_MD5_FUNC_TC001(int algId, Hex *data, Hex *hash)
{
int ret;
TestMemInit();
const uint32_t threadNum = 2;
pthread_t thrd[2];
ThreadParameter arg[2] = {
{data->x, hash->x, data->len, hash->len, algId},
{data->x, hash->x, data->len, hash->len, algId}
};
for (uint32_t i = 0; i < threadNum; i++) {
ret = pthread_create(&thrd[i], NULL, (void *)Md5MultiThreadTest, &arg[i]);
ASSERT_EQ(ret, 0);
}
for (uint32_t i = 0; i < threadNum; i++) {
pthread_join(thrd[i], NULL);
}
EXIT:
return;
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/md5/test_suite_sdv_eal_md5.c | C | unknown | 14,310 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "securec.h"
#include "hitls_build.h"
#include "bsl_err.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_rand.h"
#include "crypt_eal_md.h"
#include "crypt_util_rand.h"
/* END_HEADER */
static uint8_t gMlDsaRandBuf[3][32] = { 0 };
uint32_t gMlDsaRandNum = 0;
static int32_t TEST_MLDSARandom(uint8_t *randNum, uint32_t randLen)
{
memcpy_s(randNum, randLen, gMlDsaRandBuf[gMlDsaRandNum], 32);
gMlDsaRandNum++;
return 0;
}
static int32_t TEST_MLDSARandomEx(void *libCtx, uint8_t *randNum, uint32_t randLen)
{
(void) libCtx;
return TEST_MLDSARandom(randNum, randLen);
}
/* @
* @test SDV_CRYPTO_MLDSA_API_TC001
* @spec -
* @title Test the MLDSA external interface.
* @precon nan
* @brief
* 1.Generate the context.
* 2.Call the copy and cmp interfaces.
* @expect
* 1.success
* 2.The result is same as expected.
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLDSA_API_TC001(int type, int setBits)
{
TestMemInit();
TestRandInit();
CRYPT_EAL_PkeyCtx *ctx1 = NULL;
CRYPT_EAL_PkeyCtx *ctx2 = NULL;
CRYPT_EAL_PkeyCtx *ctx3 = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx1 = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
#else
ctx1 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
#endif
ASSERT_TRUE(ctx1 != NULL);
uint32_t val = (uint32_t)type;
int32_t ret = CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_PARA_BY_ID, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyGen(ctx1);
ASSERT_EQ(ret, CRYPT_SUCCESS);
#ifdef HITLS_CRYPTO_PROVIDER
ctx2 = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
#else
ctx2 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
#endif
ASSERT_TRUE(ctx2 != NULL);
val = (uint32_t)type;
ret = CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_PARA_BY_ID, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyGen(ctx2);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyCmp(ctx1, ctx2);
ASSERT_NE(ret, CRYPT_SUCCESS);
ctx3 = CRYPT_EAL_PkeyDupCtx(ctx1);
ASSERT_TRUE(ctx3 != NULL);
ret = CRYPT_EAL_PkeyCmp(ctx1, ctx3);
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t secBits = CRYPT_EAL_PkeyGetSecurityBits(ctx1);
ASSERT_EQ(secBits, setBits);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
CRYPT_EAL_PkeyFreeCtx(ctx3);
TestRandDeInit();
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLDSA_FUNC_KEYGEN_TC001
* @spec -
* @title Generate public and private key tests.
* @precon nan
* @brief
* 1.Registers a random number that returns the specified value.
* 2.Call the key generation interface.
* @expect
* 1.success
* 2.The public and private key is same as expected.
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLDSA_FUNC_KEYGEN_TC001(int type, Hex *d, Hex *testPubkey, Hex *testPrvKey)
{
TestMemInit();
gMlDsaRandNum = 0;
memcpy_s(gMlDsaRandBuf[0], 32, d->x, d->len);
CRYPT_RandRegist(TEST_MLDSARandom);
CRYPT_RandRegistEx(TEST_MLDSARandomEx);
CRYPT_EAL_PkeyPub pubKey = { 0 };
pubKey.id = CRYPT_PKEY_ML_DSA;
pubKey.key.mldsaPub.len = testPubkey->len;
pubKey.key.mldsaPub.data = BSL_SAL_Malloc(testPubkey->len);
ASSERT_TRUE(pubKey.key.mldsaPub.data != NULL);
CRYPT_EAL_PkeyPrv prvKey = { 0 };
prvKey.id = CRYPT_PKEY_ML_DSA;
prvKey.key.mldsaPrv.len = testPrvKey->len;
prvKey.key.mldsaPrv.data = BSL_SAL_Malloc(testPrvKey->len);
ASSERT_TRUE(prvKey.key.mldsaPrv.data != NULL);
CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
ASSERT_TRUE(ctx != NULL);
uint32_t val = (uint32_t)type;
int32_t ret = CRYPT_EAL_PkeySetParaById(ctx, val);
ASSERT_EQ(ret, CRYPT_SUCCESS);
pubKey.key.mldsaPub.len = testPubkey->len;
ret = CRYPT_EAL_PkeyGetPub(ctx, &pubKey);
ASSERT_EQ(ret, CRYPT_MLDSA_KEY_NOT_SET);
prvKey.key.mldsaPrv.len = testPrvKey->len;
ret = CRYPT_EAL_PkeyGetPrv(ctx, &prvKey);
ASSERT_EQ(ret, CRYPT_MLDSA_KEY_NOT_SET);
ret = CRYPT_EAL_PkeyGen(ctx);
ASSERT_EQ(ret, CRYPT_SUCCESS);
pubKey.key.mldsaPub.len = testPubkey->len - 1;
ret = CRYPT_EAL_PkeyGetPub(ctx, &pubKey);
ASSERT_EQ(ret, CRYPT_MLDSA_LEN_NOT_ENOUGH);
pubKey.key.mldsaPub.len = testPubkey->len;
ret = CRYPT_EAL_PkeyGetPub(ctx, &pubKey);
ASSERT_EQ(ret, CRYPT_SUCCESS);
prvKey.key.mldsaPrv.len = testPrvKey->len - 1;
ret = CRYPT_EAL_PkeyGetPrv(ctx, &prvKey);
ASSERT_EQ(ret, CRYPT_MLDSA_LEN_NOT_ENOUGH);
prvKey.key.mldsaPrv.len = testPrvKey->len;
ret = CRYPT_EAL_PkeyGetPrv(ctx, &prvKey);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_COMPARE("compare pubkey", pubKey.key.mldsaPub.data, pubKey.key.mldsaPub.len, testPubkey->x, testPubkey->len);
ASSERT_COMPARE("compare prvkey", prvKey.key.mldsaPrv.data, prvKey.key.mldsaPrv.len, testPrvKey->x, testPrvKey->len);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
BSL_SAL_FREE(pubKey.key.mldsaPub.data);
BSL_SAL_FREE(prvKey.key.mldsaPrv.data);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLDSA_FUNC_SIGNDATA_TC001
* @spec -
* @title Signature test.
* @precon nan
* @brief
* 1.Registers a random number that returns the specified value.
* 2.Set the private key.
* 3.Call the signature interface.
* @expect
* 1.success
* 2.success
* 3.The signature value is consistent with the test vector.
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLDSA_FUNC_SIGNDATA_TC001(int type, Hex *seed, Hex *testPrvKey, Hex *msg, Hex *sign)
{
TestMemInit();
gMlDsaRandNum = 0;
memcpy_s(gMlDsaRandBuf[0], 32, seed->x, seed->len);
CRYPT_RandRegist(TEST_MLDSARandom);
CRYPT_RandRegistEx(TEST_MLDSARandomEx);
CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
ASSERT_TRUE(ctx != NULL);
uint32_t val = (uint32_t)type;
int32_t ret = CRYPT_EAL_PkeySetParaById(ctx, val);
ASSERT_EQ(ret, CRYPT_SUCCESS);
val = 0;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_MLDSA_ENCODE_FLAG, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t outLen = CRYPT_EAL_PkeyGetSignLen(ctx);
ASSERT_EQ(outLen, sign->len);
uint8_t *out = BSL_SAL_Malloc(outLen);
CRYPT_EAL_PkeyPrv prvKey = { 0 };
prvKey.id = CRYPT_PKEY_ML_DSA;
prvKey.key.mldsaPrv.data = testPrvKey->x;
prvKey.key.mldsaPrv.len = testPrvKey->len - 1;
ret = CRYPT_EAL_PkeySetPrv(ctx, &prvKey);
ASSERT_EQ(ret, CRYPT_MLDSA_KEYLEN_ERROR);
prvKey.key.mldsaPrv.len = testPrvKey->len + 1;
ret = CRYPT_EAL_PkeySetPrv(ctx, &prvKey);
ASSERT_EQ(ret, CRYPT_MLDSA_KEYLEN_ERROR);
prvKey.key.mldsaPrv.len = testPrvKey->len;
ret = CRYPT_EAL_PkeySetPrv(ctx, &prvKey);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeySign(ctx, CRYPT_MD_MAX, msg->x, msg->len, out, &outLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_COMPARE("compare sign", out, outLen, sign->x, sign->len);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
BSL_SAL_FREE(out);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLDSA_FUNC_VERIFYDATA_TC001
* @spec -
* @title Verify test.
* @precon nan
* @brief
* 1.Set the public key.
* 2.Call the verify interface.
* @expect
* 1.success
* 2.The verify value is consistent with the test vector.
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLDSA_FUNC_VERIFYDATA_TC001(int type, Hex *testPubKey, Hex *msg, Hex *sign, int res)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
ASSERT_TRUE(ctx != NULL);
uint32_t val = (uint32_t)type;
int32_t ret = CRYPT_EAL_PkeySetParaById(ctx, val);
ASSERT_EQ(ret, CRYPT_SUCCESS);
val = 0;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_MLDSA_ENCODE_FLAG, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
CRYPT_EAL_PkeyPub pubKey = { 0 };
pubKey.id = CRYPT_PKEY_ML_DSA;
pubKey.key.mldsaPub.data = testPubKey->x;
pubKey.key.mldsaPub.len = testPubKey->len - 1;
ret = CRYPT_EAL_PkeySetPub(ctx, &pubKey);
ASSERT_EQ(ret, CRYPT_MLDSA_KEYLEN_ERROR);
pubKey.key.mldsaPub.len = testPubKey->len + 1;
ret = CRYPT_EAL_PkeySetPub(ctx, &pubKey);
ASSERT_EQ(ret, CRYPT_MLDSA_KEYLEN_ERROR);
pubKey.key.mldsaPub.len = testPubKey->len;
ret = CRYPT_EAL_PkeySetPub(ctx, &pubKey);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_MAX, msg->x, msg->len, sign->x, sign->len);
if (res == 1) {
ASSERT_EQ(ret, CRYPT_SUCCESS);
} else {
ASSERT_NE(ret, CRYPT_SUCCESS);
}
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLDSA_FUNC_SIGNDATA_TC002
* @spec -
* @title Signature test.
* @precon nan
* @brief
* 1.Registers a random number that returns the specified value.
* 2.Set the private key and additional messages.
* 3.Call the signature interface.
* @expect
* 1.success
* 2.success
* 3.The signature value is consistent with the test vector.
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLDSA_FUNC_SIGNDATA_TC002(int type, Hex *seed, Hex *testPrvKey, Hex *msg, Hex *ctxText,
Hex *sign, int deterministic, int externalMu, int encodeCtx)
{
TestMemInit();
gMlDsaRandNum = 0;
memcpy_s(gMlDsaRandBuf[0], 32, seed->x, seed->len);
CRYPT_RandRegist(TEST_MLDSARandom);
CRYPT_RandRegistEx(TEST_MLDSARandomEx);
CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
ASSERT_TRUE(ctx != NULL);
uint32_t val = (uint32_t)type;
int32_t ret = CRYPT_EAL_PkeySetParaById(ctx, val);
ASSERT_EQ(ret, CRYPT_SUCCESS);
val = (uint32_t)deterministic;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_DETERMINISTIC_FLAG, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_CTX_INFO, ctxText->x, ctxText->len);
ASSERT_EQ(ret, CRYPT_SUCCESS);
val = (uint32_t)encodeCtx;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_MLDSA_ENCODE_FLAG, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
val = (uint32_t)externalMu;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_MLDSA_MUMSG_FLAG, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t outLen = CRYPT_EAL_PkeyGetSignLen(ctx);
ASSERT_EQ(outLen, sign->len);
uint8_t *out = BSL_SAL_Malloc(outLen);
CRYPT_EAL_PkeyPrv prvKey = { 0 };
prvKey.id = CRYPT_PKEY_ML_DSA;
prvKey.key.mldsaPrv.data = testPrvKey->x;
prvKey.key.mldsaPrv.len = testPrvKey->len;
ret = CRYPT_EAL_PkeySetPrv(ctx, &prvKey);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeySign(ctx, CRYPT_MD_MAX, msg->x, msg->len, out, &outLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_COMPARE("compare sign", out, outLen, sign->x, sign->len);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
BSL_SAL_FREE(out);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLDSA_FUNC_VERIFYDATA_TC002
* @spec -
* @title Verify test.
* @precon nan
* @brief
* 1.Set the public key.
* 2.Call the verify interface.
* @expect
* 1.success
* 2.The verify value is consistent with the test vector.
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLDSA_FUNC_VERIFYDATA_TC002(int type, Hex *testPubKey, Hex *msg, Hex *sign, Hex *ctxText, int externalMu, int encodeCtx, int res)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
ASSERT_TRUE(ctx != NULL);
uint32_t val = (uint32_t)type;
int32_t ret = CRYPT_EAL_PkeySetParaById(ctx, val);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_CTX_INFO, ctxText->x, ctxText->len);
ASSERT_EQ(ret, CRYPT_SUCCESS);
val = (uint32_t)encodeCtx;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_MLDSA_ENCODE_FLAG, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
val = (uint32_t)externalMu;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_MLDSA_MUMSG_FLAG, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
CRYPT_EAL_PkeyPub pubKey = { 0 };
pubKey.id = CRYPT_PKEY_ML_DSA;
pubKey.key.mldsaPub.data = testPubKey->x;
pubKey.key.mldsaPub.len = testPubKey->len;
ret = CRYPT_EAL_PkeySetPub(ctx, &pubKey);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_MAX, msg->x, msg->len, sign->x, sign->len);
if (res == 0) {
ASSERT_EQ(ret, CRYPT_SUCCESS);
} else {
ASSERT_NE(ret, CRYPT_SUCCESS);
}
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLDSA_FUNC_SIGN_TC001
* @spec -
* @title Signature test.
* @precon nan
* @brief
* 1.Registers a random number that returns the specified value.
* 2.Set the private key and additional messages.
* 3.Call the signature interface.
* @expect
* 1.success
* 2.success
* 3.The signature value is consistent with the test vector.
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLDSA_FUNC_SIGN_TC001(int type, int hashId, Hex *seed, Hex *testPrvKey, Hex *msg, Hex *ctxText,
Hex *sign, int deterministic, int externalMu, int encodeCtx)
{
TestMemInit();
gMlDsaRandNum = 0;
memcpy_s(gMlDsaRandBuf[0], 32, seed->x, seed->len);
CRYPT_RandRegist(TEST_MLDSARandom);
CRYPT_RandRegistEx(TEST_MLDSARandomEx);
CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
ASSERT_TRUE(ctx != NULL);
uint32_t val = (uint32_t)type;
int32_t ret = CRYPT_EAL_PkeySetParaById(ctx, val);
ASSERT_EQ(ret, CRYPT_SUCCESS);
val = (uint32_t)deterministic;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_DETERMINISTIC_FLAG, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_CTX_INFO, ctxText->x, ctxText->len);
ASSERT_EQ(ret, CRYPT_SUCCESS);
val = (uint32_t)encodeCtx;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_MLDSA_ENCODE_FLAG, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
val = (uint32_t)externalMu;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_MLDSA_MUMSG_FLAG, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t outLen = CRYPT_EAL_PkeyGetSignLen(ctx);
ASSERT_EQ(outLen, sign->len);
uint8_t *out = BSL_SAL_Malloc(outLen);
CRYPT_EAL_PkeyPrv prvKey = { 0 };
prvKey.id = CRYPT_PKEY_ML_DSA;
prvKey.key.mldsaPrv.data = testPrvKey->x;
prvKey.key.mldsaPrv.len = testPrvKey->len;
ret = CRYPT_EAL_PkeySetPrv(ctx, &prvKey);
ASSERT_EQ(ret, CRYPT_SUCCESS);
val = 1;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_PREHASH_FLAG, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeySign(ctx, hashId, msg->x, msg->len, out, &outLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_COMPARE("compare sign", out, outLen, sign->x, sign->len);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
BSL_SAL_FREE(out);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLDSA_FUNC_VERIFY_TC001
* @spec -
* @title Verify test.
* @precon nan
* @brief
* 1.Set the public key.
* 2.Call the verify interface.
* @expect
* 1.success
* 2.The verify value is consistent with the test vector.
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLDSA_FUNC_VERIFY_TC001(int type, int hashId, Hex *testPubKey, Hex *msg, Hex *sign, Hex *ctxText, int externalMu, int encodeCtx, int res)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
ASSERT_TRUE(ctx != NULL);
uint32_t val = (uint32_t)type;
int32_t ret = CRYPT_EAL_PkeySetParaById(ctx, val);
ASSERT_EQ(ret, CRYPT_SUCCESS);
val = (int32_t)encodeCtx;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_MLDSA_ENCODE_FLAG, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_CTX_INFO, ctxText->x, ctxText->len);
ASSERT_EQ(ret, CRYPT_SUCCESS);
val = (int32_t)externalMu;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_MLDSA_MUMSG_FLAG, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
CRYPT_EAL_PkeyPub pubKey = { 0 };
pubKey.id = CRYPT_PKEY_ML_DSA;
pubKey.key.mldsaPub.data = testPubKey->x;
pubKey.key.mldsaPub.len = testPubKey->len;
ret = CRYPT_EAL_PkeySetPub(ctx, &pubKey);
ASSERT_EQ(ret, CRYPT_SUCCESS);
val = 1;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_PREHASH_FLAG, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyVerify(ctx, hashId, msg->x, msg->len, sign->x, sign->len);
if (res == 0) {
ASSERT_EQ(ret, CRYPT_SUCCESS);
} else {
ASSERT_NE(ret, CRYPT_SUCCESS);
}
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_MLDSA_FUNC_PROVIDER_TC001
* @title To test the provisioner function.
* @precon Registering memory-related functions.
* @brief
* Invoke the signature and signature verification functions to test the function correctness.
* @expect
* Success, and contexts are not NULL.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_MLDSA_FUNC_PROVIDER_TC001(int type, Hex *testPubKey, Hex *testPrvKey, Hex *msg, Hex *context, Hex *sign)
{
TestMemInit();
TestRandInit();
uint8_t *out = NULL;
CRYPT_EAL_PkeyCtx *ctx = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
#else
ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
#endif
ASSERT_TRUE(ctx != NULL);
uint32_t val = (uint32_t)type;
int32_t ret = CRYPT_EAL_PkeySetParaById(ctx, val);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_CTX_INFO, context->x, context->len);
ASSERT_EQ(ret, CRYPT_SUCCESS);
val = 1;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_DETERMINISTIC_FLAG, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t outLen = CRYPT_EAL_PkeyGetSignLen(ctx);
ASSERT_EQ(outLen, sign->len);
out = BSL_SAL_Malloc(outLen);
ASSERT_TRUE(out != NULL);
CRYPT_EAL_PkeyPrv prvKey = { 0 };
prvKey.id = CRYPT_PKEY_ML_DSA;
prvKey.key.mldsaPrv.data = testPrvKey->x;
prvKey.key.mldsaPrv.len = testPrvKey->len;
ret = CRYPT_EAL_PkeySetPrv(ctx, &prvKey);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeySign(ctx, CRYPT_MD_MAX, msg->x, msg->len, out, &outLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_COMPARE("compare sign", out, outLen, sign->x, sign->len);
CRYPT_EAL_PkeyPub pubKey = { 0 };
pubKey.id = CRYPT_PKEY_ML_DSA;
pubKey.key.mldsaPub.len = testPubKey->len;
pubKey.key.mldsaPub.data = testPubKey->x;
ret = CRYPT_EAL_PkeySetPub(ctx, &pubKey);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_MAX, msg->x, msg->len, sign->x, sign->len);
ASSERT_EQ(ret, CRYPT_SUCCESS);
CRYPT_EAL_PkeyCtx *ctx2 = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx2 = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
#else
ctx2 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
#endif
ASSERT_TRUE(ctx2 != NULL);
val = (uint32_t)type;
ret = CRYPT_EAL_PkeySetParaById(ctx2, val);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyGen(ctx2);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyGetPub(ctx2, &pubKey);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_EQ(pubKey.key.mldsaPub.len, testPubKey->len);
ret = CRYPT_EAL_PkeyGetPrv(ctx2, &prvKey);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_EQ(prvKey.key.mldsaPrv.len, testPrvKey->len);
val = 1;
ret = CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_PREHASH_FLAG, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeySign(ctx2, CRYPT_MD_SHA256, msg->x, msg->len, out, &outLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyVerify(ctx2, CRYPT_MD_SHA256, msg->x, msg->len, out, outLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyCmp(ctx, ctx2);
ASSERT_NE(ret, CRYPT_SUCCESS);
CRYPT_EAL_PkeyCtx *ctx3 = CRYPT_EAL_PkeyDupCtx(ctx);
ASSERT_TRUE(ctx3 != NULL);
ret = CRYPT_EAL_PkeyCmp(ctx, ctx3);
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_EAL_PkeyFreeCtx(ctx2);
CRYPT_EAL_PkeyFreeCtx(ctx3);
BSL_SAL_Free(out);
TestRandDeInit();
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/mldsa/test_suite_sdv_mldsa.c | C | unknown | 21,851 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "securec.h"
#include "hitls_build.h"
#include "bsl_err.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "crypt_algid.h"
#include "crypt_mldsa.h"
#include "ml_dsa_local.h"
#include "crypt_eal_pkey.h"
#include "eal_pkey_local.h"
/* END_HEADER */
/* @
* @test SDV_CRYPTO_MLDSA_CHECK_KEYPAIR_TC001
* @spec -
* @title Key pair generation function test
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLDSA_CHECK_KEYPAIR_TC001(int type)
{
#if !defined(HITLS_CRYPTO_MLDSA_CHECK)
(void)type;
SKIP_TEST();
#else
TestMemInit();
TestRandInit();
CRYPT_EAL_PkeyCtx *ctx = NULL;
CRYPT_EAL_PkeyCtx *pubCtx = NULL;
CRYPT_EAL_PkeyCtx *prvCtx = NULL;
CRYPT_EAL_PkeyPrv prvKey = { 0 };
CRYPT_EAL_PkeyPub pubKey = { 0 };
uint32_t prvKeyLen = 4896; // max len = 4896
uint32_t pubKeyLen = 2592; // max len = 2592
uint8_t *prvKeyBuf = BSL_SAL_Malloc(prvKeyLen);
uint8_t *pubKeyBuf = BSL_SAL_Malloc(pubKeyLen);
#ifdef HITLS_CRYPTO_PROVIDER
ctx = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
pubCtx = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
prvCtx = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
#else
ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
pubCtx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
prvCtx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
#endif
ASSERT_TRUE(pubKeyBuf != NULL);
ASSERT_TRUE(prvKeyBuf != NULL);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(pubCtx != NULL);
ASSERT_TRUE(prvCtx != NULL);
prvKey.id = CRYPT_PKEY_ML_DSA;
pubKey.id = CRYPT_PKEY_ML_DSA;
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx, type), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pubCtx, type), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(prvCtx, type), CRYPT_SUCCESS);
prvKey.key.mldsaPrv.len = prvKeyLen;
prvKey.key.mldsaPrv.data = prvKeyBuf;
pubKey.key.mldsaPub.len = pubKeyLen;
pubKey.key.mldsaPub.data = pubKeyBuf;
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx, ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctx, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubCtx, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(prvCtx, pubCtx), CRYPT_MLDSA_INVALID_PUBKEY); // no pub
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, pubCtx), CRYPT_MLDSA_INVALID_PRVKEY); // no prv
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_EAL_PkeyFreeCtx(pubCtx);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
BSL_SAL_Free(prvKeyBuf);
BSL_SAL_Free(pubKeyBuf);
TestRandDeInit();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLDSA_CHECK_KEYPAIR_TC002
* @spec -
* @title Key pair generation function invalid test
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLDSA_CHECK_KEYPAIR_TC002(void)
{
#if !defined(HITLS_CRYPTO_MLDSA_CHECK)
SKIP_TEST();
#else
TestMemInit();
TestRandInit();
int32_t bits1 = CRYPT_MLDSA_TYPE_MLDSA_44;
int32_t bits2 = CRYPT_MLDSA_TYPE_MLDSA_65;
CRYPT_EAL_PkeyCtx *ctx1 = NULL;
CRYPT_EAL_PkeyCtx *ctx2 = NULL;
CRYPT_EAL_PkeyCtx *ctx3 = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx1 = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
ctx2 = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
ctx3 = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
#else
ctx1 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
ctx2 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
ctx3 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
#endif
ASSERT_TRUE(ctx1 != NULL);
ASSERT_TRUE(ctx2 != NULL);
ASSERT_TRUE(ctx3 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(NULL, NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx2), CRYPT_MLDSA_KEYINFO_NOT_SET); // different key-info
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx1, bits1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx2, bits1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx3, bits2), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx2), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx2, ctx2), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx2), CRYPT_MLDSA_PAIRWISE_CHECK_FAIL);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
CRYPT_EAL_PkeyFreeCtx(ctx3);
TestRandDeInit();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLDSA_CHECK_PRVKEY_TC001
* @spec -
* @title Key generation and check prv key
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLDSA_CHECK_PRVKEY_TC001(int type)
{
#if !defined(HITLS_CRYPTO_MLDSA_CHECK)
(void)type;
SKIP_TEST();
#else
TestMemInit();
TestRandInit();
CRYPT_EAL_PkeyCtx *ctx = NULL;
CRYPT_EAL_PkeyCtx *prvCtx = NULL;
CRYPT_EAL_PkeyPrv sk = { 0 };
uint32_t skLen = 0;
CRYPT_ML_DSA_Ctx *tmp = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
prvCtx = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
#else
ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
prvCtx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
#endif
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(prvCtx != NULL);
uint32_t val = (uint32_t)type;
sk.id = CRYPT_PKEY_ML_DSA;
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(prvCtx), CRYPT_MLDSA_KEYINFO_NOT_SET);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx, val), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(prvCtx, val), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PRVKEY_LEN, &skLen, sizeof(skLen)), CRYPT_SUCCESS);
sk.key.mldsaPrv.len = skLen;
sk.key.mldsaPrv.data = BSL_SAL_Malloc(skLen);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, &sk), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(prvCtx), CRYPT_MLDSA_INVALID_PRVKEY); // no dk
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &sk), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(prvCtx), CRYPT_SUCCESS); // dk is set
tmp = (CRYPT_ML_DSA_Ctx *)prvCtx->key;
tmp->prvLen = 1;
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(prvCtx), CRYPT_MLDSA_INVALID_PRVKEY); // dk is set
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
BSL_SAL_Free(sk.key.mldsaPrv.data);
TestRandDeInit();
#endif
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/mldsa/test_suite_sdv_mldsa_util.c | C | unknown | 7,715 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "crypt_algid.h"
#include "crypt_eal_pkey.h"
#include "crypt_util_rand.h"
#include "eal_pkey_local.h"
#include "securec.h"
#include "crypt_mlkem.h"
#include "ml_kem_local.h"
/* END_HEADER */
static uint8_t gKyberRandBuf[3][32] = { 0 };
uint32_t gKyberRandNum = 0;
static int32_t TEST_KyberRandom(uint8_t *randNum, uint32_t randLen)
{
memcpy_s(randNum, randLen, gKyberRandBuf[gKyberRandNum], 32);
gKyberRandNum++;
return 0;
}
static int32_t TEST_KyberRandomEx(void *libCtx, uint8_t *randNum, uint32_t randLen)
{
(void)libCtx;
return TEST_KyberRandom(randNum, randLen);
}
/* @
* @test SDV_CRYPTO_MLKEM_CTRL_API_TC001
* @spec -
* @title CRYPT_EAL_PkeyCtrl test
* @precon nan
* @brief 1. creat context
* 2.invoke CRYPT_EAL_PkeyCtrl to transfer various exception parameters.
* 3.call CRYPT_EAL_PkeyCtrl repeatedly to set the key information.
* @expect 1.success 2.returned as expected 3.cannot be set repeatedly.
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLKEM_CTRL_API_TC001(int bits)
{
TestMemInit();
CRYPT_RandRegist(TestSimpleRand);
CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_KEM);
uint32_t val = (uint32_t)bits;
int ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_PARA_BY_ID + 100, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_MLKEM_CTRL_NOT_SUPPORT);
ret = CRYPT_EAL_PkeyCtrl(NULL, CRYPT_CTRL_SET_PARA_BY_ID, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_PARA_BY_ID, NULL, sizeof(val));
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_PARA_BY_ID, &val, sizeof(val) - 1);
ASSERT_EQ(ret, CRYPT_INVALID_ARG);
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_PARA_BY_ID, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_PARA_BY_ID, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_MLKEM_CTRL_INIT_REPEATED);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_RandRegist(NULL);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLKEM_KEYGEN_API_TC001
* @spec -
* @title CRYPT_EAL_PkeyGen test
* @precon nan
* @brief 1.register a random number and create a context.
* 2.invoke CRYPT_EAL_PkeyGen and transfer various parameters.
* 3.check the return value.
* @expect 1.success 2.success 3.the returned value is the same as expected.
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLKEM_KEYGEN_API_TC001(int bits)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_KEM, CRYPT_EAL_PKEY_KEM_OPERATE, "provider=default");
#else
ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_KEM);
#endif
ASSERT_TRUE(ctx != NULL);
int32_t ret = CRYPT_EAL_PkeyGen(ctx);
ASSERT_EQ(ret, CRYPT_MLKEM_KEYINFO_NOT_SET);
uint32_t val = (uint32_t)bits;
ret = CRYPT_EAL_PkeySetParaById(ctx, val);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyEncapsInit(ctx, NULL);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyGen(ctx);
ASSERT_EQ(ret, CRYPT_NO_REGIST_RAND);
CRYPT_RandRegist(TestSimpleRand);
CRYPT_RandRegistEx(TestSimpleRandEx);
ret = CRYPT_EAL_PkeyGen(ctx);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyGen(ctx);
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
return;
}
/* END_CASE */
/* Use default random numbers for end-to-end testing */
/* BEGIN_CASE */
void SDV_CRYPTO_MLKEM_KEYGEN_API_TC002(int bits)
{
TestMemInit();
TestRandInit();
CRYPT_EAL_PkeyCtx *ctx = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_KEM, CRYPT_EAL_PKEY_KEM_OPERATE, "provider=default");
#else
ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_KEM);
#endif
ASSERT_TRUE(ctx != NULL);
uint32_t val = (uint32_t)bits;
int32_t ret = CRYPT_EAL_PkeySetParaById(ctx, val);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyEncapsInit(ctx, NULL);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyGen(ctx);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyGen(ctx);
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
TestRandDeInit();
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLKEM_ENCAPS_API_TC001
* @spec -
* @title CRYPT_EAL_PkeyEncaps test
* @precon nan
* @brief 1.register a random number and generate a context and key pair.
* 2.call CRYPT_EAL_PkeyEncaps to transfer abnormal values.
* 3. check the return value.
* @expect 1.success 2.success 3.the returned value is the same as expected.
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLKEM_ENCAPS_API_TC001(int bits)
{
TestMemInit();
TestRandInit();
CRYPT_EAL_PkeyCtx *ctx = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_KEM, CRYPT_EAL_PKEY_KEM_OPERATE, "provider=default");
#else
ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_KEM);
#endif
ASSERT_TRUE(ctx != NULL);
uint32_t val = (uint32_t)bits;
int32_t ret = CRYPT_EAL_PkeySetParaById(ctx, val);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyEncapsInit(ctx, NULL);
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t cipherLen = 0;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_CIPHERTEXT_LEN, &cipherLen, sizeof(cipherLen));
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint8_t *ciphertext = BSL_SAL_Malloc(cipherLen);
uint32_t sharedLen = 32;
uint8_t *sharedKey = BSL_SAL_Malloc(sharedLen);
ret = CRYPT_EAL_PkeyGen(ctx);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyEncaps(NULL, ciphertext, &cipherLen, sharedKey, &sharedLen);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_PkeyEncaps(ctx, NULL, &cipherLen, sharedKey, &sharedLen);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_PkeyEncaps(ctx, ciphertext, NULL, sharedKey, &sharedLen);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_PkeyEncaps(ctx, ciphertext, &cipherLen, NULL, &sharedLen);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_PkeyEncaps(ctx, ciphertext, &cipherLen, sharedKey, NULL);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
cipherLen = cipherLen - 1;
ret = CRYPT_EAL_PkeyEncaps(ctx, ciphertext, &cipherLen, sharedKey, &sharedLen);
ASSERT_EQ(ret, CRYPT_MLKEM_LEN_NOT_ENOUGH);
cipherLen = cipherLen + 1;
sharedLen = sharedLen - 1;
ret = CRYPT_EAL_PkeyEncaps(ctx, ciphertext, &cipherLen, sharedKey, &sharedLen);
ASSERT_EQ(ret, CRYPT_MLKEM_LEN_NOT_ENOUGH);
sharedLen = sharedLen + 1;
ret = CRYPT_EAL_PkeyEncaps(ctx, ciphertext, &cipherLen, sharedKey, &sharedLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
BSL_SAL_Free(ciphertext);
BSL_SAL_Free(sharedKey);
TestRandDeInit();
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLKEM_DECAPS_API_TC001
* @spec -
* @title CRYPT_EAL_PkeyEncaps test
* @precon nan
* @brief 1.register a random number and generate a context and key pair.
* 2.call CRYPT_EAL_PkeyDecaps to transfer various abnormal values.
* 3.check return value
* @expect 1.success 2.success 3.the returned value is the same as expected.
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLKEM_DECAPS_API_TC001(int bits)
{
TestMemInit();
TestRandInit();
CRYPT_EAL_PkeyCtx *ctx = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_KEM, CRYPT_EAL_PKEY_KEM_OPERATE, "provider=default");
#else
ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_KEM);
#endif
ASSERT_TRUE(ctx != NULL);
uint32_t val = (uint32_t)bits;
int32_t ret = CRYPT_EAL_PkeySetParaById(ctx, val);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyDecapsInit(ctx, NULL);
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t cipherLen = 0;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_CIPHERTEXT_LEN, &cipherLen, sizeof(cipherLen));
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint8_t *ciphertext = BSL_SAL_Malloc(cipherLen);
uint32_t sharedLen = 32;
uint8_t *sharedKey = BSL_SAL_Malloc(sharedLen);
ret = CRYPT_EAL_PkeyGen(ctx);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyEncaps(ctx, ciphertext, &cipherLen, sharedKey, &sharedLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyDecaps(NULL, ciphertext, cipherLen, sharedKey, &sharedLen);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_PkeyDecaps(ctx, NULL, cipherLen, sharedKey, &sharedLen);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_PkeyDecaps(ctx, ciphertext, cipherLen, NULL, &sharedLen);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_PkeyDecaps(ctx, ciphertext, cipherLen, sharedKey, NULL);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
cipherLen = cipherLen - 1;
ret = CRYPT_EAL_PkeyDecaps(ctx, ciphertext, cipherLen, sharedKey, &sharedLen);
ASSERT_EQ(ret, CRYPT_MLKEM_LEN_NOT_ENOUGH);
cipherLen = cipherLen + 1;
sharedLen = sharedLen - 1;
ret = CRYPT_EAL_PkeyDecaps(ctx, ciphertext, cipherLen, sharedKey, &sharedLen);
ASSERT_EQ(ret, CRYPT_MLKEM_LEN_NOT_ENOUGH);
sharedLen = sharedLen + 1;
ret = CRYPT_EAL_PkeyDecaps(ctx, ciphertext, cipherLen, sharedKey, &sharedLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
BSL_SAL_Free(ciphertext);
BSL_SAL_Free(sharedKey);
TestRandDeInit();
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLKEM_SETPUB_API_TC002
* @spec -
* @title CRYPT_EAL_PkeySetPub and CRYPT_EAL_PkeyGetPub
* @precon nan
* @brief 1.register a random number and create a context.
* 2.call CRYPT_EAL_PkeySetPub and CRYPT_EAL_PkeyGetPub and transfer various parameters.
* 3.check return value
* @expect 1.success 2.success 3.the returned value is the same as expected.
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLKEM_SETPUB_API_TC002(int bits, Hex *testEK)
{
TestMemInit();
CRYPT_RandRegist(TestSimpleRand);
CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_KEM);
uint32_t val = (uint32_t)bits;
int ret = CRYPT_EAL_PkeySetParaById(ctx, val);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyEncapsInit(ctx, NULL);
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t encapsKeyLen = 0;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PUBKEY_LEN, &encapsKeyLen, sizeof(encapsKeyLen));
ASSERT_EQ(ret, CRYPT_SUCCESS);
CRYPT_EAL_PkeyPub ek = { 0 };
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &ek), CRYPT_EAL_ERR_ALGID);
ek.id = CRYPT_PKEY_ML_KEM;
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &ek), CRYPT_NULL_INPUT);
ek.key.kemEk.data = BSL_SAL_Malloc(encapsKeyLen);
(void)memcpy_s(ek.key.kemEk.data, encapsKeyLen, testEK->x, testEK->len);
ek.key.kemEk.len = encapsKeyLen - 1;
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &ek), CRYPT_MLKEM_KEYLEN_ERROR);
ek.key.kemEk.len = encapsKeyLen;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctx, &ek), CRYPT_MLKEM_KEY_NOT_SET);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &ek), CRYPT_SUCCESS);
(void)memset_s(ek.key.kemEk.data, encapsKeyLen, 0, encapsKeyLen);
ek.key.kemEk.len = encapsKeyLen - 1;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctx, &ek), CRYPT_MLKEM_KEYLEN_ERROR);
ek.key.kemEk.len = encapsKeyLen + 1;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctx, &ek), CRYPT_SUCCESS);
ASSERT_COMPARE("compare ek", ek.key.kemEk.data, ek.key.kemEk.len, testEK->x, testEK->len);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
BSL_SAL_Free(ek.key.kemEk.data);
CRYPT_RandRegist(NULL);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLKEM_SETPRV_API_TC002
* @spec -
* @title CRYPT_EAL_PkeySetPrv and CRYPT_EAL_PkeyGetPrv
* @precon nan
* @brief 1.register a random number and create a context.
* 2.call CRYPT_EAL_PkeySetPrv and CRYPT_EAL_PkeyGetPrv and transfer various parameters.
* 3.check return value
* @expect 1.success 2.success 3.the returned value is the same as expected.
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLKEM_SETPRV_API_TC002(int bits, Hex *testDK)
{
TestMemInit();
CRYPT_RandRegist(TestSimpleRand);
CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_KEM);
uint32_t val = (uint32_t)bits;
int ret = CRYPT_EAL_PkeySetParaById(ctx, val);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyEncapsInit(ctx, NULL);
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t decapsKeyLen = 0;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PRVKEY_LEN, &decapsKeyLen, sizeof(decapsKeyLen));
ASSERT_EQ(ret, CRYPT_SUCCESS);
CRYPT_EAL_PkeyPrv dk = { 0 };
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &dk), CRYPT_EAL_ERR_ALGID);
dk.id = CRYPT_PKEY_ML_KEM;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &dk), CRYPT_NULL_INPUT);
dk.key.kemDk.data = BSL_SAL_Malloc(decapsKeyLen);
(void)memcpy_s(dk.key.kemDk.data, decapsKeyLen, testDK->x, testDK->len);
dk.key.kemDk.len = decapsKeyLen - 1;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &dk), CRYPT_MLKEM_KEYLEN_ERROR);
dk.key.kemDk.len = decapsKeyLen;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, &dk), CRYPT_MLKEM_KEY_NOT_SET);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &dk), CRYPT_SUCCESS);
(void)memset_s(dk.key.kemDk.data, decapsKeyLen, 0, decapsKeyLen);
dk.key.kemDk.len = decapsKeyLen - 1;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, &dk), CRYPT_MLKEM_KEYLEN_ERROR);
dk.key.kemDk.len = decapsKeyLen;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, &dk), CRYPT_SUCCESS);
ASSERT_COMPARE("compare de", dk.key.kemDk.data, dk.key.kemDk.len, testDK->x, testDK->len);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
BSL_SAL_Free(dk.key.kemDk.data);
CRYPT_RandRegist(NULL);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLKEM_KEYCMP_FUNC_TC001
* @spec -
* @title Context Comparison and Copy Test
* @precon nan
* @brief 1.Registers a random number that returns the specified value.
* 2. Call CRYPT_EAL_PkeyGen to generate a key pair. The first two groups of random numbers are the same,
* and the third group of random numbers is different.
* 3. Call CRYPT_EAL_PkeyCopyCtx to copy the key pair.
* 4. Invoke CRYPT_EAL_PkeyCmp to compare key pairs.
* @expect 1.success 2.success 3.success 4.the returned value is the same as expected.
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLKEM_KEYCMP_FUNC_TC001(int bits, Hex *r0, Hex *r1, Hex *r2, int isProvider)
{
TestMemInit();
gKyberRandNum = 0;
memcpy_s(gKyberRandBuf[0], 32, r0->x, r0->len);
memcpy_s(gKyberRandBuf[1], 32, r1->x, r1->len);
memcpy_s(gKyberRandBuf[2], 32, r2->x, r2->len);
CRYPT_RandRegist(TEST_KyberRandom);
CRYPT_RandRegistEx(TEST_KyberRandomEx);
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_ML_KEM, CRYPT_EAL_PKEY_KEM_OPERATE,
"provider=default", isProvider);
ASSERT_NE(ctx, NULL);
uint32_t val = (uint32_t)bits;
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx, val), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyEncapsInit(ctx, NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx, NULL), CRYPT_NULL_INPUT);
gKyberRandNum = 0;
CRYPT_EAL_PkeyCtx *ctx2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_ML_KEM, CRYPT_EAL_PKEY_KEM_OPERATE,
"provider=default", isProvider);
ASSERT_NE(ctx2, NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx, ctx2), CRYPT_MLKEM_KEY_NOT_EQUAL);
val = (uint32_t)bits;
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx2, val), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx, ctx2), CRYPT_MLKEM_KEY_NOT_EQUAL);
ASSERT_EQ(CRYPT_EAL_PkeyEncapsInit(ctx2, NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx, ctx2), CRYPT_MLKEM_KEY_NOT_EQUAL);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx2), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx, ctx2), CRYPT_SUCCESS);
gKyberRandNum = 1;
CRYPT_EAL_PkeyCtx *ctx3 = TestPkeyNewCtx(NULL, CRYPT_PKEY_ML_KEM, CRYPT_EAL_PKEY_KEM_OPERATE,
"provider=default", isProvider);
ASSERT_NE(ctx3, NULL);
val = (uint32_t)bits;
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx3, val), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyEncapsInit(ctx3, NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx3), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx, ctx3), CRYPT_MLKEM_KEY_NOT_EQUAL);
CRYPT_EAL_PkeyCtx *ctx4 = BSL_SAL_Calloc(1u, sizeof(CRYPT_EAL_PkeyCtx));
ASSERT_EQ(CRYPT_EAL_PkeyCopyCtx(ctx4, ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx, ctx4), CRYPT_SUCCESS);
CRYPT_EAL_PkeyCtx *ctx5 = CRYPT_EAL_PkeyDupCtx(ctx);
ASSERT_TRUE(ctx5 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx, ctx5), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_EAL_PkeyFreeCtx(ctx2);
CRYPT_EAL_PkeyFreeCtx(ctx3);
CRYPT_EAL_PkeyFreeCtx(ctx4);
CRYPT_EAL_PkeyFreeCtx(ctx5);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLKEM_KEYGEN_FUNC_TC001
* @spec -
* @title Generating a Key Pair
* @precon nan
* @brief
* 1. Register a random number and return the specified random number of the test vector.
* 2. Call CRYPT_EAL_PkeyGen to generate a key pair.
* 3. Compare key pairs and test vectors.
* @expect
* 1. success
* 2. success
* 3. the key pair is the same as the test vector.
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLKEM_KEYGEN_FUNC_TC001(int bits, Hex *z, Hex *d, Hex *testEK, Hex *testDK, int isProvider)
{
TestMemInit();
gKyberRandNum = 0;
memcpy_s(gKyberRandBuf[0], 32, d->x, d->len);
memcpy_s(gKyberRandBuf[1], 32, z->x, z->len);
CRYPT_RandRegist(TEST_KyberRandom);
CRYPT_RandRegistEx(TEST_KyberRandomEx);
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_ML_KEM, CRYPT_EAL_PKEY_KEM_OPERATE,
"provider=default", isProvider);
ASSERT_NE(ctx, NULL);
uint32_t val = (uint32_t)bits;
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx, val), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyEncapsInit(ctx, NULL), CRYPT_SUCCESS);
uint32_t encapsKeyLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PUBKEY_LEN, &encapsKeyLen, sizeof(encapsKeyLen)), CRYPT_SUCCESS);
uint32_t decapsKeyLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PRVKEY_LEN, &decapsKeyLen, sizeof(decapsKeyLen)), CRYPT_SUCCESS);
CRYPT_EAL_PkeyPub ek = { 0 };
ek.id = CRYPT_PKEY_ML_KEM;
ek.key.kemEk.len = encapsKeyLen;
ek.key.kemEk.data = BSL_SAL_Malloc(encapsKeyLen);
CRYPT_EAL_PkeyPrv dk = { 0 };
dk.id = CRYPT_PKEY_ML_KEM;
dk.key.kemDk.len = decapsKeyLen;
dk.key.kemDk.data = BSL_SAL_Malloc(decapsKeyLen);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctx, &ek), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, &dk), CRYPT_SUCCESS);
ASSERT_COMPARE("compare ek", ek.key.kemEk.data, ek.key.kemEk.len, testEK->x, testEK->len);
ASSERT_COMPARE("compare dk", dk.key.kemDk.data, dk.key.kemDk.len, testDK->x, testDK->len);
EXIT:
BSL_SAL_Free(ek.key.kemEk.data);
BSL_SAL_Free(dk.key.kemDk.data);
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLKEM_ENCAPS_DECAPS_FUNC_TC001
* @spec -
* @title Vector test for generating ciphertext, shared key, and decapsulation
* @precon nan
* @brief
* 1. Register a random number and return the specified random number of the test vector.
* 2. Call CRYPT_EAL_PkeyEncaps to generate the ciphertext and shared key.
* 3. Compare the ciphertext and shared key with the test vector.
* 4. Call CRYPT_EAL_PkeyDecaps to generate a shared key.
* 5. Compare the shared key with the test vector.
* @expect 1. Success 2. Success 3. The generation result is the same as expected 4. Success
* 5. The generation result is the same as expected
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLKEM_ENCAPS_DECAPS_FUNC_TC001(int bits, Hex *m, Hex *testEK, Hex *testDK, Hex *testCT, Hex *testSK, int isProvider)
{
TestMemInit();
gKyberRandNum = 0;
memcpy_s(gKyberRandBuf[0], 32, m->x, m->len);
CRYPT_RandRegist(TEST_KyberRandom);
CRYPT_RandRegistEx(TEST_KyberRandomEx);
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_ML_KEM, CRYPT_EAL_PKEY_KEM_OPERATE,
"provider=default", isProvider);
ASSERT_NE(ctx, NULL);
uint32_t val = (uint32_t)bits;
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx, val), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyEncapsInit(ctx, NULL), CRYPT_SUCCESS);
uint32_t encapsKeyLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PUBKEY_LEN, &encapsKeyLen, sizeof(encapsKeyLen)), CRYPT_SUCCESS);
uint32_t decapsKeyLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PRVKEY_LEN, &decapsKeyLen, sizeof(decapsKeyLen)), CRYPT_SUCCESS);
uint32_t cipherLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_CIPHERTEXT_LEN, &cipherLen, sizeof(cipherLen)), CRYPT_SUCCESS);
CRYPT_EAL_PkeyPub ek = { 0 };
ek.id = CRYPT_PKEY_ML_KEM;
ek.key.kemEk.len = encapsKeyLen;
ek.key.kemEk.data = BSL_SAL_Malloc(encapsKeyLen);
(void)memcpy_s(ek.key.kemEk.data, ek.key.kemEk.len, testEK->x, testEK->len);
CRYPT_EAL_PkeyPrv dk = { 0 };
dk.id = CRYPT_PKEY_ML_KEM;
dk.key.kemDk.len = decapsKeyLen;
dk.key.kemDk.data = BSL_SAL_Malloc(decapsKeyLen);
(void)memcpy_s(dk.key.kemDk.data, dk.key.kemDk.len, testDK->x, testDK->len);
uint8_t *ciphertext = BSL_SAL_Malloc(cipherLen);
uint32_t sharedLen = 32;
uint8_t *sharedKey = BSL_SAL_Malloc(sharedLen);
uint32_t decSharedLen = 32;
uint8_t *decSharedKey = BSL_SAL_Malloc(decSharedLen);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &ek), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyEncaps(ctx, ciphertext, &cipherLen, sharedKey, &sharedLen), CRYPT_SUCCESS);
ASSERT_COMPARE("compare ct", ciphertext, cipherLen, testCT->x, testCT->len);
ASSERT_COMPARE("compare sk", sharedKey, sharedLen, testSK->x, testSK->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &dk), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyDecaps(ctx, testCT->x, testCT->len, decSharedKey, &decSharedLen), CRYPT_SUCCESS);
ASSERT_COMPARE("compare dec sk", decSharedKey, decSharedLen, testSK->x, testSK->len);
EXIT:
BSL_SAL_Free(ek.key.kemEk.data);
BSL_SAL_Free(dk.key.kemDk.data);
BSL_SAL_Free(ciphertext);
BSL_SAL_Free(sharedKey);
BSL_SAL_Free(decSharedKey);
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLKEM_DECAPS_FUNC_TC001
* @spec -
* @title Vector test using ciphertext and shared key decapsulation
* @precon nan
* @brief
* 1. Set the decapsulation key.
* 2. Invoke CRYPT_EAL_PkeyDecaps to generate a shared key.
* 3. Compare the shared key with the test vector.
* @expect 1. Succeeded 2. Succeeded 3. The generation result is the same as expected.
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLKEM_DECAPS_FUNC_TC001(int bits, Hex *testDK, Hex *testCT, Hex *testSK, int isProvider)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_ML_KEM, CRYPT_EAL_PKEY_KEM_OPERATE,
"provider=default", isProvider);
ASSERT_NE(ctx, NULL);
uint32_t val = (uint32_t)bits;
int ret = CRYPT_EAL_PkeySetParaById(ctx, val);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyDecapsInit(ctx, NULL);
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t decapsKeyLen = 0;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PRVKEY_LEN, &decapsKeyLen, sizeof(decapsKeyLen));
ASSERT_EQ(ret, CRYPT_SUCCESS);
CRYPT_EAL_PkeyPrv dk = { 0 };
dk.id = CRYPT_PKEY_ML_KEM;
dk.key.kemDk.len = decapsKeyLen;
dk.key.kemDk.data = BSL_SAL_Malloc(decapsKeyLen);
(void)memcpy_s(dk.key.kemDk.data, dk.key.kemDk.len, testDK->x, testDK->len);
uint32_t sharedLen = 32;
uint8_t *sharedKey = BSL_SAL_Malloc(sharedLen);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &dk), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyDecaps(ctx, testCT->x, testCT->len, sharedKey, &sharedLen), CRYPT_SUCCESS);
ASSERT_COMPARE("compare sk", sharedKey, sharedLen, testSK->x, testSK->len);
EXIT:
BSL_SAL_Free(dk.key.kemDk.data);
BSL_SAL_Free(sharedKey);
CRYPT_EAL_PkeyFreeCtx(ctx);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLKEM_PKEYNEWCTX_API_TC001
* @spec -
* @title CRYPT_EAL_PkeyNewCtx interface test
* @precon nan
* @brief 1. The input parameter is the ID of the algorithm that does not support key generation CRYPT_MD_SHA256.
* 2. The input parameter is - 1.
* 3. The input parameter is CRYPT_PKEY_MAX + 1.
* @expect 1. Failure 2. Failure 3. Failure
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLKEM_PKEYNEWCTX_API_TC001()
{
TestMemInit();
CRYPT_RandRegist(TestSimpleRand);
CRYPT_EAL_PkeyCtx *ctx1 = CRYPT_EAL_PkeyNewCtx((CRYPT_PKEY_AlgId)CRYPT_MD_SHA256);
ASSERT_TRUE(ctx1 == NULL);
CRYPT_EAL_PkeyCtx *ctx2 = CRYPT_EAL_PkeyNewCtx(-1);
ASSERT_TRUE(ctx2 == NULL);
CRYPT_EAL_PkeyCtx *ctx3 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_MAX + 1);
ASSERT_TRUE(ctx3 == NULL);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
CRYPT_EAL_PkeyFreeCtx(ctx3);
CRYPT_RandRegist(NULL);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLKEM_ABNORMAL_DECAPS_FUNC_TC001
* @spec -
* @title Invalid ciphertext. Decapsulation failed.
* @precon nan
* @brief 1. Generate a key pair.
* 2. Call CRYPT_EAL_PkeyEncaps for encapsulation.
* 3. Modify the content in ciphertext and call CRYPT_EAL_PkeyDecaps for decapsulation.
* 4. Inconsistent sharedKeys
* @expect 1. Success 2. Success 3. Success 4. Inconsistency
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLKEM_ABNORMAL_DECAPS_FUNC_TC001(int bits, Hex *m, Hex *testEK, Hex *testDK, Hex *testCT, Hex *testSK, Hex *changeCT)
{
TestMemInit();
gKyberRandNum = 0;
memcpy_s(gKyberRandBuf[0], 32, m->x, m->len);
CRYPT_RandRegist(TEST_KyberRandom);
CRYPT_RandRegistEx(TEST_KyberRandomEx);
CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_KEM);
uint32_t val = (uint32_t)bits;
uint32_t ret = CRYPT_EAL_PkeySetParaById(ctx, val);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyEncapsInit(ctx, NULL);
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t encapsKeyLen = 0;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PUBKEY_LEN, &encapsKeyLen, sizeof(encapsKeyLen));
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t decapsKeyLen = 0;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PRVKEY_LEN, &decapsKeyLen, sizeof(decapsKeyLen));
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t cipherLen = 0;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_CIPHERTEXT_LEN, &cipherLen, sizeof(cipherLen));
ASSERT_EQ(ret, CRYPT_SUCCESS);
CRYPT_EAL_PkeyPub ek = { 0 };
ek.id = CRYPT_PKEY_ML_KEM;
ek.key.kemEk.len = encapsKeyLen;
ek.key.kemEk.data = BSL_SAL_Malloc(encapsKeyLen);
(void)memcpy_s(ek.key.kemEk.data, ek.key.kemEk.len, testEK->x, testEK->len);
CRYPT_EAL_PkeyPrv dk = { 0 };
dk.id = CRYPT_PKEY_ML_KEM;
dk.key.kemDk.len = decapsKeyLen;
dk.key.kemDk.data = BSL_SAL_Malloc(decapsKeyLen);
(void)memcpy_s(dk.key.kemDk.data, dk.key.kemDk.len, testDK->x, testDK->len);
uint8_t *ciphertext = BSL_SAL_Malloc(cipherLen);
uint32_t sharedLen = 32;
uint8_t *sharedKey = BSL_SAL_Malloc(sharedLen);
uint32_t decSharedLen = 32;
uint8_t *decSharedKey = BSL_SAL_Malloc(decSharedLen);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &ek), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyEncaps(ctx, ciphertext, &cipherLen, sharedKey, &sharedLen), CRYPT_SUCCESS);
ASSERT_COMPARE("compare ct", ciphertext, cipherLen, testCT->x, testCT->len);
ASSERT_COMPARE("compare sk", sharedKey, sharedLen, testSK->x, testSK->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &dk), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyDecaps(ctx, changeCT->x, changeCT->len, decSharedKey, &decSharedLen), CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(sharedKey, decSharedKey, sharedLen) != 0);
EXIT:
BSL_SAL_Free(ek.key.kemEk.data);
BSL_SAL_Free(dk.key.kemDk.data);
BSL_SAL_Free(ciphertext);
BSL_SAL_Free(sharedKey);
BSL_SAL_Free(decSharedKey);
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLKEM_ABNORMAL_DECAPS_FUNC_TC002
* @spec -
* @title Invalid private key. Decapsulation failed.
* @precon nan
* @brief 1. Generate a key pair.
* 2. Call CRYPT_EAL_PkeyEncaps for encapsulation.
* 3. Call SetPrvKey to set invalid prvKey to the CTX.
* 4. Call CRYPT_EAL_PkeyDecaps for decapsulation.
* 5. Inconsistent sharedKeys
* @expect 1. Success 2. Success 3. Success 4. Success 5. Inconsistency
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLKEM_ABNORMAL_DECAPS_FUNC_TC002(int bits, Hex *m, Hex *testEK, Hex *testCT, Hex *testSK, Hex *changeDK)
{
TestMemInit();
gKyberRandNum = 0;
memcpy_s(gKyberRandBuf[0], 32, m->x, m->len);
CRYPT_RandRegist(TEST_KyberRandom);
CRYPT_RandRegistEx(TEST_KyberRandomEx);
CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_KEM);
uint32_t val = (uint32_t)bits;
int ret = CRYPT_EAL_PkeySetParaById(ctx, val);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyEncapsInit(ctx, NULL);
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t encapsKeyLen = 0;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PUBKEY_LEN, &encapsKeyLen, sizeof(encapsKeyLen));
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t decapsKeyLen = 0;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PRVKEY_LEN, &decapsKeyLen, sizeof(decapsKeyLen));
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t cipherLen = 0;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_CIPHERTEXT_LEN, &cipherLen, sizeof(cipherLen));
ASSERT_EQ(ret, CRYPT_SUCCESS);
CRYPT_EAL_PkeyPub ek = { 0 };
ek.id = CRYPT_PKEY_ML_KEM;
ek.key.kemEk.len = encapsKeyLen;
ek.key.kemEk.data = BSL_SAL_Malloc(encapsKeyLen);
(void)memcpy_s(ek.key.kemEk.data, ek.key.kemEk.len, testEK->x, testEK->len);
CRYPT_EAL_PkeyPrv dk = { 0 };
dk.id = CRYPT_PKEY_ML_KEM;
dk.key.kemDk.len = decapsKeyLen;
dk.key.kemDk.data = BSL_SAL_Malloc(decapsKeyLen);
(void)memcpy_s(dk.key.kemDk.data, dk.key.kemDk.len, changeDK->x, changeDK->len);
uint8_t *ciphertext = BSL_SAL_Malloc(cipherLen);
uint32_t sharedLen = 32;
uint8_t *sharedKey = BSL_SAL_Malloc(sharedLen);
uint32_t decSharedLen = 32;
uint8_t *decSharedKey = BSL_SAL_Malloc(decSharedLen);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &ek), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyEncaps(ctx, ciphertext, &cipherLen, sharedKey, &sharedLen), CRYPT_SUCCESS);
ASSERT_COMPARE("compare ct", ciphertext, cipherLen, testCT->x, testCT->len);
ASSERT_COMPARE("compare sk", sharedKey, sharedLen, testSK->x, testSK->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &dk), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyDecaps(ctx, ciphertext, cipherLen, decSharedKey, &decSharedLen), CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(sharedKey, decSharedKey, sharedLen) != 0);
EXIT:
BSL_SAL_Free(ek.key.kemEk.data);
BSL_SAL_Free(dk.key.kemDk.data);
BSL_SAL_Free(ciphertext);
BSL_SAL_Free(sharedKey);
BSL_SAL_Free(decSharedKey);
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLKEM_ABNORMAL_DECAPS_FUNC_TC002
* @spec -
* @title Invalid public key. Decapsulation failed.
* @precon nan
* @brief 1. Generate a key pair.
* 2. Call CRYPT_EAL_PkeyEncaps for encapsulation.
* 3. Call SetPrvKey to set invalid prvKey to the CTX.
* 4. Call CRYPT_EAL_PkeyDecaps for decapsulation.
* 5. Inconsistent sharedKeys
* @expect 1. Success 2. Success 3. Success 4. Success 5. Failure
* @prior nan
* @auto FALSE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLKEM_ABNORMAL_DECAPS_FUNC_TC003(int bits, Hex *m, Hex *testDK, Hex *changeEK)
{
TestMemInit();
gKyberRandNum = 0;
memcpy_s(gKyberRandBuf[0], 32, m->x, m->len);
CRYPT_RandRegist(TEST_KyberRandom);
CRYPT_RandRegistEx(TEST_KyberRandomEx);
CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_KEM);
uint32_t val = (uint32_t)bits;
int ret = CRYPT_EAL_PkeySetParaById(ctx, val);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyEncapsInit(ctx, NULL);
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t encapsKeyLen = 0;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PUBKEY_LEN, &encapsKeyLen, sizeof(encapsKeyLen));
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t decapsKeyLen = 0;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PRVKEY_LEN, &decapsKeyLen, sizeof(decapsKeyLen));
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t cipherLen = 0;
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_CIPHERTEXT_LEN, &cipherLen, sizeof(cipherLen));
ASSERT_EQ(ret, CRYPT_SUCCESS);
CRYPT_EAL_PkeyPub ek = { 0 };
ek.id = CRYPT_PKEY_ML_KEM;
ek.key.kemEk.len = encapsKeyLen;
ek.key.kemEk.data = BSL_SAL_Malloc(encapsKeyLen);
(void)memcpy_s(ek.key.kemEk.data, ek.key.kemEk.len, changeEK->x, changeEK->len);
CRYPT_EAL_PkeyPrv dk = { 0 };
dk.id = CRYPT_PKEY_ML_KEM;
dk.key.kemDk.len = decapsKeyLen;
dk.key.kemDk.data = BSL_SAL_Malloc(decapsKeyLen);
(void)memcpy_s(dk.key.kemDk.data, dk.key.kemDk.len, testDK->x, testDK->len);
uint8_t *ciphertext = BSL_SAL_Malloc(cipherLen);
uint32_t sharedLen = 32;
uint8_t *sharedKey = BSL_SAL_Malloc(sharedLen);
uint32_t decSharedLen = 32;
uint8_t *decSharedKey = BSL_SAL_Malloc(decSharedLen);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &ek), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyEncaps(ctx, ciphertext, &cipherLen, sharedKey, &sharedLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &dk), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyDecaps(ctx, ciphertext, cipherLen, decSharedKey, &decSharedLen), CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(sharedKey, decSharedKey, sharedLen) != 0);
EXIT:
BSL_SAL_Free(ek.key.kemEk.data);
BSL_SAL_Free(dk.key.kemDk.data);
BSL_SAL_Free(ciphertext);
BSL_SAL_Free(sharedKey);
BSL_SAL_Free(decSharedKey);
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLKEM_KEY_PAIR_FUNC_TC001
* @spec -
* @title Key pair generation function test
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLKEM_KEY_PAIR_FUNC_TC001(int bits)
{
#if !defined(HITLS_CRYPTO_MLKEM_CHECK)
(void)bits;
SKIP_TEST();
#else
TestMemInit();
TestRandInit();
CRYPT_EAL_PkeyCtx *ctx = NULL;
CRYPT_EAL_PkeyCtx *pubCtx = NULL;
CRYPT_EAL_PkeyCtx *prvCtx = NULL;
CRYPT_EAL_PkeyPrv dk = { 0 };
CRYPT_EAL_PkeyPub ek = { 0 };
uint32_t decapsKeyLen = 0;
uint32_t encapsKeyLen = 0;
#ifdef HITLS_CRYPTO_PROVIDER
ctx = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_KEM, CRYPT_EAL_PKEY_KEM_OPERATE, "provider=default");
pubCtx = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_KEM, CRYPT_EAL_PKEY_KEM_OPERATE, "provider=default");
prvCtx = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_KEM, CRYPT_EAL_PKEY_KEM_OPERATE, "provider=default");
#else
ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_KEM);
pubCtx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_KEM);
prvCtx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_KEM);
#endif
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(pubCtx != NULL);
ASSERT_TRUE(prvCtx != NULL);
uint32_t val = (uint32_t)bits;
dk.id = CRYPT_PKEY_ML_KEM;
ek.id = CRYPT_PKEY_ML_KEM;
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx, val), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pubCtx, val), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(prvCtx, val), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PRVKEY_LEN, &decapsKeyLen, sizeof(decapsKeyLen)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PUBKEY_LEN, &encapsKeyLen, sizeof(encapsKeyLen)), CRYPT_SUCCESS);
dk.key.kemDk.len = decapsKeyLen;
dk.key.kemDk.data = BSL_SAL_Malloc(decapsKeyLen);
ek.key.kemEk.len = encapsKeyLen;
ek.key.kemEk.data = BSL_SAL_Malloc(encapsKeyLen);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, &dk), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(ctx, &ek), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &dk), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubCtx, &ek), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(prvCtx, pubCtx), CRYPT_NULL_INPUT); // no pub
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, pubCtx), CRYPT_NULL_INPUT); // no prv
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_EAL_PkeyFreeCtx(pubCtx);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
BSL_SAL_Free(dk.key.kemDk.data);
BSL_SAL_Free(ek.key.kemEk.data);
TestRandDeInit();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLKEM_KEY_PAIR_FUNC_TC002
* @spec -
* @title Key pair generation function invalid test
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLKEM_KEY_PAIR_FUNC_TC002(void)
{
#if !defined(HITLS_CRYPTO_MLKEM_CHECK)
SKIP_TEST();
#else
TestMemInit();
TestRandInit();
int32_t bits1 = CRYPT_KEM_TYPE_MLKEM_512;
int32_t bits2 = CRYPT_KEM_TYPE_MLKEM_768;
CRYPT_EAL_PkeyCtx *ctx1 = NULL;
CRYPT_EAL_PkeyCtx *ctx2 = NULL;
CRYPT_EAL_PkeyCtx *ctx3 = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx1 = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_KEM, CRYPT_EAL_PKEY_KEM_OPERATE, "provider=default");
ctx2 = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_KEM, CRYPT_EAL_PKEY_KEM_OPERATE, "provider=default");
ctx3 = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_KEM, CRYPT_EAL_PKEY_KEM_OPERATE, "provider=default");
#else
ctx1 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_KEM);
ctx2 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_KEM);
ctx3 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_KEM);
#endif
ASSERT_TRUE(ctx1 != NULL);
ASSERT_TRUE(ctx2 != NULL);
ASSERT_TRUE(ctx3 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(NULL, NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx2), CRYPT_MLKEM_KEYINFO_NOT_SET); // different key-info
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx1, bits1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx2, bits1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx3, bits2), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx2), CRYPT_NULL_INPUT); // no key.
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx2), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx2, ctx2), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx2), CRYPT_MLKEM_PAIRWISE_CHECK_FAIL);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
CRYPT_EAL_PkeyFreeCtx(ctx3);
TestRandDeInit();
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_MLKEM_PRV_KEY_FUNC_TC001
* @spec -
* @title Key generation and check prv key
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_MLKEM_PRV_KEY_FUNC_TC001(int bits)
{
#if !defined(HITLS_CRYPTO_MLKEM_CHECK)
(void)bits;
SKIP_TEST();
#else
TestMemInit();
TestRandInit();
CRYPT_EAL_PkeyCtx *ctx = NULL;
CRYPT_EAL_PkeyCtx *prvCtx = NULL;
CRYPT_EAL_PkeyPrv dk = { 0 };
uint32_t decapsKeyLen = 0;
CRYPT_ML_KEM_Ctx *tmp = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_KEM, CRYPT_EAL_PKEY_KEM_OPERATE, "provider=default");
prvCtx = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_KEM, CRYPT_EAL_PKEY_KEM_OPERATE, "provider=default");
#else
ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_KEM);
prvCtx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_KEM);
#endif
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(prvCtx != NULL);
uint32_t val = (uint32_t)bits;
dk.id = CRYPT_PKEY_ML_KEM;
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(prvCtx), CRYPT_MLKEM_KEYINFO_NOT_SET);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx, val), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(prvCtx, val), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_PRVKEY_LEN, &decapsKeyLen, sizeof(decapsKeyLen)), CRYPT_SUCCESS);
dk.key.kemDk.len = decapsKeyLen;
dk.key.kemDk.data = BSL_SAL_Malloc(decapsKeyLen);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, &dk), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(prvCtx), CRYPT_MLKEM_INVALID_PRVKEY); // no dk
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &dk), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(prvCtx), CRYPT_SUCCESS); // dk is set
tmp = (CRYPT_ML_KEM_Ctx *)prvCtx->key;
tmp->dkLen = 1;
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(prvCtx), CRYPT_MLKEM_INVALID_PRVKEY); // dk is set
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
BSL_SAL_Free(dk.key.kemDk.data);
TestRandDeInit();
#endif
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/mlkem/test_suite_sdv_mlkem.c | C | unknown | 42,041 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <pthread.h>
#include "bsl_err.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_rand.h"
#include "crypt_bn.h"
#include "eal_pkey_local.h"
#include "stub_replace.h"
#include "crypt_util_rand.h"
#include "crypt_paillier.h"
#include "paillier_local.h"
#include "bn_basic.h"
#include "securec.h"
#include "crypt_encode_decode_key.h"
/* END_HEADER */
#define CRYPT_EAL_PKEY_KEYMGMT_OPERATE 0
#define CRYPT_EAL_PKEY_CIPHER_OPERATE 1
#define CRYPT_EAL_PKEY_EXCH_OPERATE 2
#define CRYPT_EAL_PKEY_SIGN_OPERATE 4
void *malloc_fail(uint32_t size)
{
(void)size;
return NULL;
}
void SetPaillierPara(CRYPT_EAL_PkeyPara *para, Hex *p, Hex *q, uint32_t bits)
{
para->id = CRYPT_PKEY_PAILLIER;
para->para.paillierPara.p = p->x;
para->para.paillierPara.q = q->x;
para->para.paillierPara.pLen = p->len;
para->para.paillierPara.qLen = q->len;
para->para.paillierPara.bits = bits;
}
void SetPaillierPubKey(CRYPT_EAL_PkeyPub *pubKey, uint8_t *g, uint32_t gLen, uint8_t *n, uint32_t nLen, uint8_t *n2, uint32_t n2Len)
{
pubKey->id = CRYPT_PKEY_PAILLIER;
pubKey->key.paillierPub.g = g;
pubKey->key.paillierPub.gLen = gLen;
pubKey->key.paillierPub.n = n;
pubKey->key.paillierPub.nLen = nLen;
pubKey->key.paillierPub.n2 = n2;
pubKey->key.paillierPub.n2Len = n2Len;
}
void SetPaillierPrvKey(CRYPT_EAL_PkeyPrv *prvKey, uint8_t *lambda, uint32_t lambdaLen, uint8_t *mu, uint32_t muLen)
{
prvKey->id = CRYPT_PKEY_PAILLIER;
prvKey->key.paillierPrv.lambda = lambda;
prvKey->key.paillierPrv.lambdaLen = lambdaLen;
prvKey->key.paillierPrv.mu = mu;
prvKey->key.paillierPrv.muLen = muLen;
}
int32_t RandFunc(uint8_t *randNum, uint32_t randLen)
{
const int maxNum = 255;
for (uint32_t i = 0; i < randLen; i++) {
randNum[i] = (uint8_t)(rand() % maxNum);
}
return 0;
}
int32_t RandFuncEx(void *libCtx, uint8_t *randNum, uint32_t randLen)
{
(void)libCtx;
const int maxNum = 255;
for (uint32_t i = 0; i < randLen; i++) {
randNum[i] = (uint8_t)(rand() % maxNum);
}
return 0;
}
/**
* @test SDV_CRYPTO_PAILLIER_NEW_API_TC001
* @title PAILLIER CRYPT_EAL_PkeyNewCtx test.
* @precon nan
* @brief
* 1. Call the CRYPT_EAL_PkeyNewCtx method to create ctx, algId is CRYPT_PKEY_PAILLIER, expected result 1.
* 2. Release the ctx.
* 3. Repeat steps 1 to 2 for 100 times.
* @expect
* 1. The returned result is not empty.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PAILLIER_NEW_API_TC001(int isProvider)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = NULL;
/* Run 100 times */
for (int i = 0; i < 100; i++) {
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
CRYPT_EAL_PkeyFreeCtx(pkey);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PAILLIER_NEW_API_TC002
* @title PAILLIER CRYPT_EAL_PkeyNewCtx test: Malloc failed.
* @precon Mock BSL_SAL_Malloc to malloc_fail.
* @brief
* 1. Call the CRYPT_EAL_PkeyNewCtx method to create ctx, algId is CRYPT_PKEY_PAILLIER, expected result 1.
* 2. Release the ctx.
* 3. Reset the BSL_SAL_Malloc.
* @expect
* 1. Failed to create the ctx.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PAILLIER_NEW_API_TC002(int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
FuncStubInfo tmpRpInfo = {0};
STUB_Init();
ASSERT_TRUE(STUB_Replace(&tmpRpInfo, BSL_SAL_Malloc, malloc_fail) == 0);
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey == NULL);
EXIT:
STUB_Reset(&tmpRpInfo);
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PAILLIER_SET_PARA_API_TC001
* @title PAILLIER CRYPT_EAL_PkeySetPara test.
* @precon Create the context of the paillier algorithm.
*
* @brief
* 1. Call the CRYPT_EAL_PkeySetPara method:
* (1) para = NULL, expected result 1.
* (2) pLen != BN_BITS_TO_BYTES(bits), expected result 2.
* (3) qLen != BN_BITS_TO_BYTES(bits), expected result 2.
* (4) p = NULL, q = NULL, bits = 0, expected result 2.
* (4) pLen = BN_BITS_TO_BYTES(bits) qLen = BN_BITS_TO_BYTES(bits), bits != 0, expected result 3.
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_EAL_ERR_NEW_PARA_FAIL
* 3. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PAILLIER_SET_PARA_API_TC001(Hex *p, Hex *q, int bits, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPara para = {0};
SetPaillierPara(¶, p, q, bits);
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, NULL), CRYPT_NULL_INPUT);
uint32_t bytes = BN_BITS_TO_BYTES(bits);
if (p->len != bytes)
{
ASSERT_TRUE_AND_LOG("pLen != BN_BITS_TO_BYTES(bits)",
CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_MEM_ALLOC_FAIL);
}
if (q->len != bytes)
{
ASSERT_TRUE_AND_LOG("qLen != BN_BITS_TO_BYTES(bits)",
CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_MEM_ALLOC_FAIL);
}
if (p->len == bytes && q->len == bytes && bits == 0)
{
ASSERT_TRUE_AND_LOG("p = NULL, q = NULL, bits = 0",
CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_MEM_ALLOC_FAIL);
}
if (p->len == bytes && q->len == bytes && bits != 0)
{
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
}
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PAILLIER_GEN_API_TC001
* @title PAILLIER CRYPT_EAL_PkeyGen: No regist rand.
* @precon Create the contexts of the paillier algorithm and set para.
* @brief
* 1. Call the CRYPT_EAL_PkeyGen method to generate a key pair, expected result 1.
* @expect
* 1. Failed to generate a key pair, the return value is CRYPT_NO_REGIST_RAND.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PAILLIER_GEN_API_TC001(Hex *p, Hex *q, int bits, int isProvider)
{
CRYPT_EAL_PkeyPara para = {0};
SetPaillierPara(¶, p, q, bits);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey;
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_NO_REGIST_RAND);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PAILLIER_GET_PUB_API_TC001
* @title PAILLIER CRYPT_EAL_PkeyGetPub test.
* @precon 1. Create the context of the paillier algorithm.
* 2. Initialize the DRBG.
* @brief
* 1. Call the CRYPT_EAL_PkeyGetPub method without public key, expected result 1
* 2. Set para and generate a key pair, expected result 2
* 3. Call the CRYPT_EAL_PkeyGetPub method:
* (1) pkey = NULL, expected result 1.
* (2) pub = NULL, expected result 1.
* (3) n = NULL, expected result 1.
* (4) n != NULL and nLen = 0, expected result 3.
* (5) g = NULL, expected result 1.
* (6) g != NULL, gLen = 0, expected result 3.
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_SUCCESS
* 3. CRYPT_BN_BUFF_LEN_NOT_ENOUGH
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PAILLIER_GET_PUB_API_TC001(Hex *p, Hex *q, int bits, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPub pubKey = {0};
uint8_t pubG[600];
uint8_t pubN[600];
uint8_t pubN2[600];
SetPaillierPara(¶, p, q, bits);
SetPaillierPubKey(&pubKey, pubG, 600, pubN, 600, pubN2, 600);
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
/* Missing public key */
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(NULL, &pubKey), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, NULL), CRYPT_NULL_INPUT);
/* n = NULL */
pubKey.key.paillierPub.n = NULL;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_NULL_INPUT);
pubKey.key.paillierPub.n = pubN;
/* n != NULL and nLen = 0 */
pubKey.key.paillierPub.nLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_BN_BUFF_LEN_NOT_ENOUGH);
pubKey.key.paillierPub.nLen = 600;
/* g = NULL */
pubKey.key.paillierPub.g = NULL;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_NULL_INPUT);
pubKey.key.paillierPub.g = pubG;
/* g != NULL, gLen = 0 */
pubKey.key.paillierPub.gLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_BN_BUFF_LEN_NOT_ENOUGH);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PAILLIER_GET_PRV_API_TC001
* @title PAILLIER CRYPT_EAL_PkeyGetPrv: Bad private key.
* @precon 1. Create the context of the paillier algorithm.
* 2. Initialize the DRBG.
* @brief
* 1. Call the CRYPT_EAL_PkeyGetPrv method without private key, expected result 1
* 2. Set para and generate a key pair, expected result 2
* 3. Call the CRYPT_EAL_PkeyGetPrv method:
* (1) pkey = NULL, expected result 1.
* (2) prv = NULL, expected result 1.
* (3) lambda = NULL, expected result 1.
* (4) lambda != NULL and lambdaLen = 0, expected result 3.
* (5) mu = NULL, expected result 1.
* (6) mu != NULL, muLen = 0, expected result 3.
* (7) lambda != NULL, mu != NULL, lambdaLen != 0, muLen != 0, expected result 2.
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_SUCCESS
* 3. CRYPT_BN_BUFF_LEN_NOT_ENOUGH
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PAILLIER_GET_PRV_API_TC001(Hex *p, Hex *q, int bits, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPrv prvKey = {0};
CRYPT_EAL_PkeyPara para = {0};
uint8_t prvLambda[600];
uint8_t prvMu[600];
SetPaillierPrvKey(&prvKey, prvLambda, 600, prvMu, 600);
SetPaillierPara(¶, p, q, bits);
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
/* Missing private key */
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(NULL, &prvKey), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, NULL), CRYPT_NULL_INPUT);
/* lambda = NULL */
prvKey.key.paillierPrv.lambda = NULL;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey), CRYPT_PAILLIER_ERR_INPUT_VALUE);
prvKey.key.paillierPrv.lambda = prvLambda;
/* lambda != NULL and lambdaLen = 0 */
prvKey.key.paillierPrv.lambdaLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey), CRYPT_BN_BUFF_LEN_NOT_ENOUGH);
prvKey.key.paillierPrv.lambdaLen = 600;
/* mu = NULL */
prvKey.key.paillierPrv.mu = NULL;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey), CRYPT_PAILLIER_ERR_INPUT_VALUE);
prvKey.key.paillierPrv.mu = prvMu;
/* mu != NULL, muLen = 0 */
prvKey.key.paillierPrv.muLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey), CRYPT_BN_BUFF_LEN_NOT_ENOUGH);
prvKey.key.paillierPrv.muLen = 600;
/* lambda != NULL, mu != NULL, lambdaLen != 0, muLen != 0 */
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey), CRYPT_SUCCESS);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PAILLIER_SET_PRV_API_TC001
* @title PAILLIER CRYPT_EAL_PkeySetPrv: Bad private key.
* @precon Create the contexts of the paillier algorithm and set para:
* pkey1: Generate a key pair.
* pkey2: set the private key.
* @brief
* 1. Call the CRYPT_EAL_PkeySetPrv method:
* (1) pKey is NULL, expected result 1.
* (2) prv is NULL, expected result 1.
* (3) n = NULL, expected result 2.
* (4) lambda = NULL, expected result 2.
* (5) mu = NULL, expected result 2.
* (6) n2 = NULL, expected result 2.
* (7) lambdaLen = 0, expected result 2.
* (8) muLen = 0, expected result 2.
* (9) n2Len = 0, expected result 2.
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_PAILLIER_ERR_INPUT_VALUE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PAILLIER_SET_PRV_API_TC001(Hex *p, Hex *q, int bits, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyCtx *pkey2 = NULL;
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPrv prvKey = {0};
uint8_t prvMu[600];
uint8_t prvLambda[600];
uint8_t prvN[600];
uint8_t prvN2[600];
SetPaillierPrvKey(&prvKey, prvLambda, 600, prvMu, 600);
SetPaillierPara(¶, p, q, bits);
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL && pkey2 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey2, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
/*pKey is NULL*/
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(NULL, &prvKey) == CRYPT_NULL_INPUT);
/*prvKey is NULL*/
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey2, NULL) == CRYPT_NULL_INPUT);
prvKey.key.paillierPrv.n = prvN;
prvKey.key.paillierPrv.nLen = 600;
prvKey.key.paillierPrv.n2 = prvN2;
prvKey.key.paillierPrv.n2Len = 600;
/*n = NULL*/
prvKey.key.paillierPrv.n = NULL;
ASSERT_TRUE_AND_LOG("n is NULL", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_PAILLIER_ERR_INPUT_VALUE);
prvKey.key.paillierPrv.n = prvN;
/*lambda = NULL*/
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
prvKey.key.paillierPrv.lambda = NULL;
ASSERT_TRUE_AND_LOG("lambda is NULL", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_PAILLIER_ERR_INPUT_VALUE);
prvKey.key.paillierPrv.lambda = prvLambda;
/*mu = NULL*/
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
prvKey.key.paillierPrv.mu = NULL;
ASSERT_TRUE_AND_LOG("mu is NULL", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_PAILLIER_ERR_INPUT_VALUE);
prvKey.key.paillierPrv.mu = prvMu;
/*n2 = NULL*/
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
prvKey.key.paillierPrv.n2 = NULL;
ASSERT_TRUE_AND_LOG("n2 is NULL", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_PAILLIER_ERR_INPUT_VALUE);
prvKey.key.paillierPrv.n2 = prvN2;
/*lambdaLen = 0*/
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
prvKey.key.paillierPrv.lambdaLen = 0;
ASSERT_TRUE_AND_LOG("lambdaLen is 0", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_PAILLIER_ERR_INPUT_VALUE);
prvKey.key.paillierPrv.lambdaLen = 600;
/*muLen = 0*/
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
prvKey.key.paillierPrv.muLen = 0;
ASSERT_TRUE_AND_LOG("muLen is 0", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_PAILLIER_ERR_INPUT_VALUE);
prvKey.key.paillierPrv.muLen = 600;
/*n2Len = 0*/
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
prvKey.key.paillierPrv.n2Len = 0;
ASSERT_TRUE_AND_LOG("n2Len is 0", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_PAILLIER_ERR_INPUT_VALUE);
prvKey.key.paillierPrv.n2Len = 600;
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(pkey2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PAILLIER_SET_PRV_API_TC002
* @title PAILLIER CRYPT_EAL_PkeySetPrv: Specification test.
* @precon Create the contexts of the paillier algorithm and set para:
* pkey1: Generate a key pair.
* pkey2: set the private key.
* @brief
* 1. Call the CRYPT_EAL_PkeySetPrv method:
* (1) n2 is not equal to n^2, expected result 1.
* (2) n2 is equal to n^2, expceted result 2.
* @expect
* 1. CRYPT_PAILLIER_ERR_INPUT_VALUE
* 2. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PAILLIER_SET_PRV_API_TC002(Hex *p, Hex *q, Hex *n, Hex *n2, int bits, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyCtx *pkey2 = NULL;
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPrv prvKey = {0};
uint8_t prvMu[256];
uint8_t prvLambda[256];
SetPaillierPrvKey(&prvKey, prvLambda, 256, prvMu, 256);
SetPaillierPara(¶, p, q, bits);
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL && pkey2 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey2, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
prvKey.key.paillierPrv.n = n->x;
prvKey.key.paillierPrv.nLen = n->len;
prvKey.key.paillierPrv.n2 = n->x;
prvKey.key.paillierPrv.n2Len = n->len;
ASSERT_TRUE_AND_LOG("n2 is not equal to n^2", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey)
== CRYPT_PAILLIER_ERR_INPUT_VALUE);
prvKey.key.paillierPrv.n2 = n2->x;
prvKey.key.paillierPrv.n2Len = n2->len;
ASSERT_TRUE_AND_LOG("set success", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_SUCCESS);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(pkey2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PAILLIER_SET_PUB_API_TC001
* @title PAILLIER CRYPT_EAL_PkeyGetPub: Bad public key.
* @precon Create the contexts of the paillier algorithm and set para:
* pkey1: Generate a key pair.
* pkey2: Set the public key.
* @brief
* 1. Call the CRYPT_EAL_PkeyGetPub method:
* (1) pKey is NULL, expected result 1.
* (2) prv is NULL, expected result 1.
* (3) n = NULL, expected result 1.
* (4) g = NULL, expected result 1.
* (5) n2 = NULL, expected result 1.
* @expect
* 1. CRYPT_NULL_INPUT
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PAILLIER_SET_PUB_API_TC001(Hex *p, Hex *q, int bits, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyCtx *pkey2 = NULL;
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPub pubKey;
uint8_t pubG[600];
uint8_t pubN[600];
uint8_t pubN2[600];
SetPaillierPara(¶, p, q, bits);
SetPaillierPubKey(&pubKey, pubN, 600, pubG, 600, pubN2, 600);
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL && pkey2 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey2, ¶) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
/*pKey is NULL*/
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(NULL, &pubKey) == CRYPT_NULL_INPUT);
/*pubKey is NULL*/
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey2, NULL) == CRYPT_NULL_INPUT);
/*n = NULL*/
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pubKey) == CRYPT_SUCCESS);
pubKey.key.paillierPub.n = NULL;
ASSERT_TRUE_AND_LOG("lambda is NULL", CRYPT_EAL_PkeySetPub(pkey2, &pubKey) == CRYPT_NULL_INPUT);
pubKey.key.paillierPub.n = pubN;
/*g = NULL*/
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pubKey) == CRYPT_SUCCESS);
pubKey.key.paillierPub.g = NULL;
ASSERT_TRUE_AND_LOG("mu is NULL", CRYPT_EAL_PkeySetPub(pkey2, &pubKey) == CRYPT_NULL_INPUT);
pubKey.key.paillierPub.g = pubG;
/*n2 = NULL*/
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pubKey) == CRYPT_SUCCESS);
pubKey.key.paillierPub.n2 = NULL;
ASSERT_TRUE_AND_LOG("n2 is NULL", CRYPT_EAL_PkeySetPub(pkey2, &pubKey) == CRYPT_NULL_INPUT);
pubKey.key.paillierPub.n2 = pubN2;
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pubKey) == CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("set prvKey success", CRYPT_EAL_PkeySetPub(pkey2, &pubKey) == CRYPT_SUCCESS);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(pkey2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PAILLIER_SET_PUB_API_TC002
* @title PAILLIER CRYPT_EAL_PkeyGetPub: Bad public key.
* @precon Create the contexts of the paillier algorithm and set para:
* pkey1: Generate a key pair.
* pkey2: Set the public key.
* @brief
* 1. Call the CRYPT_EAL_PkeyGetPub method:
* (1) n2 is not equal to n^2, expected result 1.
* (2) n2 is equal to n^2, expceted result 2.
* @expect
* 1. CRYPT_PAILLIER_ERR_INPUT_VALUE
* 2. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PAILLIER_SET_PUB_API_TC002(Hex *p, Hex *q, Hex *n, Hex *n2, int bits, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyCtx *pkey2 = NULL;
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPub pubKey;
uint8_t pubG[128];
SetPaillierPara(¶, p, q, bits);
SetPaillierPubKey(&pubKey, pubG, 128, n->x, n->len, n2->x, n2->len);
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL && pkey2 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey2, ¶) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
pubKey.key.paillierPub.n2 = n->x;
pubKey.key.paillierPub.n2Len = n->len;
ASSERT_TRUE_AND_LOG("n2 is not equal to n^2", CRYPT_EAL_PkeySetPub(pkey2, &pubKey)
== CRYPT_PAILLIER_ERR_INPUT_VALUE);
pubKey.key.paillierPub.n2 = n2->x;
pubKey.key.paillierPub.n2Len = n2->len;
ASSERT_TRUE_AND_LOG("set success", CRYPT_EAL_PkeySetPub(pkey2, &pubKey) == CRYPT_SUCCESS);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(pkey2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PAILLIER_ENC_API_TC001
* @title PAILLIER CRYPT_EAL_PkeyEncrypt: Test the validity of input parameters.
* @precon Create the context of the paillier algorithm:
* @brief
* 1. Call the CRYPT_EAL_PkeyEncrypt method without public key, expected result 1
* 2. Set pubkey, expected result 2
* 3. Call the CRYPT_EAL_PkeyEncrypt method:
* (1) pkey = NULL, expected result 3
* (2) data = NULL, expected result 3
* (3) data != NULL dataLen > bytes of ctx, expected result 4
* (4) out = NULL, expected result 3
* (5) outLen = NULL, expected result 3
* (6) outLen = 0, expected result 5
* (7) no modification, expected result 2
* @expect
* 1. CRYPT_PAILLIER_NO_KEY_INFO
* 2. CRYPT_SUCCESS
* 3. CRYPT_NULL_INPUT
* 4. CRYPT_PAILLIER_ERR_ENC_BITS
* 5. CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PAILLIER_ENC_API_TC001(Hex *n, Hex *g, Hex *n2, Hex *in, int isProvider)
{
uint8_t crypt[512];
uint32_t cryptLen = 512;
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPub pubkey = {0};
SetPaillierPubKey(&pubkey, g->x, g->len, n->x, n->len, n2->x, n2->len);
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyEncrypt(pkey, in->x, in->len, crypt, &cryptLen), CRYPT_PAILLIER_NO_KEY_INFO);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey, &pubkey) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(NULL, in->x, in->len, crypt, &cryptLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, NULL, in->len, crypt, &cryptLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, in->x, 257, crypt, &cryptLen) == CRYPT_PAILLIER_ERR_ENC_BITS);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, in->x, in->len, NULL, &cryptLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, in->x, in->len, crypt, NULL) == CRYPT_NULL_INPUT);
cryptLen = 0;
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, in->x, in->len, crypt, &cryptLen) == CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH);
cryptLen = 512;
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, in->x, in->len, crypt, &cryptLen) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PAILLIER_DEC_API_TC001
* @title PAILLIER CRYPT_EAL_PkeyDecrypt: Test the validity of input parameters.
* @precon Create the context of the paillier algorithm:
* @brief
* 1. Call the CRYPT_EAL_PkeyDecrypt method without private key, expected result 1
* 2. Set private key, expected result 2
* 4. Call the CRYPT_EAL_PkeyDecrypt method:
* (1) pkey = NULL, expected result 3
* (2) data = NULL, expected result 3
* (3) data != NULL, dataLen = 0, expected result 4
* (4) data != NULL, dataLen is invalid , expected result 4
* (5) out = NULL, expected result 3
* (6) outLen = NULL, expected result 3
* (7) outLen = 0, expected result 5
* (8) no modification, expected result 2
* @expect
* 1. CRYPT_PAILLIER_NO_KEY_INFO
* 2. CRYPT_SUCCESS
* 3. CRYPT_NULL_INPUT
* 4. CRYPT_PAILLIER_ERR_DEC_BITS
* 5. CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PAILLIER_DEC_API_TC001(Hex *Lambda, Hex *mu, Hex *n, Hex *n2, Hex *in, int isProvider)
{
uint8_t crypt[256];
uint32_t cryptLen = 256;
CRYPT_EAL_PkeyPrv prvkey = {0};
CRYPT_EAL_PkeyCtx *pkey = NULL;
SetPaillierPrvKey(&prvkey, Lambda->x, Lambda->len, mu->x, mu->len);
prvkey.key.paillierPrv.n = n->x;
prvkey.key.paillierPrv.nLen = n->len;
prvkey.key.paillierPrv.n2 = n2->x;
prvkey.key.paillierPrv.n2Len = n2->len;
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, in->x, in->len, crypt, &cryptLen) == CRYPT_PAILLIER_NO_KEY_INFO);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey, &prvkey) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(NULL, in->x, in->len, crypt, &cryptLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, NULL, in->len, crypt, &cryptLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, in->x, 0, crypt, &cryptLen) == CRYPT_PAILLIER_ERR_DEC_BITS);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, in->x, 257, crypt, &cryptLen) == CRYPT_PAILLIER_ERR_DEC_BITS);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, in->x, in->len, NULL, &cryptLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, in->x, in->len, crypt, NULL) == CRYPT_NULL_INPUT);
cryptLen = 0;
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, in->x, in->len, crypt, &cryptLen) == CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH);
cryptLen = 256;
ASSERT_EQ(CRYPT_EAL_PkeyDecrypt(pkey, in->x, in->len, crypt, &cryptLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
int Compare_PubKey(CRYPT_EAL_PkeyPub *pubKey1, CRYPT_EAL_PkeyPub *pubKey2)
{
if (pubKey1->key.paillierPub.nLen != pubKey2->key.paillierPub.nLen || pubKey1->key.paillierPub.gLen != pubKey2->key.paillierPub.gLen) {
return -1; // -1 indicates failure
}
if (memcmp(pubKey1->key.paillierPub.n, pubKey2->key.paillierPub.n, pubKey1->key.paillierPub.nLen) != 0 ||
memcmp(pubKey1->key.paillierPub.g, pubKey2->key.paillierPub.g, pubKey1->key.paillierPub.gLen) != 0) {
return -1; // -1 indicates failure
}
return 0;
}
int Compare_PrvKey(CRYPT_EAL_PkeyPrv *prvKey1, CRYPT_EAL_PkeyPrv *prvKey2)
{
if (prvKey1->key.paillierPrv.nLen != prvKey2->key.paillierPrv.nLen || prvKey1->key.paillierPrv.muLen != prvKey2->key.paillierPrv.muLen ||
prvKey1->key.paillierPrv.lambdaLen != prvKey2->key.paillierPrv.lambdaLen) {
return -1; // -1 indicates failure
}
if (memcmp(prvKey1->key.paillierPrv.lambda, prvKey2->key.paillierPrv.lambda, prvKey1->key.paillierPrv.lambdaLen) != 0 ||
memcmp(prvKey1->key.paillierPrv.mu, prvKey2->key.paillierPrv.mu, prvKey1->key.paillierPrv.muLen) != 0 ||
memcmp(prvKey1->key.paillierPrv.n, prvKey2->key.paillierPrv.n, prvKey1->key.paillierPrv.nLen) != 0) {
return -1; // -1 indicates failure
}
return 0;
}
/**
* @test SDV_CRYPTO_PAILLIER_SET_KEY_API_TC001
* @title PAILLIER Set the public key and private key multiple times.
* @precon Create the contexts of the paillier algorithm and:
* pkey1: Set paran and generate a key pair: test obtaining the key.
* pkey2: Test set keys, and verify that the public and private keys can exist at the same time.
* @brief
* 1. pkey1: Get public key and get private key, expected result 1
* 2. pkey2:
* (1) Set public key and set private key, expected result 1
* (2) Get public key, get private key and check private key, expected result 2
* (3) Set private key and set public key, expected result 3
* (4) Get private key, get public key and check public key, expected result 4
* @expect
* 1. CRYPT_SUCCESS
* 2. The obtained private key is equal to the set private key.
* 3. CRYPT_SUCCESS
* 4. The obtained public key is equal to the set public key.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PAILLIER_SET_KEY_API_TC001(Hex *p, Hex *q, int bits, int isProvider)
{
uint8_t pubN[600];
uint8_t pubG[600];
uint8_t pubN2[600];
uint8_t prvN[600];
uint8_t prvLambda[600];
uint8_t prvMu[600];
uint8_t prvN2[600];
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPub pubKey = {0};
CRYPT_EAL_PkeyPrv prvKey = {0};
SetPaillierPara(¶, p, q, bits);
SetPaillierPubKey(&pubKey, pubG, 600, pubN, 600, pubN2, 600);
SetPaillierPrvKey(&prvKey, prvLambda, 600, prvMu, 600);
prvKey.key.paillierPrv.n = prvN;
prvKey.key.paillierPrv.nLen = 600;
prvKey.key.paillierPrv.n2 = prvN2;
prvKey.key.paillierPrv.n2Len = 600;
TestMemInit();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
CRYPT_EAL_PkeyCtx *pkey1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE,
"provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pkey1 != NULL && pkey2 != NULL);
/* pkey1 */
/* Generate a key pair. */
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey1, ¶) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey1), CRYPT_SUCCESS);
/* Get keys. */
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey1, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey1, &prvKey), CRYPT_SUCCESS);
/* pkey2 */
/* Set public key and set private key. */
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey2, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey2, &prvKey), CRYPT_SUCCESS);
/* Get public key, get private key and check private key.*/
SetPaillierPubKey(&pubKey, pubG, 600, pubN, 600, pubN2, 600);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey2, &pubKey), CRYPT_SUCCESS);
SetPaillierPrvKey(&prvKey, prvLambda, 600, prvMu, 600);
prvKey.key.paillierPrv.n = prvN;
prvKey.key.paillierPrv.nLen = 600;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey2, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(Compare_PrvKey(&prvKey, &prvKey), 0);
/* Set private key and set public key. */
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey2, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey2, &pubKey), CRYPT_SUCCESS);
/* Get private key, get public key and check public key.*/
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey2, &prvKey), CRYPT_SUCCESS);
SetPaillierPubKey(&pubKey, pubG, 600, pubN, 600, pubN2, 600);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey2, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(Compare_PubKey(&pubKey, &pubKey), 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PAILLIER_DUP_CTX_API_TC001
* @title PAILLIER CRYPT_EAL_PkeyDupCtx test.
* @precon Create the contexts of the paillier algorithm, set para and generate a key pair.
* @brief
* 1. Call the CRYPT_EAL_PkeyDupCtx mehod to dup paillier, expected result 1
* @expect
* 1. Success.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PAILLIER_DUP_CTX_API_TC001(Hex *p, Hex *q, int bits, int isProvider)
{
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyCtx *newPkey = NULL;
CRYPT_EAL_PkeyCtx *pkey = NULL;
SetPaillierPara(¶, p, q, bits);
TestMemInit();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), 0);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
CRYPT_PAILLIER_Ctx *paillierCtx = (CRYPT_PAILLIER_Ctx *)pkey->key;
ASSERT_TRUE(paillierCtx != NULL);
newPkey = CRYPT_EAL_PkeyDupCtx(pkey);
ASSERT_TRUE(newPkey != NULL);
ASSERT_EQ(newPkey->references.count, 1);
CRYPT_PAILLIER_Ctx *paillierCtx2 = (CRYPT_PAILLIER_Ctx *)newPkey->key;
ASSERT_TRUE(paillierCtx2 != NULL);
ASSERT_COMPARE("paillier compare lambda",
paillierCtx->prvKey->lambda->data,
paillierCtx->prvKey->lambda->size * sizeof(BN_UINT),
paillierCtx2->prvKey->lambda->data,
paillierCtx2->prvKey->lambda->size * sizeof(BN_UINT));
ASSERT_COMPARE("paillier compare mu",
paillierCtx->prvKey->mu->data,
paillierCtx->prvKey->mu->size * sizeof(BN_UINT),
paillierCtx2->prvKey->mu->data,
paillierCtx2->prvKey->mu->size * sizeof(BN_UINT));
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(newPkey);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PAILLIER_GET_SECURITY_BITS_FUNC_TC001
* @title PAILLIER CRYPT_EAL_PkeyGetSecurityBits test.
* @precon nan
* @brief
* 1. Create the context of the paillier algorithm, expected result 1
* 2. Set public key, expected result 2
* 3. Call the CRYPT_EAL_PkeyVerify method and the parameter is correct, expected result 3
* @expect
* 1. Success, and the context is not null.
* 2. CRYPT_SUCCESS
* 3. The return value is not 0.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PAILLIER_GET_SECURITY_BITS_FUNC_TC001(Hex *n, Hex *g, Hex *n2, int securityBits, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPub pubkey = {0};
SetPaillierPubKey(&pubkey, g->x, g->len, n->x, n->len, n2->x, n2->len);
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pubkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetSecurityBits(pkey), securityBits);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
int HEAdd_Correctness_Check(CRYPT_EAL_PkeyCtx *pkey, Hex *c1, Hex *c2, uint8_t *addResult, uint32_t addLen)
{
uint8_t m1[256] = {0};
uint8_t m2[256] = {0};
uint8_t sum[256] = {0};
uint32_t m1Len = 256;
uint32_t m2Len = 256;
uint32_t sumLen = 256;
if (CRYPT_EAL_PkeyDecrypt(pkey, c1->x, c1->len, m1, &m1Len) != CRYPT_SUCCESS ||
CRYPT_EAL_PkeyDecrypt(pkey, c2->x, c2->len, m2, &m2Len) != CRYPT_SUCCESS ||
CRYPT_EAL_PkeyDecrypt(pkey, addResult, addLen, sum, &sumLen) != CRYPT_SUCCESS) {
return -1;
}
uint8_t expected_sum[256] = {0};
uint32_t maxLen = (m1Len > m2Len ? m1Len : m2Len);
uint16_t carry = 0;
for (uint32_t i = 0; i < maxLen || carry; i++) {
uint16_t v1 = (i < m1Len) ? m1[i] : 0;
uint16_t v2 = (i < m2Len) ? m2[i] : 0;
uint16_t s = v1 + v2 + carry;
expected_sum[i] = (uint8_t)(s & 0xFF);
carry = (s >> CHAR_BIT);
}
uint32_t expected_sum_len = maxLen + (carry ? 1 : 0);
if (sumLen != expected_sum_len) {
return -1; // -1 indicates failure
}
if (memcmp(sum, expected_sum, expected_sum_len) != 0) {
return -1; // -1 indicates failure
}
return 0;
}
/**
* @test SDV_CRYPTO_PAILLIER_ADD_API_TC001
* @title PAILLIER CRYPT_EAL_PkeyHEAdd: Test the validity of input parameters and homomorphic addition functionality.
* @precon Create the context of the paillier algorithm.
* @brief
* 1. Call the CRYPT_EAL_PkeyHEAdd method without public key, expected result 1.
* 2. Set valid ciphertexts, expected result 3.
* 3. Call the CRYPT_EAL_PkeyHEAdd method:
* (1) pkey = NULL, expected result 4.
* (2) params = NULL, expected result 4.
* (3) out = NULL, expected result 4.
* (4) outLen = NULL, expected result 4.
* (5) ciphertext length is invalid, expected result 2.
* (6) ciphertext value is out of range [0, n^2) or not coprime to n^2, expected result 2.
* (7) outLen = 0, expected result 5
* (8) all parameters are valid, expected result 3.
* @expect
* 1. CRYPT_PAILLIER_NO_KEY_INFO
* 2. CRYPT_PAILLIER_ERR_INPUT_VALUE
* 3. CRYPT_SUCCESS
* 4. CRYPT_NULL_INPUT
* 5. CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PAILLIER_ADD_API_TC001(Hex *Lambda, Hex *mu, Hex *n, Hex *g, Hex *n2, Hex *c1, Hex *c2, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPub pubkey = {0};
uint8_t addResult[512];
uint32_t addLen = 512;
enum { IDX_C1 = 0, IDX_C2 = 1, IDX_END = 2 };
BSL_Param items[3]; // Two ciphertexts + end marker
SetPaillierPubKey(&pubkey, g->x, g->len, n->x, n->len, n2->x, n2->len);
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
// Create context and set public key
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_PAILLIER, CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
/* pKey is NULL */
ASSERT_TRUE(CRYPT_EAL_PkeyHEAdd(pkey, items, addResult, &addLen) == CRYPT_PAILLIER_NO_KEY_INFO);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pubkey), CRYPT_SUCCESS);
/* Prepare homomorphic addition input */
ASSERT_EQ(
BSL_PARAM_InitValue(&items[IDX_C1], CRYPT_PARAM_PKEY_HE_CIPHERTEXT1, BSL_PARAM_TYPE_OCTETS, c1->x, c1->len),
BSL_SUCCESS);
ASSERT_EQ(
BSL_PARAM_InitValue(&items[IDX_C2], CRYPT_PARAM_PKEY_HE_CIPHERTEXT2, BSL_PARAM_TYPE_OCTETS, c2->x, c2->len),
BSL_SUCCESS);
(void)memset_s(&items[IDX_END], sizeof(items[IDX_END]), 0, sizeof(items[IDX_END]));
/* Test invalid inputs */
ASSERT_EQ(CRYPT_EAL_PkeyHEAdd(NULL, items, addResult, &addLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyHEAdd(pkey, NULL, addResult, &addLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyHEAdd(pkey, items, NULL, &addLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyHEAdd(pkey, items, addResult, NULL), CRYPT_NULL_INPUT);
/* Test invalid ciphertext length */
items[IDX_C1].valueLen = c1->len + 1; // Corrupt length
ASSERT_EQ(CRYPT_EAL_PkeyHEAdd(pkey, items, addResult, &addLen), CRYPT_PAILLIER_ERR_INPUT_VALUE);
/* Restore the correct value */
ASSERT_EQ(
BSL_PARAM_InitValue(&items[IDX_C1], CRYPT_PARAM_PKEY_HE_CIPHERTEXT1, BSL_PARAM_TYPE_OCTETS, c1->x, c1->len),
BSL_SUCCESS);
ASSERT_EQ(
BSL_PARAM_InitValue(&items[IDX_C2], CRYPT_PARAM_PKEY_HE_CIPHERTEXT2, BSL_PARAM_TYPE_OCTETS, c2->x, c2->len),
BSL_SUCCESS);
/* Test invalid outLen */
addLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyHEAdd(pkey, items, addResult, &addLen), CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH);
/* Test valid homomorphic addition */
addLen = 512;
ASSERT_EQ(CRYPT_EAL_PkeyHEAdd(pkey, items, addResult, &addLen), CRYPT_SUCCESS);
CRYPT_EAL_PkeyPrv prvkey = {0};
SetPaillierPrvKey(&prvkey, Lambda->x, Lambda->len, mu->x, mu->len);
prvkey.key.paillierPrv.n = n->x;
prvkey.key.paillierPrv.nLen = n->len;
prvkey.key.paillierPrv.n2 = n2->x;
prvkey.key.paillierPrv.n2Len = n2->len;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prvkey), CRYPT_SUCCESS);
ASSERT_EQ(HEAdd_Correctness_Check(pkey, c1, c2, addResult, addLen), 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
TestRandDeInit();
}
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/paillier/test_suite_sdv_eal_paillier.c | C | unknown | 42,349 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <pthread.h>
#include "securec.h"
#include "crypt_eal_kdf.h"
#include "crypt_errno.h"
#include "bsl_sal.h"
#include "bsl_params.h"
#include "crypt_params_key.h"
/* END_HEADER */
#define DATA_LEN (64)
#define ITERATION_COUNT (1024)
#define DATA_MAX_LEN (512)
#define TEST_FAIL (-1)
#define TEST_SUCCESS (0)
/**
* @test SDV_CRYPT_EAL_KDF_PBKDF2_API_TC001
* @title pbkdf2 api test.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_KDF_PBKDF2_API_TC001(void)
{
TestMemInit();
uint32_t keyLen = DATA_LEN;
uint8_t key[DATA_LEN];
uint32_t saltLen = DATA_LEN;
uint8_t salt[DATA_LEN];
uint32_t it = ITERATION_COUNT; // The number of iterations cannot be less than 1024.. GM/T 0091-2020
uint32_t outLen = DATA_LEN;
uint8_t out[DATA_LEN];
CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_PBKDF2);
ASSERT_TRUE(ctx != NULL);
CRYPT_MAC_AlgId macAlgId = CRYPT_MAC_HMAC_SHA1;
BSL_Param params[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&macAlgId, sizeof(macAlgId)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS,
key, keyLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
salt, saltLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_ITER, BSL_PARAM_TYPE_UINT32,
&it, sizeof(it)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS,
NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
uint32_t iterCntFailed = 0;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_ITER, BSL_PARAM_TYPE_UINT32,
&iterCntFailed, sizeof(iterCntFailed)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_PBKDF2_PARAM_ERROR);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_ITER, BSL_PARAM_TYPE_UINT32,
&it, sizeof(it)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, NULL, outLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, 0), CRYPT_PBKDF2_PARAM_ERROR);
macAlgId = CRYPT_MAC_HMAC_MD5;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&macAlgId, sizeof(macAlgId)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
macAlgId = CRYPT_MAC_HMAC_SHA1;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&macAlgId, sizeof(macAlgId)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
macAlgId = CRYPT_MAC_HMAC_SHA224;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&macAlgId, sizeof(macAlgId)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
macAlgId = CRYPT_MAC_HMAC_SHA256;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&macAlgId, sizeof(macAlgId)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
macAlgId = CRYPT_MAC_HMAC_SHA384;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&macAlgId, sizeof(macAlgId)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
macAlgId = CRYPT_MAC_HMAC_SHA512;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&macAlgId, sizeof(macAlgId)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
macAlgId = CRYPT_MAC_HMAC_SM3;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&macAlgId, sizeof(macAlgId)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDeInitCtx(NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_KdfDeInitCtx(ctx), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_KdfFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_KDF_PBKDF2_FUN_TC001
* @title Perform the vector test to check whether the calculation result is consistent with the standard output.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_KDFCTX functions get output, expected result 1.
* 2.Compare the result to the expected value, expected result 2.
* @expect
* 1.Successful.
* 2.The results are as expected.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_KDF_PBKDF2_FUN_TC001(int algId, Hex *key, Hex *salt, int it, Hex *result)
{
if (IsHmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
uint32_t outLen = result->len;
uint8_t *out = malloc(outLen * sizeof(uint8_t));
ASSERT_TRUE(out != NULL);
CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_PBKDF2);
ASSERT_TRUE(ctx != NULL);
BSL_Param params[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&algId, sizeof(algId)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS,
key->x, key->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
salt->x, salt->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_ITER, BSL_PARAM_TYPE_UINT32,
&it, sizeof(it)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
EXIT:
if (out != NULL) {
free(out);
}
CRYPT_EAL_KdfFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PBKDF2_DEFAULT_PROVIDER_FUNC_TC001
* @title Default provider testing
* @precon nan
* @brief
* Load the default provider and use the test vector to test its correctness
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PBKDF2_DEFAULT_PROVIDER_FUNC_TC001(int algId, Hex *key, Hex *salt, int it, Hex *result)
{
if (IsHmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
uint32_t outLen = result->len;
uint8_t *out = malloc(outLen * sizeof(uint8_t));
ASSERT_TRUE(out != NULL);
CRYPT_EAL_KdfCTX *ctx = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_PBKDF2, "provider=default");
#else
ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_PBKDF2);
#endif
ASSERT_TRUE(ctx != NULL);
BSL_Param params[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&algId, sizeof(algId)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS,
key->x, key->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
salt->x, salt->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_ITER, BSL_PARAM_TYPE_UINT32,
&it, sizeof(it)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
EXIT:
if (out != NULL) {
free(out);
}
CRYPT_EAL_KdfFreeCtx(ctx);
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/pbkdf2/test_suite_sdv_eal_kdf_pbkdf2.c | C | unknown | 9,203 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include "securec.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "crypt_algid.h"
#include "crypt_eal_init.h"
#include "crypt_eal_provider.h"
#include "crypt_provider_local.h"
#include "crypt_eal_implprovider.h"
#include "crypt_provider.h"
#include "crypt_eal_mac.h"
#include "eal_mac_local.h"
#include "crypt_eal_kdf.h"
#include "eal_kdf_local.h"
#include "crypt_eal_md.h"
#include "eal_md_local.h"
#include "crypt_eal_pkey.h"
#include "eal_pkey_local.h"
#include "test.h"
#include "crypt_eal_cmvp.h"
#include "crypt_errno.h"
#include "bsl_sal.h"
#include "bsl_list.h"
#include "bsl_errno.h"
#include "crypt_eal_md.h"
#include "hitls_crypt_type.h"
#include "hitls_cert_type.h"
#include "hitls_type.h"
#include "crypt_eal_entropy.h"
#include "crypt_util_rand.h"
#include <stdio.h>
#include <time.h>
#include <string.h>
/* END_HEADER */
#ifdef HITLS_CRYPTO_CMVP_ISO19790_PURE_C
#define HITLS_CRYPTO_CMVP_ISO19790
#define HITLS_ISO_PROVIDER_PATH "../../output/CMVP/C/lib"
#endif
#ifdef HITLS_CRYPTO_CMVP_ISO19790_ARMV8_LE
#define HITLS_CRYPTO_CMVP_ISO19790
#define HITLS_ISO_PROVIDER_PATH "../../output/CMVP/armv8_le/lib"
#endif
#ifdef HITLS_CRYPTO_CMVP_ISO19790_X86_64
#define HITLS_CRYPTO_CMVP_ISO19790
#define HITLS_ISO_PROVIDER_PATH "../../output/CMVP/x86_64/lib"
#endif
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#define ISO19790_LOG_FILE "iso19790_audit.log"
#define HITLS_ISO_LIB_NAME "libhitls_iso.so"
#define HITLS_ISO_PROVIDER_ATTR "provider=iso"
static FILE* g_logFile = NULL;
static int32_t InitLogFile(void)
{
if (g_logFile == NULL) {
g_logFile = fopen(ISO19790_LOG_FILE, "a");
if (g_logFile == NULL) {
return CRYPT_NULL_INPUT;
}
}
return CRYPT_SUCCESS;
}
static void CloseLogFile(void)
{
if (g_logFile != NULL) {
fclose(g_logFile);
g_logFile = NULL;
}
}
static void ISO19790_RunLogCb(CRYPT_EVENT_TYPE oper, CRYPT_ALGO_TYPE type, int32_t id, int32_t err)
{
char timeStr[72] = {0};
time_t now = time(NULL);
struct tm *tm_info = gmtime(&now);
if (InitLogFile() != CRYPT_SUCCESS) {
return;
}
sprintf(timeStr, "%d-%d-%d %d:%d:%d",
tm_info->tm_year + 1900,
tm_info->tm_mon + 1,
tm_info->tm_mday,
tm_info->tm_hour,
tm_info->tm_min,
tm_info->tm_sec);
if (oper == CRYPT_EVENT_INTEGRITY_TEST) {
if (err == CRYPT_SUCCESS) {
fprintf(g_logFile, "[%s] [open hitls] [INFO] Integrity test begin.\n", timeStr);
} else {
fprintf(g_logFile, "[%s] [open hitls] [ERR] Integrity test failed, errcode: 0x%x\n", timeStr, err);
}
fflush(g_logFile);
CloseLogFile();
return;
}
// ISO/IEC 19790:2012 AS09.33
// The module shall provide an output status indication when zeroing is complete
if (oper == CRYPT_EVENT_ZERO && err == CRYPT_SUCCESS) {
fprintf(g_logFile, "[%s] [open hitls] [INFO] SSP already zeroisation - algorithm type: %d, id: %d\n",
timeStr, type, id);
fflush(g_logFile);
}
/*
ISO/IEC 19790:2012 AS06.26
The following events of the cryptographic module should be recorded by the OS audit mechanism:
● Attempted to provide invalid input for the cryptographic officer function;
*/
if (err != CRYPT_SUCCESS) {
fprintf(g_logFile, "[%s] [open hitls] [ERR] Occur error - algorithm type: %d, id: %d, operate: %d, errcode: 0x%x\n",
timeStr, type, id, oper, err);
fflush(g_logFile);
}
/*
ISO/IEC 19790:2012 AS06.26
The following events of the cryptographic module should be recorded by the OS audit mechanism:
● Modify, access, delete, and add encrypted data and SSPs；
● Use security-related encryption features
ISO/IEC 19790:2012 AS02.24
When a service uses approved encryption algorithms, security functions or processes,
and specified services or processes in an approved manner,
the service shall provide corresponding status indications.
*/
fprintf(g_logFile, "[%s] [open hitls] [INFO] Excute - algorithm type: %d, id: %d, operate: %d\n",
timeStr, type, id, oper);
fflush(g_logFile);
CloseLogFile();
}
static int32_t GetEntropy(void *ctx, CRYPT_Data *entropy, uint32_t strength, CRYPT_Range *lenRange)
{
return CRYPT_EAL_SeedPoolGetEntropy((CRYPT_EAL_SeedPoolCtx *)ctx, entropy, strength, lenRange);
}
static void CleanEntropy(void *ctx, CRYPT_Data *entropy)
{
(void)ctx;
BSL_SAL_ClearFree(entropy->data, entropy->len);
}
static int32_t GetNonce(void *ctx, CRYPT_Data *nonce, uint32_t strength, CRYPT_Range *lenRange)
{
return GetEntropy(ctx, nonce, strength, lenRange);
}
static void CleanNonce(void *ctx, CRYPT_Data *nonce)
{
CleanEntropy(ctx, nonce);
}
static void EntropyRunLogCb(int32_t ret)
{
char timeStr[72] = {0};
time_t now = time(NULL);
struct tm *tm_info = gmtime(&now);
if (InitLogFile() != CRYPT_SUCCESS) {
return;
}
sprintf(timeStr, "%d-%d-%d %d:%d:%d",
tm_info->tm_year + 1900,
tm_info->tm_mon + 1,
tm_info->tm_mday,
tm_info->tm_hour,
tm_info->tm_min,
tm_info->tm_sec);
fprintf(g_logFile, "[%s] [open hitls] [INFO] Excute entropy health test - ret: %d\n",
timeStr, ret);
fflush(g_logFile);
CloseLogFile();
}
static void GetSeedPool(void **seedPool, void **es)
{
CRYPT_EAL_Es *esTemp = NULL;
CRYPT_EAL_SeedPoolCtx *poolTemp = NULL;
int32_t ret = 0;
esTemp = CRYPT_EAL_EsNew();
ASSERT_TRUE(esTemp != NULL);
ret = CRYPT_EAL_EsCtrl(esTemp, CRYPT_ENTROPY_SET_CF, "sha256_df", (uint32_t)strlen("sha256_df"));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_EsCtrl(esTemp, CRYPT_ENTROPY_REMOVE_NS, "timestamp", (uint32_t)strlen("timestamp"));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_EsCtrl(esTemp, CRYPT_ENTROPY_SET_LOG_CALLBACK, EntropyRunLogCb, 0);
ASSERT_EQ(ret, CRYPT_SUCCESS);
bool healthTest = true;
ret = CRYPT_EAL_EsCtrl(esTemp, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, sizeof(healthTest));
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t size = 4096;
ret = CRYPT_EAL_EsCtrl(esTemp, CRYPT_ENTROPY_SET_POOL_SIZE, &size, sizeof(size));
ASSERT_EQ(ret, CRYPT_SUCCESS);
do {
ret = CRYPT_EAL_EsInit(esTemp);
} while (ret == CRYPT_ENTROPY_ES_NO_NS || ret == CRYPT_DRBG_FAIL_GET_ENTROPY || ret == CRYPT_DRBG_FAIL_GET_NONCE);
ASSERT_EQ(ret, CRYPT_SUCCESS);
poolTemp = CRYPT_EAL_SeedPoolNew(true);
ASSERT_TRUE(poolTemp != NULL);
CRYPT_EAL_EsPara para = {
false,
8,
esTemp,
(CRYPT_EAL_EntropyGet)CRYPT_EAL_EsEntropyGet,
};
ret = CRYPT_EAL_SeedPoolAddEs(poolTemp, ¶);
ASSERT_EQ(ret, CRYPT_SUCCESS);
*seedPool = poolTemp;
*es = esTemp;
return;
EXIT:
CRYPT_EAL_SeedPoolFree(poolTemp);
CRYPT_EAL_EsFree(esTemp);
return;
}
typedef struct {
CRYPT_EAL_LibCtx *libCtx;
CRYPT_EAL_Es *es;
CRYPT_EAL_SeedPoolCtx *pool;
} Iso19790_ProviderLoadCtx;
static void Iso19790_ProviderLoad(Iso19790_ProviderLoadCtx *ctx)
{
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_Es *es = NULL;
CRYPT_EAL_SeedPoolCtx *pool = NULL;
libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
CRYPT_EAL_RegEventReport(ISO19790_RunLogCb);
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, HITLS_ISO_PROVIDER_PATH), CRYPT_SUCCESS);
BSL_Param param[2] = {{0}, BSL_PARAM_END};
(void)BSL_PARAM_InitValue(¶m[0], CRYPT_PARAM_CMVP_LOG_FUNC, BSL_PARAM_TYPE_FUNC_PTR, ISO19790_RunLogCb, 0);
int32_t ret;
do {
ret = CRYPT_EAL_ProviderLoad(libCtx, 0, HITLS_ISO_LIB_NAME, param, NULL);
} while (ret == CRYPT_ENTROPY_ES_NO_NS || ret == CRYPT_DRBG_FAIL_GET_ENTROPY || ret == CRYPT_DRBG_FAIL_GET_NONCE);
ASSERT_EQ(ret, CRYPT_SUCCESS);
GetSeedPool((void **)&pool, (void **)&es);
ASSERT_TRUE(pool != NULL && es != NULL);
BSL_Param randParam[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
(void)BSL_PARAM_InitValue(&randParam[0], CRYPT_PARAM_RAND_SEED_GETENTROPY, BSL_PARAM_TYPE_FUNC_PTR, GetEntropy, 0);
(void)BSL_PARAM_InitValue(&randParam[1], CRYPT_PARAM_RAND_SEED_CLEANENTROPY, BSL_PARAM_TYPE_FUNC_PTR, CleanEntropy, 0);
(void)BSL_PARAM_InitValue(&randParam[2], CRYPT_PARAM_RAND_SEED_GETNONCE, BSL_PARAM_TYPE_FUNC_PTR, GetNonce, 0);
(void)BSL_PARAM_InitValue(&randParam[3], CRYPT_PARAM_RAND_SEED_CLEANNONCE, BSL_PARAM_TYPE_FUNC_PTR, CleanNonce, 0);
(void)BSL_PARAM_InitValue(&randParam[4], CRYPT_PARAM_RAND_SEEDCTX, BSL_PARAM_TYPE_CTX_PTR, pool, 0);
do {
ret = CRYPT_EAL_ProviderRandInitCtx(libCtx, CRYPT_RAND_SHA256, HITLS_ISO_PROVIDER_ATTR, NULL, 0, randParam);
} while (ret == CRYPT_ENTROPY_ES_NO_NS || ret == CRYPT_DRBG_FAIL_GET_ENTROPY || ret == CRYPT_DRBG_FAIL_GET_NONCE);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ctx->libCtx = libCtx;
ctx->es = es;
ctx->pool = pool;
return;
EXIT:
CRYPT_EAL_LibCtxFree(libCtx);
CRYPT_EAL_SeedPoolFree(pool);
CRYPT_EAL_EsFree(es);
return;
}
static void Iso19790_ProviderUnload(Iso19790_ProviderLoadCtx *ctx)
{
CRYPT_EAL_RandDeinitEx(ctx->libCtx);
CRYPT_EAL_LibCtxFree(ctx->libCtx);
CRYPT_EAL_SeedPoolFree(ctx->pool);
CRYPT_EAL_EsFree(ctx->es);
(void)memset_s(ctx, sizeof(Iso19790_ProviderLoadCtx), 0, sizeof(Iso19790_ProviderLoadCtx));
}
#endif
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_PKEY_SIGN_VERIFY_TEST_TC001()
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_PkeyCtx *keyCtx = NULL;
uint8_t signature[128] = {0};
uint32_t signatureLen = sizeof(signature);
uint8_t testData[] = "Test data for signing and verification with ECDSA";
uint32_t testDataLen = sizeof(testData) - 1;
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
keyCtx = CRYPT_EAL_ProviderPkeyNewCtx(ctx.libCtx, CRYPT_PKEY_SM2, 0, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(keyCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyGen(keyCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySign(keyCtx, CRYPT_MD_SM3, testData, testDataLen, signature, &signatureLen), 0);
ASSERT_TRUE(signatureLen > 0);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(keyCtx, CRYPT_MD_SM3, testData, testDataLen, signature, signatureLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(keyCtx);
Iso19790_ProviderUnload(&ctx);
return;
#endif
}
/* END_CASE */
#ifdef HITLS_CRYPTO_CMVP_ISO19790
static void SetRsaPara(CRYPT_EAL_PkeyPara *para, uint8_t *e, uint32_t eLen, uint32_t bits)
{
para->id = CRYPT_PKEY_RSA;
para->para.rsaPara.e = e;
para->para.rsaPara.eLen = eLen;
para->para.rsaPara.bits = bits;
}
#endif
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_PKEY_SIGN_VERIFY_TEST_TC002()
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
uint8_t e[] = {1, 0, 1};
CRYPT_EAL_PkeyPara para = {0};
int32_t mdId = CRYPT_MD_SHA256;
int32_t pkcsv15 = mdId;
uint8_t signature[256] = {0};
uint32_t signatureLen = sizeof(signature);
uint8_t testData[] = "Test data for signing and verification with ECDSA";
uint32_t testDataLen = sizeof(testData) - 1;
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
pkeyCtx = CRYPT_EAL_ProviderPkeyNewCtx(ctx.libCtx, CRYPT_PKEY_RSA, 0, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(pkeyCtx != NULL);
SetRsaPara(¶, e, 3, 2048);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkeyCtx, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkeyCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, mdId, testData, testDataLen, signature, &signatureLen), 0);
ASSERT_TRUE(signatureLen > 0);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkeyCtx, mdId, testData, testDataLen, signature, signatureLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
Iso19790_ProviderUnload(&ctx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO_PROVIDER_PKEY_ENCRYPT_DECRYPT_TEST_TC001()
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
uint8_t e[] = {1, 0, 1};
CRYPT_EAL_PkeyPara para = {0};
int32_t mdId = CRYPT_MD_SHA256;
uint8_t plaintext[256] = {0};
uint32_t plaintextLen = sizeof(plaintext);
uint8_t ciphertext[256] = {0};
uint32_t ciphertextLen = sizeof(ciphertext);
uint8_t testData[] = "Test data for encrypt and decrypt with RSA.";
uint32_t testDataLen = sizeof(testData) - 1;
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
BSL_Param oaep[3] = {{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
BSL_PARAM_END
};
pkeyCtx = CRYPT_EAL_ProviderPkeyNewCtx(ctx.libCtx, CRYPT_PKEY_RSA, 0, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(pkeyCtx != NULL);
SetRsaPara(¶, e, 3, 2048);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkeyCtx, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkeyCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_RSAES_OAEP, oaep, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyEncrypt(pkeyCtx, testData, testDataLen, ciphertext, &ciphertextLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyDecrypt(pkeyCtx, ciphertext, ciphertextLen, plaintext, &plaintextLen), CRYPT_SUCCESS);
ASSERT_EQ(testDataLen, plaintextLen);
ASSERT_EQ(memcmp(testData, plaintext, plaintextLen), 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
Iso19790_ProviderUnload(&ctx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_DRBG_TEST_TC001()
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
SKIP_TEST();
#else
CRYPT_EAL_Es *es = NULL;
CRYPT_EAL_SeedPoolCtx *pool = NULL;
CRYPT_EAL_RndCtx *randCtx = NULL;
Iso19790_ProviderLoadCtx ctx = {0};
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
es = CRYPT_EAL_EsNew();
ASSERT_TRUE(es != NULL);
int32_t ret = CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_CF, "sha256_df", (uint32_t)strlen("sha256_df"));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_REMOVE_NS, "timestamp", (uint32_t)strlen("timestamp"));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_LOG_CALLBACK, EntropyRunLogCb, 0);
ASSERT_EQ(ret, CRYPT_SUCCESS);
bool healthTest = true;
ret = CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, sizeof(healthTest));
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t size = 4096;
ret = CRYPT_EAL_EsCtrl(es, CRYPT_ENTROPY_SET_POOL_SIZE, &size, sizeof(size));
ASSERT_EQ(ret, CRYPT_SUCCESS);
do {
ret = CRYPT_EAL_EsInit(es);
} while (ret == CRYPT_ENTROPY_ES_NO_NS || ret == CRYPT_DRBG_FAIL_GET_ENTROPY || ret == CRYPT_DRBG_FAIL_GET_NONCE);
ASSERT_EQ(ret, CRYPT_SUCCESS);
pool = CRYPT_EAL_SeedPoolNew(true);
ASSERT_TRUE(pool != NULL);
CRYPT_EAL_EsPara para = {
false,
8,
es,
(CRYPT_EAL_EntropyGet)CRYPT_EAL_EsEntropyGet,
};
ret = CRYPT_EAL_SeedPoolAddEs(pool, ¶);
ASSERT_EQ(ret, CRYPT_SUCCESS);
BSL_Param param[6] = {0};
ASSERT_EQ(BSL_PARAM_InitValue(¶m[0], CRYPT_PARAM_RAND_SEED_GETENTROPY, BSL_PARAM_TYPE_FUNC_PTR, GetEntropy, 0), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[1], CRYPT_PARAM_RAND_SEED_CLEANENTROPY, BSL_PARAM_TYPE_FUNC_PTR, CleanEntropy, 0), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[2], CRYPT_PARAM_RAND_SEED_GETNONCE, BSL_PARAM_TYPE_FUNC_PTR, GetNonce, 0), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[3], CRYPT_PARAM_RAND_SEED_CLEANNONCE, BSL_PARAM_TYPE_FUNC_PTR, CleanNonce, 0), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[4], CRYPT_PARAM_RAND_SEEDCTX, BSL_PARAM_TYPE_CTX_PTR, pool, 0), CRYPT_SUCCESS);
randCtx = CRYPT_EAL_ProviderDrbgNewCtx(ctx.libCtx, CRYPT_RAND_SHA256, NULL, param);
ASSERT_TRUE(randCtx != NULL);
ret = CRYPT_EAL_DrbgInstantiate(randCtx, NULL, 0);
ASSERT_EQ(ret, CRYPT_SUCCESS);
unsigned char data[16] = {0};
uint32_t dataLen = sizeof(data);
ret = CRYPT_EAL_Drbgbytes(randCtx, data, dataLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_DrbgSeed(randCtx);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_Drbgbytes(randCtx, data, dataLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_DrbgDeinit(randCtx);
CRYPT_EAL_SeedPoolFree(pool);
CRYPT_EAL_EsFree(es);
Iso19790_ProviderUnload(&ctx);
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_MD_TEST_TC001(int algId)
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
(void)algId;
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_MdCTX *mdCtx = NULL;
uint8_t plaintext[128] = {0};
uint32_t plaintextLen = sizeof(plaintext);
uint8_t md[128] = {0};
uint32_t mdLen = sizeof(md);
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
mdCtx = CRYPT_EAL_ProviderMdNewCtx(ctx.libCtx, algId, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(mdCtx != NULL);
int32_t ret = CRYPT_EAL_MdInit(mdCtx);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_MdUpdate(mdCtx, plaintext, plaintextLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_MdFinal(mdCtx, md, &mdLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MdFreeCtx(mdCtx);
Iso19790_ProviderUnload(&ctx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_MAC_TEST_TC001(int algId, int keyLen)
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
(void)algId;
(void)keyLen;
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_MacCtx *macCtx = NULL;
uint8_t macKey[32] = {0};
uint32_t macKeyLen = keyLen;
uint8_t plaintext[128] = {0};
uint32_t plaintextLen = sizeof(plaintext);
uint8_t iv[16] = {0};
uint32_t ivLen = sizeof(iv);
int32_t tagLen = 16;
uint8_t mac[128] = {0};
uint32_t macLen = sizeof(mac);
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
macCtx = CRYPT_EAL_ProviderMacNewCtx(ctx.libCtx, algId, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(macCtx != NULL);
int32_t ret = CRYPT_EAL_MacInit(macCtx, macKey, macKeyLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
if (algId == CRYPT_MAC_GMAC_AES128 || algId == CRYPT_MAC_GMAC_AES192 || algId == CRYPT_MAC_GMAC_AES256) {
ret = CRYPT_EAL_MacCtrl(macCtx, CRYPT_CTRL_SET_IV, iv, ivLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_MacCtrl(macCtx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen));
ASSERT_EQ(ret, CRYPT_SUCCESS);
}
ret = CRYPT_EAL_MacUpdate(macCtx, plaintext, plaintextLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
if (algId == CRYPT_MAC_GMAC_AES128 || algId == CRYPT_MAC_GMAC_AES192 || algId == CRYPT_MAC_GMAC_AES256) {
macLen = tagLen;
}
ret = CRYPT_EAL_MacFinal(macCtx, mac, &macLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(macCtx);
Iso19790_ProviderUnload(&ctx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_KDF_TEST_TC001(int macId, int iter, int saltLen)
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
(void)macId;
(void)iter;
(void)saltLen;
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_KdfCTX *kdfCtx = NULL;
uint8_t password[32] = {0};
uint32_t passwordLen = sizeof(password);
uint8_t salt[32] = {0};
uint8_t derivedKey[32] = {0};
uint32_t derivedKeyLen = sizeof(derivedKey);
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(ctx.libCtx, CRYPT_KDF_PBKDF2, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(kdfCtx != NULL);
BSL_Param param[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};
(void)BSL_PARAM_InitValue(¶m[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32, &macId, sizeof(macId));
(void)BSL_PARAM_InitValue(¶m[1], CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS, password, passwordLen);
(void)BSL_PARAM_InitValue(¶m[2], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS, salt, saltLen);
(void)BSL_PARAM_InitValue(¶m[3], CRYPT_PARAM_KDF_ITER, BSL_PARAM_TYPE_UINT32, &iter, sizeof(iter));
int32_t ret = CRYPT_EAL_KdfSetParam(kdfCtx, param);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_KdfDerive(kdfCtx, derivedKey, derivedKeyLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_KdfFreeCtx(kdfCtx);
Iso19790_ProviderUnload(&ctx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_KDF_TEST_TC002(int algId, Hex *key, Hex *salt, Hex *info)
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
(void)algId;
(void)key;
(void)salt;
(void)info;
SKIP_TEST();
#else
if (IsHmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_KdfCTX *kdfCtx = NULL;
uint32_t outLen = 32;
uint8_t *out = malloc(outLen * sizeof(uint8_t));
ASSERT_TRUE(out != NULL);
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(ctx.libCtx, CRYPT_KDF_HKDF, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(kdfCtx != NULL);
CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_FULL;
BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&algId, sizeof(algId)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_MODE, BSL_PARAM_TYPE_UINT32,
&mode, sizeof(mode)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
key->x, key->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
salt->x, salt->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_INFO, BSL_PARAM_TYPE_OCTETS,
info->x, info->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(kdfCtx, out, outLen), CRYPT_SUCCESS);
EXIT:
if (out != NULL) {
free(out);
}
CRYPT_EAL_KdfFreeCtx(kdfCtx);
Iso19790_ProviderUnload(&ctx);
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_KDF_TEST_TC003(int algId, Hex *key, Hex *label, Hex *seed)
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
(void)algId;
(void)key;
(void)label;
(void)seed;
SKIP_TEST();
#else
if (IsHmacAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
uint32_t outLen = 32;
uint8_t *out = malloc(outLen * sizeof(uint8_t));
ASSERT_TRUE(out != NULL);
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_KdfCTX *kdfCtx = NULL;
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(ctx.libCtx, CRYPT_KDF_KDFTLS12, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(kdfCtx != NULL);
BSL_Param params[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&algId, sizeof(algId)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
key->x, key->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_LABEL, BSL_PARAM_TYPE_OCTETS,
label->x, label->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_SEED, BSL_PARAM_TYPE_OCTETS,
seed->x, seed->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(kdfCtx, out, outLen), CRYPT_SUCCESS);
EXIT:
if (out != NULL) {
free(out);
}
CRYPT_EAL_KdfFreeCtx(kdfCtx);
Iso19790_ProviderUnload(&ctx);
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_Get_Status_Test_TC001()
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_ProvMgrCtx *providerMgr = NULL;
libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, HITLS_ISO_PROVIDER_PATH), CRYPT_SUCCESS);
bool isLoaded = false;
int32_t ret = CRYPT_EAL_ProviderIsLoaded(libCtx, 0, HITLS_ISO_LIB_NAME, &isLoaded);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_TRUE(isLoaded == false);
BSL_Param providerParam[2] = {{0}, BSL_PARAM_END};
(void)BSL_PARAM_InitValue(&providerParam[0], CRYPT_PARAM_CMVP_LOG_FUNC, BSL_PARAM_TYPE_FUNC_PTR,
ISO19790_RunLogCb, 0);
do {
ret = CRYPT_EAL_ProviderLoad(libCtx, 0, HITLS_ISO_LIB_NAME, providerParam, &providerMgr);
} while (ret == CRYPT_ENTROPY_ES_NO_NS || ret == CRYPT_DRBG_FAIL_GET_ENTROPY || ret == CRYPT_DRBG_FAIL_GET_NONCE);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_TRUE(providerMgr != NULL);
ret = CRYPT_EAL_ProviderIsLoaded(libCtx, 0, HITLS_ISO_LIB_NAME, &isLoaded);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_TRUE(isLoaded);
providerMgr = NULL;
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, 0, HITLS_ISO_LIB_NAME, providerParam, &providerMgr), CRYPT_SUCCESS);
ASSERT_TRUE(providerMgr != NULL);
ret = CRYPT_EAL_ProviderUnload(libCtx, 0, HITLS_ISO_LIB_NAME);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_ProviderIsLoaded(libCtx, 0, HITLS_ISO_LIB_NAME, &isLoaded);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_TRUE(isLoaded);
ret = CRYPT_EAL_ProviderUnload(libCtx, 0, HITLS_ISO_LIB_NAME);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_ProviderIsLoaded(libCtx, 0, HITLS_ISO_LIB_NAME, &isLoaded);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_TRUE(isLoaded == false);
EXIT:
CRYPT_EAL_ProviderUnload(libCtx, 0, HITLS_ISO_LIB_NAME);
CRYPT_EAL_LibCtxFree(libCtx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_CMVP_SELFTEST_Test_TC001()
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_SelftestCtx *selftestCtx = NULL;
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
selftestCtx = CRYPT_CMVP_SelftestNewCtx(ctx.libCtx, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(selftestCtx != NULL);
const char *version = CRYPT_CMVP_GetVersion(selftestCtx);
ASSERT_TRUE(version != NULL);
BSL_Param params[2] = {{0}, BSL_PARAM_END};
int32_t type = CRYPT_CMVP_KAT_TEST;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_CMVP_SELFTEST_TYPE, BSL_PARAM_TYPE_INT32,
&type, sizeof(type)), CRYPT_SUCCESS);
int32_t ret = CRYPT_CMVP_Selftest(selftestCtx, params);
ASSERT_EQ(ret, CRYPT_SUCCESS);
type = CRYPT_CMVP_INTEGRITY_TEST;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_CMVP_SELFTEST_TYPE, BSL_PARAM_TYPE_INT32,
&type, sizeof(type)), CRYPT_SUCCESS);
ret = CRYPT_CMVP_Selftest(selftestCtx, params);
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
CRYPT_CMVP_SelftestFreeCtx(selftestCtx);
Iso19790_ProviderUnload(&ctx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_ML_DSA_TEST_TC001()
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
int32_t mdId = CRYPT_MD_SHAKE128;
uint8_t signature[4627] = {0};
uint32_t signatureLen = sizeof(signature);
uint8_t testData[] = "Test data for signing and verification with ECDSA";
uint32_t testDataLen = sizeof(testData) - 1;
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
pkeyCtx = CRYPT_EAL_ProviderPkeyNewCtx(ctx.libCtx, CRYPT_PKEY_ML_DSA, 0, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(pkeyCtx != NULL);
uint32_t val = CRYPT_MLDSA_TYPE_MLDSA_44;
int32_t ret = CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_PARA_BY_ID, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkeyCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, mdId, testData, testDataLen, signature, &signatureLen), 0);
ASSERT_TRUE(signatureLen > 0);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkeyCtx, mdId, testData, testDataLen, signature, signatureLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
Iso19790_ProviderUnload(&ctx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_ML_KEM_TEST_TC001()
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
uint32_t cipherLen = 0;
uint8_t *ciphertext = NULL;
uint32_t sharedLen = 32;
uint8_t *sharedKey = NULL;
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
pkeyCtx = CRYPT_EAL_ProviderPkeyNewCtx(ctx.libCtx, CRYPT_PKEY_ML_KEM, 0, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(pkeyCtx != NULL);
uint32_t val = CRYPT_KEM_TYPE_MLKEM_512;
int32_t ret = CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_PARA_BY_ID, &val, sizeof(val));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkeyCtx), CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_GET_CIPHERTEXT_LEN, &cipherLen, sizeof(cipherLen));
ASSERT_EQ(ret, CRYPT_SUCCESS);
ciphertext = BSL_SAL_Malloc(cipherLen);
ASSERT_TRUE(ciphertext != NULL);
sharedKey = BSL_SAL_Malloc(sharedLen);
ASSERT_TRUE(sharedKey != NULL);
ret = CRYPT_EAL_PkeyEncaps(pkeyCtx, ciphertext, &cipherLen, sharedKey, &sharedLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
BSL_SAL_Free(ciphertext);
BSL_SAL_Free(sharedKey);
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
Iso19790_ProviderUnload(&ctx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_CIPHPER_TEST_TC001()
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_CipherCtx *cipherCtx = NULL;
uint8_t key[32] = {0};
uint32_t keyLen = 16;
uint8_t iv[32] = {0};
uint32_t ivLen = 16;
uint8_t plain[] = "Test data for signing and verification with ECDSA";
uint32_t plainLen = sizeof(plainLen) - 1;
uint8_t cipher[128] = {0};
uint32_t cipherLen = sizeof(cipher);
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
cipherCtx = CRYPT_EAL_ProviderCipherNewCtx(ctx.libCtx, CRYPT_CIPHER_AES128_CBC, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(cipherCtx != NULL);
int32_t ret = CRYPT_EAL_CipherInit(cipherCtx, key, keyLen, iv, ivLen, true);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherSetPadding(cipherCtx, CRYPT_PADDING_PKCS7);
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t tmpLen = cipherLen;
ret = CRYPT_EAL_CipherUpdate(cipherCtx, plain, plainLen, cipher, &tmpLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
cipherLen = tmpLen;
tmpLen = sizeof(cipher) - cipherLen;
ret = CRYPT_EAL_CipherFinal(cipherCtx, cipher + cipherLen, &tmpLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
cipherLen += tmpLen;
EXIT:
CRYPT_EAL_CipherFreeCtx(cipherCtx);
Iso19790_ProviderUnload(&ctx);
return;
#endif
}
/* END_CASE */
#ifdef HITLS_CRYPTO_CMVP_ISO19790
static void SetDsaPara(CRYPT_EAL_PkeyPara *para, uint8_t *p, uint32_t pLen, uint8_t *q, uint32_t qLen, uint8_t *g, uint32_t gLen)
{
para->id = CRYPT_PKEY_DSA;
para->para.dsaPara.p = p;
para->para.dsaPara.pLen = pLen;
para->para.dsaPara.q = q;
para->para.dsaPara.qLen = qLen;
para->para.dsaPara.g = g;
para->para.dsaPara.gLen = gLen;
}
#endif
/*
SDV_ISO19790_PROVIDER_PKEY_TEST_TC001
测试DSA set para
*/
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_PKEY_TEST_TC001(int hashId, Hex *p, Hex *q, Hex *g)
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
(void)hashId;
(void)p;
(void)q;
(void)g;
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
CRYPT_EAL_PkeyPara para = {0};
uint8_t signature[128] = {0};
uint32_t signatureLen = sizeof(signature);
uint8_t testData[] = "Test data for signing and verification with ECDSA";
uint32_t testDataLen = sizeof(testData) - 1;
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
pkeyCtx = CRYPT_EAL_ProviderPkeyNewCtx(ctx.libCtx, CRYPT_PKEY_DSA, 0, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(pkeyCtx != NULL);
SetDsaPara(¶, p->x, p->len, q->x, q->len, g->x, g->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkeyCtx, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkeyCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, hashId, testData, testDataLen, signature, &signatureLen), 0);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkeyCtx, hashId, testData, testDataLen, signature, signatureLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
Iso19790_ProviderUnload(&ctx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_MAC_PARAM_CHECK_TC001(int algId, int keyLen)
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
(void)algId;
(void)keyLen;
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_MacCtx *macCtx = NULL;
uint8_t macKey[32] = {0};
uint32_t macKeyLen = 13;
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
macCtx = CRYPT_EAL_ProviderMacNewCtx(ctx.libCtx, algId, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(macCtx != NULL);
int32_t ret = CRYPT_EAL_MacInit(macCtx, macKey, macKeyLen);
ASSERT_EQ(ret, CRYPT_CMVP_ERR_PARAM_CHECK);
macKeyLen = keyLen;
ret = CRYPT_EAL_MacInit(macCtx, macKey, macKeyLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(macCtx);
Iso19790_ProviderUnload(&ctx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_KDF_PARAM_CHECK_TC001(Hex *key, Hex *label, Hex *seed)
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
(void)key;
(void)label;
(void)seed;
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_KdfCTX *kdfCtx = NULL;
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(ctx.libCtx, CRYPT_KDF_KDFTLS12, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(kdfCtx != NULL);
BSL_Param params[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
key->x, 14), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_LABEL, BSL_PARAM_TYPE_OCTETS,
label->x, label->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_SEED, BSL_PARAM_TYPE_OCTETS,
seed->x, seed->len), CRYPT_SUCCESS);
int32_t macId = CRYPT_MAC_HMAC_SHA224;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&macId, sizeof(macId)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, params), CRYPT_CMVP_ERR_PARAM_CHECK);
macId = CRYPT_MAC_HMAC_SHA256;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&macId, sizeof(macId)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, params), CRYPT_SUCCESS);
// key len < 112 / 8
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
key->x, 13), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, params), CRYPT_CMVP_ERR_PARAM_CHECK);
EXIT:
CRYPT_EAL_KdfFreeCtx(kdfCtx);
Iso19790_ProviderUnload(&ctx);
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_KDF_PARAM_CHECK_TC002(Hex *key, Hex *salt, Hex *info)
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
(void)key;
(void)salt;
(void)info;
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_KdfCTX *kdfCtx = NULL;
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(ctx.libCtx, CRYPT_KDF_HKDF, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(kdfCtx != NULL);
int32_t macId = CRYPT_MAC_HMAC_SHA256;
CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_FULL;
BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
&macId, sizeof(macId)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_MODE, BSL_PARAM_TYPE_UINT32,
&mode, sizeof(mode)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
key->x, key->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
salt->x, salt->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_INFO, BSL_PARAM_TYPE_OCTETS,
info->x, info->len), CRYPT_SUCCESS);
macId = CRYPT_MAC_HMAC_SM3;
ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, params), CRYPT_CMVP_ERR_PARAM_CHECK);
macId = CRYPT_MAC_HMAC_SHA256;
ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, params), CRYPT_SUCCESS);
// key len < 112 / 8
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
key->x, 13), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, params), CRYPT_CMVP_ERR_PARAM_CHECK);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
key->x, 14), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, params), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_KdfFreeCtx(kdfCtx);
Iso19790_ProviderUnload(&ctx);
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_KDF_PARAM_CHECK_TC003()
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_KdfCTX *kdfCtx = NULL;
uint8_t password[32] = {0};
uint32_t passwordLen = sizeof(password);
uint8_t salt[32] = {0};
uint8_t derivedKey[32] = {0};
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(ctx.libCtx, CRYPT_KDF_PBKDF2, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(kdfCtx != NULL);
int32_t iter = 1024;
int32_t saltLen = 16;
int32_t macId = CRYPT_MAC_SIPHASH64;
BSL_Param param[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};
(void)BSL_PARAM_InitValue(¶m[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32, &macId, sizeof(macId));
(void)BSL_PARAM_InitValue(¶m[1], CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS, password, passwordLen);
(void)BSL_PARAM_InitValue(¶m[2], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS, salt, saltLen);
(void)BSL_PARAM_InitValue(¶m[3], CRYPT_PARAM_KDF_ITER, BSL_PARAM_TYPE_UINT32, &iter, sizeof(iter));
int32_t ret = CRYPT_EAL_KdfSetParam(kdfCtx, param);
ASSERT_EQ(ret, CRYPT_CMVP_ERR_PARAM_CHECK);
macId = CRYPT_MAC_HMAC_SHA1;
ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, param), CRYPT_SUCCESS);
iter = 999;
ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, param), CRYPT_CMVP_ERR_PARAM_CHECK);
iter = 1000;
ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, param), CRYPT_SUCCESS);
saltLen = 15;
(void)BSL_PARAM_InitValue(¶m[2], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS, salt, saltLen);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, param), CRYPT_CMVP_ERR_PARAM_CHECK);
saltLen = 16;
(void)BSL_PARAM_InitValue(¶m[2], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS, salt, saltLen);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, param), CRYPT_SUCCESS);
uint32_t derivedKeyLen = 13;
ret = CRYPT_EAL_KdfDerive(kdfCtx, derivedKey, derivedKeyLen);
ASSERT_EQ(ret, CRYPT_CMVP_ERR_PARAM_CHECK);
derivedKeyLen = 14;
ret = CRYPT_EAL_KdfDerive(kdfCtx, derivedKey, derivedKeyLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_KdfFreeCtx(kdfCtx);
Iso19790_ProviderUnload(&ctx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_DSA_PARAM_CHECK_TC001(Hex *p, Hex *q, Hex *g)
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
(void)p;
(void)q;
(void)g;
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
CRYPT_EAL_PkeyPara para = {0};
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
pkeyCtx = CRYPT_EAL_ProviderPkeyNewCtx(ctx.libCtx, CRYPT_PKEY_DSA, 0, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(pkeyCtx != NULL);
SetDsaPara(¶, p->x, 256, q->x, 27, g->x, 256);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkeyCtx, ¶), CRYPT_CMVP_ERR_PARAM_CHECK);
SetDsaPara(¶, p->x, 256, q->x, 31, g->x, 256);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkeyCtx, ¶), CRYPT_CMVP_ERR_PARAM_CHECK);
SetDsaPara(¶, p->x, 384, q->x, 31, g->x, 384);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkeyCtx, ¶), CRYPT_CMVP_ERR_PARAM_CHECK);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
Iso19790_ProviderUnload(&ctx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_RSA_PARAM_CHECK_TC001()
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
uint8_t e[] = {1, 0, 1};
CRYPT_EAL_PkeyPara para = {0};
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
pkeyCtx = CRYPT_EAL_ProviderPkeyNewCtx(ctx.libCtx, CRYPT_PKEY_RSA, 0, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(pkeyCtx != NULL);
SetRsaPara(¶, e, 3, 1024);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkeyCtx, ¶), CRYPT_CMVP_ERR_PARAM_CHECK);
SetRsaPara(¶, e, 3, 2048);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkeyCtx, ¶), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
Iso19790_ProviderUnload(&ctx);
return;
#endif
}
/* END_CASE */
/*
Check the padding mode of the RSA.
*/
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_RSA_PARAM_CHECK_TC002()
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
uint8_t e[] = {1, 0, 1};
CRYPT_EAL_PkeyPara para = {0};
int32_t mdId = CRYPT_MD_SHA256;
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
pkeyCtx = CRYPT_EAL_ProviderPkeyNewCtx(ctx.libCtx, CRYPT_PKEY_RSA, 0, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(pkeyCtx != NULL);
SetRsaPara(¶, e, 3, 2048);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkeyCtx, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkeyCtx), CRYPT_SUCCESS);
int32_t pkcsv15 = mdId;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_RSAES_PKCSV15, &pkcsv15, sizeof(pkcsv15)),
CRYPT_CMVP_ERR_PARAM_CHECK);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_RSAES_PKCSV15_TLS, &pkcsv15, sizeof(pkcsv15)),
CRYPT_CMVP_ERR_PARAM_CHECK);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_NO_PADDING, NULL, 0), CRYPT_CMVP_ERR_PARAM_CHECK);
int32_t pad = CRYPT_EMSA_PKCSV15;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_PADDING, &pad, sizeof(pad)), CRYPT_SUCCESS);
pad = CRYPT_EMSA_PSS;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_PADDING, &pad, sizeof(pad)), CRYPT_SUCCESS);
pad = CRYPT_RSAES_OAEP;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_PADDING, &pad, sizeof(pad)), CRYPT_SUCCESS);
pad = CRYPT_RSAES_PKCSV15;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_PADDING, &pad, sizeof(pad)), CRYPT_CMVP_ERR_PARAM_CHECK);
pad = CRYPT_RSA_NO_PAD;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_PADDING, &pad, sizeof(pad)), CRYPT_CMVP_ERR_PARAM_CHECK);
pad = CRYPT_RSAES_PKCSV15_TLS;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_PADDING, &pad, sizeof(pad)), CRYPT_CMVP_ERR_PARAM_CHECK);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)), CRYPT_SUCCESS);
BSL_Param pssParam[3] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
BSL_PARAM_END};
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PSS, pssParam, 0), CRYPT_SUCCESS);
BSL_Param oaep[3] = {{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
BSL_PARAM_END
};
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_RSAES_OAEP, oaep, 0), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
Iso19790_ProviderUnload(&ctx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_ECDH_SM2_TEST_TC001()
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_PkeyCtx *pkeyCtx1 = NULL;
CRYPT_EAL_PkeyCtx *pkeyCtx2 = NULL;
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
pkeyCtx1 = CRYPT_EAL_ProviderPkeyNewCtx(ctx.libCtx, CRYPT_PKEY_ECDH, 0, HITLS_ISO_PROVIDER_ATTR);
pkeyCtx2 = CRYPT_EAL_ProviderPkeyNewCtx(ctx.libCtx, CRYPT_PKEY_ECDH, 0, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(pkeyCtx1 != NULL && pkeyCtx2 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkeyCtx1, CRYPT_ECC_SM2), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkeyCtx2, CRYPT_ECC_SM2), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkeyCtx1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkeyCtx2), CRYPT_SUCCESS);
uint8_t sharedKey1[32] = {0};
uint32_t sharedKeyLen1 = sizeof(sharedKey1);
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(pkeyCtx1, pkeyCtx2, sharedKey1, &sharedKeyLen1), CRYPT_SUCCESS);
ASSERT_EQ(sharedKeyLen1, 32);
uint8_t sharedKey2[32] = {0};
uint32_t sharedKeyLen2 = sizeof(sharedKey2);
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(pkeyCtx2, pkeyCtx1, sharedKey2, &sharedKeyLen2), CRYPT_SUCCESS);
ASSERT_EQ(sharedKeyLen2, 32);
ASSERT_EQ(memcmp(sharedKey1, sharedKey2, sharedKeyLen1), 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx1);
CRYPT_EAL_PkeyFreeCtx(pkeyCtx2);
Iso19790_ProviderUnload(&ctx);
return;
#endif
}
/* END_CASE */
/*
Test event report log.
*/
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_RUN_LOG_TEST_TC001()
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
CRYPT_EAL_RegEventReport(ISO19790_RunLogCb);
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
pkeyCtx = CRYPT_EAL_ProviderPkeyNewCtx(ctx.libCtx, BSL_CID_UNKNOWN, 0, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(pkeyCtx == NULL);
EXIT:
Iso19790_ProviderUnload(&ctx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_DH_CHECK_TEST_TC001()
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
SKIP_TEST();
#else
Iso19790_ProviderLoadCtx ctx = {0};
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
Iso19790_ProviderLoad(&ctx);
ASSERT_TRUE(ctx.libCtx != NULL && ctx.es != NULL && ctx.pool != NULL);
pkeyCtx = CRYPT_EAL_ProviderPkeyNewCtx(ctx.libCtx, CRYPT_PKEY_DH, 0, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(pkeyCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkeyCtx, CRYPT_DH_RFC7919_2048), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkeyCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkeyCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pkeyCtx, pkeyCtx), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
Iso19790_ProviderUnload(&ctx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_ISO19790_PROVIDER_MD_USE_DEFAULT_LIBCTX_TEST_TC001(int algId)
{
#ifndef HITLS_CRYPTO_CMVP_ISO19790
(void)algId;
SKIP_TEST();
#else
int32_t ret = CRYPT_SUCCESS;
CRYPT_EAL_MdCTX *mdCtx = NULL;
uint8_t plaintext[128] = {0};
uint32_t plaintextLen = sizeof(plaintext);
uint8_t md[128] = {0};
uint32_t mdLen = sizeof(md);
BSL_Param param[2] = {{0}, BSL_PARAM_END};
(void)BSL_PARAM_InitValue(¶m[0], CRYPT_PARAM_CMVP_LOG_FUNC, BSL_PARAM_TYPE_FUNC_PTR, ISO19790_RunLogCb, 0);
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(NULL, HITLS_ISO_PROVIDER_PATH), CRYPT_SUCCESS);
do {
ret = CRYPT_EAL_ProviderLoad(NULL, 0, HITLS_ISO_LIB_NAME, param, NULL);
} while (ret == CRYPT_ENTROPY_ES_NO_NS || ret == CRYPT_DRBG_FAIL_GET_ENTROPY || ret == CRYPT_DRBG_FAIL_GET_NONCE);
ASSERT_EQ(ret, CRYPT_SUCCESS);
do {
ret = CRYPT_EAL_ProviderRandInitCtx(NULL, CRYPT_RAND_SHA256, HITLS_ISO_PROVIDER_ATTR, NULL, 0, NULL);
} while (ret == CRYPT_ENTROPY_ES_NO_NS || ret == CRYPT_DRBG_FAIL_GET_ENTROPY || ret == CRYPT_DRBG_FAIL_GET_NONCE);
ASSERT_EQ(ret, CRYPT_SUCCESS);
mdCtx = CRYPT_EAL_ProviderMdNewCtx(NULL, algId, HITLS_ISO_PROVIDER_ATTR);
ASSERT_TRUE(mdCtx != NULL);
ret = CRYPT_EAL_MdInit(mdCtx);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_MdUpdate(mdCtx, plaintext, plaintextLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_MdFinal(mdCtx, md, &mdLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MdFreeCtx(mdCtx);
CRYPT_EAL_RandDeinitEx(NULL);
CRYPT_EAL_ProviderUnload(NULL, 0, HITLS_ISO_LIB_NAME);
return;
#endif
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/provider/test_suite_sdv_eal_iso19790_provider.c | C | unknown | 51,313 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include "crypt_errno.h"
#include "crypt_algid.h"
#include "crypt_eal_md.h"
#include "crypt_eal_mac.h"
#include "crypt_eal_kdf.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_rand.h"
#include "crypt_eal_provider.h"
#include "crypt_params_key.h"
/* END_HEADER */
#define SHA2_OUTPUT_MAXSIZE 32
#define MAX_CIPHERTEXT_LEN 2048
#define DEFAULT_PROVIDER "default"
#ifdef HITLS_CRYPTO_PROVIDER
static int32_t InitTwoProviders(CRYPT_EAL_LibCtx **libCtx, const char *path, const char *providerName1,
const char *providerName2)
{
*libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(*libCtx != NULL);
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(*libCtx, path), 0);
if (strcmp(providerName1, DEFAULT_PROVIDER) == 0) {
ASSERT_EQ(CRYPT_EAL_ProviderLoad(*libCtx, BSL_SAL_LIB_FMT_OFF, providerName1, NULL, NULL), 0);
} else {
ASSERT_EQ(CRYPT_EAL_ProviderLoad(*libCtx, BSL_SAL_LIB_FMT_SO, providerName1, NULL, NULL), 0);
}
if (strcmp(providerName2, DEFAULT_PROVIDER) == 0) {
ASSERT_EQ(CRYPT_EAL_ProviderLoad(*libCtx, BSL_SAL_LIB_FMT_OFF, providerName2, NULL, NULL), 0);
} else {
ASSERT_EQ(CRYPT_EAL_ProviderLoad(*libCtx, BSL_SAL_LIB_FMT_SO, providerName2, NULL, NULL), 0);
}
return 0;
EXIT:
CRYPT_EAL_LibCtxFree(*libCtx);
*libCtx = NULL;
return 1;
}
#endif
void NoUsedParam(char *path, char *defProName, char *customProName, char *defAttr, char *customAttr)
{
(void)path;
(void)defProName;
(void)customProName;
(void)defAttr;
(void)customAttr;
}
/**
* @test SDV_PROVIDER_SHA256_TC001
* @title SHA256 test: sha256 from no-provider, default provider or other provider
*/
/* BEGIN_CASE */
void SDV_PROVIDER_SHA256_TC001(char *path, char *defProName, char *customProName, char *customAttr,
Hex *in, Hex *digest)
{
#if defined(HITLS_CRYPTO_MD) && defined(HITLS_CRYPTO_PROVIDER)
CRYPT_EAL_MdCTX *ctx = NULL;
CRYPT_EAL_LibCtx *libCtx = NULL;
uint8_t out[SHA2_OUTPUT_MAXSIZE];
uint32_t outLen = SHA2_OUTPUT_MAXSIZE;
TestMemInit();
ASSERT_EQ(InitTwoProviders(&libCtx, path, defProName, customProName), 0);
ctx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_SHA256, customAttr);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), 0);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, in->x, in->len), 0);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &outLen), 0);
ASSERT_COMPARE("other provider sha256", out, outLen, digest->x, digest->len);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
CRYPT_EAL_LibCtxFree(libCtx);
#else
NoUsedParam(path, defProName, customProName, NULL, customAttr);
(void)in;
(void)digest;
SKIP_TEST();
#endif
}
/* END_CASE */
/**
* @test SDV_PROVIDER_HMAC_TC001
* @title HMAC test
*/
/* BEGIN_CASE */
void SDV_PROVIDER_HMAC_TC001(char *path, char *defProName, char *customProName, char *defAttr, char *customAttr,
int algId, Hex *key, Hex *data, Hex *vecMac)
{
#if defined(HITLS_CRYPTO_HMAC) && defined(HITLS_CRYPTO_PROVIDER)
uint8_t *out = NULL;
uint32_t outLen = vecMac->len;
CRYPT_EAL_MacCtx *ctx = NULL;
CRYPT_EAL_LibCtx *libCtx = NULL;
BSL_Param params[] = {{0}, BSL_PARAM_END}; // Set 1 parameter for hmac
TestMemInit();
ASSERT_EQ(InitTwoProviders(&libCtx, path, defProName, customProName), 0);
out = (uint8_t *)BSL_SAL_Malloc(outLen);
ASSERT_TRUE(out != NULL);
// HMAC-SHA256: hmac from default provider, sha256 from custom provider
ctx = CRYPT_EAL_ProviderMacNewCtx(libCtx, algId, strlen(defAttr) == 0 ? NULL : defAttr);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_MD_ATTR, BSL_PARAM_TYPE_UTF8_STR, customAttr,
strlen(customAttr)), 0);
ASSERT_EQ(CRYPT_EAL_MacSetParam(ctx, params), 0);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key->x, key->len), 0);
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data->x, data->len), 0);
ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, out, &outLen), 0);
ASSERT_COMPARE("default hmac other sha256", out, outLen, vecMac->x, vecMac->len);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
CRYPT_EAL_LibCtxFree(libCtx);
BSL_SAL_Free(out);
#else
NoUsedParam(path, defProName, customProName, defAttr, customAttr);
(void)algId;
(void)key;
(void)data;
(void)vecMac;
SKIP_TEST();
#endif
}
/* END_CASE */
/**
* @test SDV_PROVIDER_HKDF_TC001
* @title hkdf-hmac-sha256 provider test, hkdf-hmac from default provider, sha256 from provider1 or provider2
*/
/* BEGIN_CASE */
void SDV_PROVIDER_HKDF_TC001(char *path, char *defProName, char *customProName, char *defAttr, char *customAttr,
int macId, Hex *key, Hex *salt, Hex *info, Hex *result)
{
#if defined(HITLS_CRYPTO_HKDF) && defined(HITLS_CRYPTO_PROVIDER)
uint8_t *out = NULL;
uint32_t outLen = result->len;
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_KdfCTX *ctx = NULL;
BSL_Param params[7] = {{0}, {0}, {0}, {0}, {0}, {0}, BSL_PARAM_END}; // Set 6 parameters for hkdf
CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_FULL;
TestMemInit();
ASSERT_EQ(InitTwoProviders(&libCtx, path, defProName, customProName), 0);
out = (uint8_t *)BSL_SAL_Malloc(outLen);
ASSERT_TRUE(out != NULL);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32, &macId, sizeof(macId)), 0);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_MODE, BSL_PARAM_TYPE_UINT32, &mode, sizeof(mode)), 0);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS, key->x, key->len), 0);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS, salt->x, salt->len), 0);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_INFO, BSL_PARAM_TYPE_OCTETS, info->x, info->len), 0);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[5], CRYPT_PARAM_MD_ATTR, BSL_PARAM_TYPE_UTF8_STR, customAttr,
strlen(customAttr)), 0);
// HMAC-SHA256: hmac from default provider, sha256 from custom provider
ctx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_HKDF, strlen(defAttr) == 0 ? NULL : defAttr);
ASSERT_TRUE(ctx != NULL);
// sha256 form provider2
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), 0);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), 0);
ASSERT_COMPARE("default hkdf-hmac other sha256", out, outLen, result->x, result->len);
EXIT:
CRYPT_EAL_KdfFreeCtx(ctx);
CRYPT_EAL_LibCtxFree(libCtx);
BSL_SAL_Free(out);
#else
NoUsedParam(path, defProName, customProName, defAttr, customAttr);
(void)macId;
(void)key;
(void)salt;
(void)info;
(void)result;
SKIP_TEST();
#endif
}
/* END_CASE */
/**
* @test SDV_PROVIDER_PBKDF2_TC001
* @title pbkdf2-hmac-sha256 provider test, pbkdf2 from default provider, sha256 from provider1 or provider2
*/
/* BEGIN_CASE */
void SDV_PROVIDER_PBKDF2_TC001(char *path, char *defProName, char *customProName, char *defAttr, char *customAttr,
int macId, Hex *key, Hex *salt, int it, Hex *result)
{
#if defined(HITLS_CRYPTO_PBKDF2) && defined(HITLS_CRYPTO_PROVIDER)
uint8_t *out = NULL;
uint32_t outLen = result->len;
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_KdfCTX *ctx = NULL;
BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END}; // Set 5 parameters for pbkdf2
TestMemInit();
ASSERT_EQ(InitTwoProviders(&libCtx, path, defProName, customProName), 0);
out = (uint8_t *)BSL_SAL_Malloc(outLen);
ASSERT_TRUE(out != NULL);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32, &macId, sizeof(macId)), 0);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS, key->x, key->len), 0);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS, salt->x, salt->len), 0);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_ITER, BSL_PARAM_TYPE_UINT32, &it, sizeof(it)), 0);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_MD_ATTR, BSL_PARAM_TYPE_UTF8_STR, customAttr,
strlen(customAttr)), 0);
// provider1: pbkdf2, provider2: sha256
ctx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_PBKDF2, strlen(defAttr) == 0 ? NULL : defAttr);
ASSERT_TRUE(ctx != NULL);
// sha256 form provider2
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), 0);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), 0);
ASSERT_COMPARE("default pbkdf2 other sha256", out, outLen, result->x, result->len);
EXIT:
CRYPT_EAL_KdfFreeCtx(ctx);
CRYPT_EAL_LibCtxFree(libCtx);
BSL_SAL_Free(out);
#else
NoUsedParam(path, defProName, customProName, defAttr, customAttr);
(void)macId;
(void)key;
(void)salt;
(void)it;
(void)result;
SKIP_TEST();
#endif
}
/* END_CASE */
/**
* @test SDV_PROVIDER_KDFTLS12_TC001
* @title kdftls12-hmac-sha256 provider test, kdftls12 from default provider, sha256 from provider1 or provider2
*/
/* BEGIN_CASE */
void SDV_PROVIDER_KDFTLS12_TC001(char *path, char *defProName, char *customProName, char *defAttr, char *customAttr,
int macId, Hex *key, Hex *label, Hex *seed, Hex *result)
{
#if defined(HITLS_CRYPTO_KDFTLS12) && defined(HITLS_CRYPTO_PROVIDER)
uint8_t *out = NULL;
uint32_t outLen = result->len;
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_KdfCTX *ctx = NULL;
BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END}; // Set 5 parameters for kdftls12
TestMemInit();
ASSERT_EQ(InitTwoProviders(&libCtx, path, defProName, customProName), 0);
out = (uint8_t *)BSL_SAL_Malloc(outLen);
ASSERT_TRUE(out != NULL);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32, &macId, sizeof(macId)), 0);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS, key->x, key->len), 0);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_LABEL, BSL_PARAM_TYPE_OCTETS, label->x, label->len), 0);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_SEED, BSL_PARAM_TYPE_OCTETS, seed->x, seed->len), 0);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_MD_ATTR, BSL_PARAM_TYPE_UTF8_STR, customAttr,
strlen(customAttr)), 0);
// provider1: kdftls12, provider2: sha256
ctx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_KDFTLS12, strlen(defAttr) == 0 ? NULL : defAttr);
ASSERT_TRUE(ctx != NULL);
// sha256 form provider2
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), 0);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), 0);
ASSERT_COMPARE("default kdftls12 other sha256", out, outLen, result->x, result->len);
EXIT:
CRYPT_EAL_KdfFreeCtx(ctx);
CRYPT_EAL_LibCtxFree(libCtx);
BSL_SAL_Free(out);
#else
NoUsedParam(path, defProName, customProName, defAttr, customAttr);
(void)macId;
(void)key;
(void)label;
(void)seed;
(void)result;
SKIP_TEST();
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PROVIDER_RSA_SIGN_TC001
* @title rsa-sign provider test, rsa-sign from default provider, sha256 from provider1 or provider2
*/
/* BEGIN_CASE */
void SDV_PROVIDER_RSA_SIGN_VERIFY_PKCSV15_TC001(char *path, char *defProName, char *customProName, char *defAttr,
char *customAttr, int mdId, Hex *n, Hex *e, Hex *d, Hex *msg)
{
#if defined(HITLS_CRYPTO_RSA_SIGN) && defined(HITLS_CRYPTO_RSA_EMSA_PKCSV15) && defined(HITLS_CRYPTO_PROVIDER)
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_PkeyCtx *ctx = NULL;
uint8_t sign[MAX_CIPHERTEXT_LEN] = {0};
uint32_t signLen = MAX_CIPHERTEXT_LEN;
CRYPT_EAL_PkeyPrv prvKey = {.id = CRYPT_PKEY_RSA, .key.rsaPrv.n = n->x, .key.rsaPrv.nLen = n->len,
.key.rsaPrv.d = d->x, .key.rsaPrv.dLen = d->len};
CRYPT_EAL_PkeyPub pubKey = {.id = CRYPT_PKEY_RSA, .key.rsaPub.n = n->x, .key.rsaPub.nLen = n->len,
.key.rsaPub.e = e->x, .key.rsaPub.eLen = e->len};
BSL_Param params[2] = {{0}, BSL_PARAM_END}; // Set 1 parameter for hmac
TestMemInit();
ASSERT_EQ(InitTwoProviders(&libCtx, path, defProName, customProName), 0);
ASSERT_EQ(TestRandInitEx(libCtx), 0);
// rsa-sign-verify-pkcsv15 from default provider, sha256 from custom provider
ctx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_SIGN_OPERATE,
strlen(defAttr) == 0 ? NULL : defAttr);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &pubKey), 0);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &prvKey), 0);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_MD_ATTR, BSL_PARAM_TYPE_UTF8_STR, customAttr,
strlen(customAttr)), 0);
ASSERT_EQ(CRYPT_EAL_PkeySetParaEx(ctx, params), 0);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &mdId, sizeof(mdId)), 0);
signLen = MAX_CIPHERTEXT_LEN;
ASSERT_EQ(CRYPT_EAL_PkeySign(ctx, mdId, msg->x, msg->len, sign, &signLen), 0);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(ctx, mdId, msg->x, msg->len, sign, signLen), 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_EAL_LibCtxFree(libCtx);
CRYPT_EAL_RandDeinit();
#else
NoUsedParam(path, defProName, customProName, defAttr, customAttr);
(void)mdId;
(void)n;
(void)e;
(void)d;
(void)msg;
SKIP_TEST();
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PROVIDER_RSA_SIGN_VERIFY_PSS_TC001
* @title rsa-sign-verify-pss provider test, rsa-sign-verify-pss from default provider
*/
/* BEGIN_CASE */
void SDV_PROVIDER_RSA_SIGN_VERIFY_PSS_TC001(char *path, char *defProName, char *customProName, char *defAttr,
char *customAttr, int mdId, Hex *n, Hex *e, Hex *d, Hex *msg, int saltLen)
{
#if defined(HITLS_CRYPTO_RSA_SIGN) && defined(HITLS_CRYPTO_RSA_EMSA_PSS) && defined(HITLS_CRYPTO_PROVIDER)
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_PkeyCtx *ctx = NULL;
CRYPT_EAL_PkeyPrv prvKey = {.id = CRYPT_PKEY_RSA, .key.rsaPrv.n = n->x, .key.rsaPrv.nLen = n->len,
.key.rsaPrv.d = d->x, .key.rsaPrv.dLen = d->len};
CRYPT_EAL_PkeyPub pubKey = {.id = CRYPT_PKEY_RSA, .key.rsaPub.n = n->x, .key.rsaPub.nLen = n->len,
.key.rsaPub.e = e->x, .key.rsaPub.eLen = e->len};
uint8_t sign[MAX_CIPHERTEXT_LEN] = {0};
uint32_t signLen = MAX_CIPHERTEXT_LEN;
BSL_Param pssParam[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &saltLen, sizeof(saltLen), 0},
BSL_PARAM_END};
BSL_Param params[2] = {{0}, BSL_PARAM_END}; // Set 1 parameter for RSA
TestMemInit();
ASSERT_EQ(InitTwoProviders(&libCtx, path, defProName, customProName), 0);
ASSERT_EQ(TestRandInitEx(libCtx), 0);
// rsa-sign-verify-pss from default provider, sha256 from custom provider
ctx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_SIGN_OPERATE,
strlen(defAttr) == 0 ? NULL : defAttr);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &pubKey), 0);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &prvKey), 0);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_RSA_EMSA_PSS, &pssParam, 0), 0);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_MD_ATTR, BSL_PARAM_TYPE_UTF8_STR, customAttr,
strlen(customAttr)), 0);
ASSERT_EQ(CRYPT_EAL_PkeySetParaEx(ctx, params), 0);
signLen = MAX_CIPHERTEXT_LEN;
ASSERT_EQ(CRYPT_EAL_PkeySign(ctx, mdId, msg->x, msg->len, sign, &signLen), 0);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(ctx, mdId, msg->x, msg->len, sign, signLen), 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_EAL_LibCtxFree(libCtx);
CRYPT_EAL_RandDeinit();
#else
NoUsedParam(path, defProName, customProName, defAttr, customAttr);
(void)mdId;
(void)n;
(void)e;
(void)d;
(void)msg;
(void)saltLen;
SKIP_TEST();
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PROVIDER_RSA_RSABSSA_BLINDING_TC001
* @title rsa-rsabssa-blinding provider test, rsa-rsabssa-blinding from default provider
*/
/* BEGIN_CASE */
void SDV_PROVIDER_RSA_RSABSSA_BLINDING_TC001(char *path, char *defProName, char *customProName, char *defAttr,
char *customAttr, int mdId, Hex *n, Hex *e, Hex *d, Hex *msg, int saltLen)
{
#if defined(HITLS_CRYPTO_RSA_SIGN) && defined(HITLS_CRYPTO_RSA_BSSA) && defined(HITLS_CRYPTO_PROVIDER)
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_PkeyCtx *ctx = NULL;
CRYPT_EAL_PkeyPrv prvKey = {.id = CRYPT_PKEY_RSA, .key.rsaPrv.n = n->x, .key.rsaPrv.nLen = n->len,
.key.rsaPrv.d = d->x, .key.rsaPrv.dLen = d->len};
CRYPT_EAL_PkeyPub pubKey = {.id = CRYPT_PKEY_RSA, .key.rsaPub.n = n->x, .key.rsaPub.nLen = n->len,
.key.rsaPub.e = e->x, .key.rsaPub.eLen = e->len};
#ifdef HITLS_CRYPTO_RSA_SIGN
uint8_t blindMsg[MAX_CIPHERTEXT_LEN] = {0};
uint32_t blindMsgLen = MAX_CIPHERTEXT_LEN;
#endif
#ifdef HITLS_CRYPTO_RSA_VERIFY
uint8_t unBlindSig[MAX_CIPHERTEXT_LEN] = {0};
uint32_t unBlindSigLen = MAX_CIPHERTEXT_LEN;
#endif
uint32_t flag = CRYPT_RSA_BSSA;
uint8_t sign[MAX_CIPHERTEXT_LEN] = {0};
uint32_t signLen = MAX_CIPHERTEXT_LEN;
BSL_Param pssParam[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &saltLen, sizeof(saltLen), 0},
BSL_PARAM_END};
BSL_Param params[2] = {{0}, BSL_PARAM_END}; // Set 1 parameter for RSA
TestMemInit();
ASSERT_EQ(InitTwoProviders(&libCtx, path, defProName, customProName), 0);
ASSERT_EQ(TestRandInitEx(libCtx), 0);
// rsa-rsabssa-blinding from default provider, sha256 from custom provider
ctx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_SIGN_OPERATE,
strlen(defAttr) == 0 ? NULL : defAttr);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &pubKey), 0);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &prvKey), 0);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_RSA_EMSA_PSS, &pssParam, 0), 0);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_MD_ATTR, BSL_PARAM_TYPE_UTF8_STR, customAttr,
strlen(customAttr)), 0);
ASSERT_EQ(CRYPT_EAL_PkeySetParaEx(ctx, params), 0);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_RSA_FLAG, (void *)&flag, sizeof(uint32_t)), 0);
#ifdef HITLS_CRYPTO_RSA_SIGN
ASSERT_EQ(CRYPT_EAL_PkeyBlind(ctx, mdId, msg->x, msg->len, blindMsg, &blindMsgLen), 0);
ASSERT_EQ(CRYPT_EAL_PkeySignData(ctx, blindMsg, blindMsgLen, sign, &signLen), 0);
#endif
#ifdef HITLS_CRYPTO_RSA_VERIFY
ASSERT_EQ(CRYPT_EAL_PkeyUnBlind(ctx, sign, signLen, unBlindSig, &unBlindSigLen), 0);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(ctx, mdId, msg->x, msg->len, unBlindSig, unBlindSigLen), 0);
#endif
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_EAL_LibCtxFree(libCtx);
CRYPT_EAL_RandDeinit();
#else
NoUsedParam(path, defProName, customProName, defAttr, customAttr);
(void)mdId;
(void)n;
(void)e;
(void)d;
(void)msg;
(void)saltLen;
SKIP_TEST();
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_PROVIDER_RSA_CRYPT_FUNC_TC001(char *path, char *defProName, char *customProName, char *defAttr,
char *customAttr, int padMode, int mdId, Hex *n, Hex *e, Hex *d, Hex *plaintext)
{
#if defined(HITLS_CRYPTO_RSA_DECRYPT) && defined(HITLS_CRYPTO_RSA_ENCRYPT) && defined(HITLS_CRYPTO_PROVIDER)
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_PkeyPrv prvkey = {.id = CRYPT_PKEY_RSA, .key.rsaPrv.n = n->x, .key.rsaPrv.nLen = n->len,
.key.rsaPrv.d = d->x, .key.rsaPrv.dLen = d->len};
CRYPT_EAL_PkeyPub pubkey = {.id = CRYPT_PKEY_RSA, .key.rsaPub.n = n->x, .key.rsaPub.nLen = n->len,
.key.rsaPub.e = e->x, .key.rsaPub.eLen = e->len};
CRYPT_EAL_PkeyCtx *ctx = NULL;
BSL_Param oaepParam[3] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
BSL_PARAM_END};
int32_t pkcsv15 = mdId;
uint8_t pt[MAX_CIPHERTEXT_LEN] = {0};
uint32_t ptLen = MAX_CIPHERTEXT_LEN;
uint8_t ct[MAX_CIPHERTEXT_LEN] = {0};
uint32_t ctLen = MAX_CIPHERTEXT_LEN;
int paraSize;
void *paraPtr;
BSL_Param params[2] = {{0}, BSL_PARAM_END}; // Set 1 parameter for RSA
if (padMode == CRYPT_CTRL_SET_RSA_RSAES_OAEP) {
paraSize = 0;
paraPtr = oaepParam;
} else if (padMode == CRYPT_CTRL_SET_RSA_RSAES_PKCSV15) {
paraSize = sizeof(pkcsv15);
paraPtr = &pkcsv15;
}
TestMemInit();
ASSERT_EQ(InitTwoProviders(&libCtx, path, defProName, customProName), 0);
ASSERT_EQ(TestRandInitEx(libCtx), 0);
ctx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_CIPHER_OPERATE,
strlen(defAttr) == 0 ? NULL : defAttr);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &prvkey), 0);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &pubkey), 0);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, padMode, paraPtr, paraSize), 0);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_MD_ATTR, BSL_PARAM_TYPE_UTF8_STR, customAttr,
strlen(customAttr)), 0);
ASSERT_EQ(CRYPT_EAL_PkeySetParaEx(ctx, params), 0);
ASSERT_EQ(CRYPT_EAL_PkeyEncrypt(ctx, plaintext->x, plaintext->len, ct, &ctLen), 0);
ASSERT_EQ(CRYPT_EAL_PkeyDecrypt(ctx, ct, ctLen, pt, &ptLen), 0);
ASSERT_EQ(ptLen, plaintext->len);
ASSERT_COMPARE("rsa encrypt and decrypt", pt, ptLen, plaintext->x, plaintext->len);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_EAL_LibCtxFree(libCtx);
CRYPT_EAL_RandDeinit();
#else
NoUsedParam(path, defProName, customProName, defAttr, customAttr);
(void)padMode;
(void)mdId;
(void)n;
(void)e;
(void)d;
(void)plaintext;
SKIP_TEST();
#endif
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/provider/test_suite_sdv_eal_multi_provider.c | C | unknown | 22,400 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include "securec.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "crypt_eal_init.h"
#include "crypt_eal_provider.h"
#include "crypt_provider_local.h"
#include "crypt_eal_implprovider.h"
#include "crypt_provider.h"
#include "crypt_eal_mac.h"
#include "eal_mac_local.h"
#include "crypt_eal_kdf.h"
#include "eal_kdf_local.h"
#include "crypt_eal_md.h"
#include "eal_md_local.h"
#include "crypt_eal_pkey.h"
#include "eal_pkey_local.h"
#include "test.h"
#include "crypt_errno.h"
#include "bsl_sal.h"
#include "bsl_list.h"
#include "bsl_errno.h"
#include "crypt_eal_md.h"
#include "hitls_crypt_type.h"
#include "hitls_cert_type.h"
#include "hitls_type.h"
/* END_HEADER */
#define PROVIDER_LOAD_SAIZE_2 2
#define PATH_EXCEED 4097
#define NEW_PARA_ALGID (BSL_CID_MAX + 1)
#define NEW_PKEY_ALGID (BSL_CID_MAX + 2)
#define NEW_SIGN_HASH_ALGID (BSL_CID_MAX + 3)
#define NEW_HASH_ALGID (BSL_CID_MAX + 4)
/**
* @test SDV_CRYPTO_PROVIDER_LOAD_FUNC_TC001
* @title Provider load and unload functionality test
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PROVIDER_LOAD_TC001(char *path, char *path2, char *test1, char *test2, char *testNoInit,
char *testNoFullfunc, int cmd, int cmd2)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)path;
(void)path2;
(void)test1;
(void)test2;
(void)testNoInit;
(void)testNoFullfunc;
(void)cmd;
(void)cmd2;
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
// Test CRYPT_EAL_LibCtxNew
libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
// Test CRYPT_EAL_ProviderSetLoadPath
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, path), CRYPT_SUCCESS);
// Test CRYPT_EAL_ProviderLoad
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, test1, NULL, NULL), CRYPT_SUCCESS);
// Test CRYPT_EAL_ProviderLoad
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, BSL_SAL_LIB_FMT_OFF, "default", NULL, NULL), CRYPT_SUCCESS);
// Test CRYPT_EAL_ProviderLoad
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, BSL_SAL_LIB_FMT_OFF, "default", NULL, NULL), CRYPT_SUCCESS);
// Test loading the same provider consecutively
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, test1, NULL, NULL), CRYPT_SUCCESS);
// Verify only one EAL_ProviderMgrCtx structure for this provider in the providers list,and ref == 2
ASSERT_EQ(BSL_LIST_COUNT(libCtx->providers), 2);
CRYPT_EAL_ProvMgrCtx *providerMgr = (CRYPT_EAL_ProvMgrCtx *)BSL_LIST_FIRST_ELMT(libCtx->providers);
ASSERT_TRUE(providerMgr != NULL);
ASSERT_EQ(providerMgr->ref.count, PROVIDER_LOAD_SAIZE_2);
providerMgr = (CRYPT_EAL_ProvMgrCtx *)BSL_LIST_LAST_ELMT(libCtx->providers);
ASSERT_TRUE(providerMgr != NULL);
ASSERT_EQ(providerMgr->ref.count, PROVIDER_LOAD_SAIZE_2);
// Test if loading the same name with different cmd is successful and not recognized as the same provider
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd2, test1, NULL, NULL), CRYPT_SUCCESS);
ASSERT_EQ(providerMgr->ref.count, PROVIDER_LOAD_SAIZE_2);
// Test if loading the same provider name with the same cmd from different paths is successful
// and will recognized as the same provider。
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, path2), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, test1, NULL, NULL), CRYPT_SUCCESS);
providerMgr = (CRYPT_EAL_ProvMgrCtx *)BSL_LIST_FIRST_ELMT(libCtx->providers);
ASSERT_TRUE(providerMgr != NULL);
ASSERT_EQ(providerMgr->ref.count, PROVIDER_LOAD_SAIZE_2 + 1);
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, path), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, test2, NULL, NULL), CRYPT_SUCCESS);
// Test loading a non-existent provider
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, "non_existent_provider", NULL, NULL), BSL_SAL_ERR_DL_NOT_FOUND);
// Test loading a provider without initialization function
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, testNoInit, NULL, NULL), BSL_SAL_ERR_DL_NON_FUNCTION);
// Test loading a provider without complete return methods
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, testNoFullfunc, NULL, NULL), CRYPT_PROVIDER_ERR_UNEXPECTED_IMPL);
ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, cmd, test2), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, test2, NULL, NULL), CRYPT_SUCCESS);
// Test CRYPT_EAL_ProviderUnload
ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, cmd, test1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, cmd, test1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, cmd, test1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, cmd, test2), CRYPT_SUCCESS);
// Test unloading a non-existent provider
ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, cmd, "non_existent_provider"), CRYPT_SUCCESS);
EXIT:
if (libCtx != NULL) {
CRYPT_EAL_LibCtxFree(libCtx);
}
return;
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PROVIDER_LOAD_FUNC_TC002
* @title Test if an error occurs when the length of the set path exceeds
* @precon None
* @brief
* 1. Test if an error is reported when the path length exceeds the maximum length in Linux.
* @expect
* 1. CRYPT_INVALID_ARG
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PROVIDER_LOAD_TC002(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
int32_t ret;
libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
// Test if an error is reported when the path length exceeds the maximum length in Linux
char *overpath = (char *)BSL_SAL_Calloc(1, PATH_EXCEED);
ASSERT_TRUE(overpath != NULL);
ret = memset_s(overpath, PATH_EXCEED, 'a', PATH_EXCEED - 1);
ASSERT_EQ(ret, 0);
ret = CRYPT_EAL_ProviderSetLoadPath(libCtx, overpath);
ASSERT_EQ(ret, CRYPT_INVALID_ARG);
BSL_SAL_Free(overpath);
EXIT:
if (libCtx != NULL) {
CRYPT_EAL_LibCtxFree(libCtx);
}
return;
#endif
}
/* END_CASE */
#define RIGHT_RESULT 1415926
/**
* @test SDV_CRYPTO_PROVIDER_LOAD_TC003
* @title Test load provider into global libctx
* @precon None
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PROVIDER_LOAD_TC003(char *path, int cmd, char *test1, char *attrName)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)path;
(void)cmd;
(void)test1;
(void)attrName;
SKIP_TEST();
#else
CRYPT_EAL_MdCTX *mdCtx = NULL;
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(NULL, path), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(NULL, cmd, test1, NULL, NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderUnload(NULL, cmd, test1), CRYPT_SUCCESS);
CRYPT_EAL_Cleanup(1);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(NULL, cmd, test1, NULL, NULL), CRYPT_PROVIDER_INVALID_LIB_CTX);
ASSERT_EQ(CRYPT_EAL_Init(CRYPT_EAL_INIT_CPU|CRYPT_EAL_INIT_PROVIDER|CRYPT_EAL_INIT_PROVIDER_RAND), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(NULL, path), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(NULL, cmd, test1, NULL, NULL), CRYPT_SUCCESS);
mdCtx = CRYPT_EAL_ProviderMdNewCtx(NULL, CRYPT_MD_MD5, NULL);
ASSERT_TRUE(mdCtx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(mdCtx), CRYPT_SUCCESS);
CRYPT_EAL_MdFreeCtx(mdCtx);
mdCtx = CRYPT_EAL_ProviderMdNewCtx(NULL, CRYPT_MD_MD5, attrName);
ASSERT_TRUE(mdCtx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(mdCtx), RIGHT_RESULT);
EXIT:
CRYPT_EAL_MdFreeCtx(mdCtx);
CRYPT_EAL_Cleanup(1);
ASSERT_EQ(CRYPT_EAL_Init(CRYPT_EAL_INIT_CPU|CRYPT_EAL_INIT_PROVIDER|CRYPT_EAL_INIT_PROVIDER_RAND), CRYPT_SUCCESS);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PROVIDER_LOAD_COMPARE_TC001
* @title Test the normal scenarios of provider lookup mechanism
* @precon None
* @brief
* 1. Test if the corresponding funcs can be found based on the attribute
* @expect
* 1. CRYPT_SUCCESS for loading providers and getting functions
* 2. The result of mdInitCtx matches the expected result
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PROVIDER_LOAD_COMPARE_TC001(char *path, char *test1, char *test2, int cmd, char *attribute, int result)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)path;
(void)test1;
(void)test2;
(void)cmd;
(void)attribute;
(void)result;
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
int32_t ret;
libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
ret = CRYPT_EAL_ProviderSetLoadPath(libCtx, path);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_ProviderLoad(libCtx, cmd, test1, NULL, NULL);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_ProviderLoad(libCtx, cmd, test2, NULL, NULL);
ASSERT_EQ(ret, CRYPT_SUCCESS);
const CRYPT_EAL_Func *funcs;
void *provCtx;
// Test if the corresponding funcs can be found based on the attribute
ret = CRYPT_EAL_ProviderGetFuncs(libCtx, CRYPT_EAL_OPERAID_HASH, CRYPT_MD_MD5, attribute, &funcs, &provCtx);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_TRUE(funcs != NULL);
CRYPT_EAL_ImplMdInitCtx mdInitCtx = (CRYPT_EAL_ImplMdInitCtx)(funcs[1].func);
ASSERT_TRUE(mdInitCtx != NULL);
ret = mdInitCtx(provCtx, NULL);
ASSERT_EQ(ret, result);
ret = CRYPT_EAL_ProviderUnload(libCtx, cmd, test1);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_ProviderUnload(libCtx, cmd, test2);
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
if (libCtx != NULL) {
CRYPT_EAL_LibCtxFree(libCtx);
}
return;
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PROVIDER_LOAD_COMPARE_TC002
* @title Test special scenarios of provider lookup mechanism
* @precon None
* @brief
* 1. Test when attribute is NULL
* 2. Test when no provider can meet the attribute requirements
* 3. Test when operaid and operaid are out of range
* @expect
* 1. CRYPT_SUCCESS for loading providers and getting functions
* 2. CRYPT_NOT_SUPPORT when no provider meets the requirements or operaid is out of range
* 3. The result of mdInitCtx matches the expected result
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PROVIDER_LOAD_COMPARE_TC002(char *path, char *test1, char *test2, int cmd, int result)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)path;
(void)test1;
(void)test2;
(void)cmd;
(void)result;
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
int32_t ret;
libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, path), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, test1, NULL, NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, test2, NULL, NULL), CRYPT_SUCCESS);
const CRYPT_EAL_Func *funcs;
void *provCtx;
// Demonstrate normal scenario
ASSERT_EQ(CRYPT_EAL_ProviderGetFuncs(libCtx, CRYPT_EAL_OPERAID_HASH, CRYPT_MD_MD5, "provider=test1",
&funcs, &provCtx), CRYPT_SUCCESS);
CRYPT_EAL_ImplMdInitCtx mdInitCtx = (CRYPT_EAL_ImplMdInitCtx)(funcs[1].func);
ASSERT_EQ(mdInitCtx(provCtx, NULL), RIGHT_RESULT);
ASSERT_EQ(CRYPT_EAL_ProviderGetFuncs(libCtx, CRYPT_EAL_OPERAID_HASH, CRYPT_MD_MD5,
"provider=test1,provider!=test2", &funcs, &provCtx), CRYPT_SUCCESS);
mdInitCtx = (CRYPT_EAL_ImplMdInitCtx)(funcs[1].func);
ASSERT_EQ(mdInitCtx(provCtx, NULL), RIGHT_RESULT);
// Test 1: Test when attribute is NULL
ASSERT_EQ(CRYPT_EAL_ProviderGetFuncs(libCtx, CRYPT_EAL_OPERAID_HASH, CRYPT_MD_MD5, NULL, &funcs, &provCtx),
CRYPT_SUCCESS);
mdInitCtx = (CRYPT_EAL_ImplMdInitCtx)(funcs[1].func);
ASSERT_EQ(mdInitCtx(provCtx, NULL), result);
funcs = provCtx = NULL;
// Test 2: Test when no provider can meet the attribute requirements
ret = CRYPT_EAL_ProviderGetFuncs(libCtx, CRYPT_EAL_OPERAID_HASH, CRYPT_MD_MD5, "n_atr=test3", &funcs, &provCtx);
ASSERT_EQ(ret, CRYPT_NOT_SUPPORT);
// Test 3: Test when both operaid and operaid are out of range
ret = CRYPT_EAL_ProviderGetFuncs(libCtx, 0, CRYPT_MD_MD5, "provider=test1", &funcs, &provCtx);
ASSERT_EQ(ret, CRYPT_NOT_SUPPORT);
ret = CRYPT_EAL_ProviderGetFuncs(libCtx, CRYPT_EAL_OPERAID_HASH, 0, "provider=test1", &funcs, &provCtx);
ASSERT_EQ(ret, CRYPT_NOT_SUPPORT);
// Test 4: Test when attribute format is non-standard
ret = CRYPT_EAL_ProviderGetFuncs(libCtx, CRYPT_EAL_OPERAID_HASH, CRYPT_MD_MD5, "provider", &funcs, &provCtx);
ASSERT_EQ(ret, CRYPT_PROVIDER_ERR_ATTRIBUTE);
ret = CRYPT_EAL_ProviderGetFuncs(libCtx, CRYPT_EAL_OPERAID_HASH, CRYPT_MD_MD5, "provider=test1provider!=test2",
&funcs, &provCtx);
ASSERT_EQ(ret, CRYPT_NOT_SUPPORT);
ret = CRYPT_EAL_ProviderGetFuncs(libCtx, CRYPT_EAL_OPERAID_HASH, CRYPT_MD_MD5, "provider!test2",
&funcs, &provCtx);
ASSERT_EQ(ret, CRYPT_PROVIDER_ERR_ATTRIBUTE);
ret = CRYPT_EAL_ProviderGetFuncs(libCtx, CRYPT_EAL_OPERAID_HASH, CRYPT_MD_MD5, "!=tesst2", &funcs, &provCtx);
ASSERT_EQ(ret, CRYPT_PROVIDER_ERR_ATTRIBUTE);
EXIT:
if (libCtx != NULL) {
CRYPT_EAL_LibCtxFree(libCtx);
}
return;
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PROVIDER_LOAD_UNINSTALL_TC001
* @title Test whether the external interface of each algorithm reports an error
* when using the provider method provided by a third party that does not contain newctx
* @precon None
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PROVIDER_LOAD_UNINSTALL_TC001(char *path, char *providerNoInit, int cmd)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)path;
(void)providerNoInit;
(void)cmd;
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, path), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, providerNoInit, NULL, NULL), CRYPT_SUCCESS);
CRYPT_EAL_KdfCTX *kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_SCRYPT, NULL);
ASSERT_TRUE(kdfCtx == NULL);
CRYPT_EAL_MacCtx *macCtx = CRYPT_EAL_ProviderMacNewCtx(libCtx, CRYPT_MAC_HMAC_MD5, NULL);
ASSERT_TRUE(macCtx == NULL);
CRYPT_EAL_MdCTX *mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_MD5, NULL);
ASSERT_TRUE(mdCtx == NULL);
CRYPT_EAL_PkeyCtx *pkeyCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_DSA, 0, NULL);
ASSERT_TRUE(pkeyCtx == NULL);
EXIT:
CRYPT_EAL_LibCtxFree(libCtx);
return;
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PROVIDER_LOAD_UNINSTALL_TC002
* @title Test whether the external interfaces of each algorithm run normally
* when using the provider method provided by a third party without freectx
* @precon None
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PROVIDER_LOAD_UNINSTALL_TC002(char *path, char *providerNoFree, int cmd)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)path;
(void)providerNoFree;
(void)cmd;
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, path), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, providerNoFree, NULL, NULL), CRYPT_SUCCESS);
CRYPT_EAL_KdfCTX *kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_SCRYPT, NULL);
ASSERT_TRUE(kdfCtx != NULL);
void *tempData = kdfCtx->data;
CRYPT_EAL_KdfFreeCtx(kdfCtx);
BSL_SAL_FREE(tempData);
CRYPT_EAL_MacCtx *macCtx = CRYPT_EAL_ProviderMacNewCtx(libCtx, CRYPT_MAC_HMAC_MD5, NULL);
ASSERT_TRUE(macCtx != NULL);
tempData = macCtx->ctx;
CRYPT_EAL_MacFreeCtx(macCtx);
BSL_SAL_FREE(tempData);
CRYPT_EAL_MdCTX *mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_MD5, NULL);
ASSERT_TRUE(mdCtx != NULL);
tempData = mdCtx->data;
CRYPT_EAL_MdFreeCtx(mdCtx);
BSL_SAL_FREE(tempData);
CRYPT_EAL_PkeyCtx *pkeyCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_DSA, 0, NULL);
ASSERT_TRUE(pkeyCtx != NULL);
tempData = pkeyCtx->key;
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
BSL_SAL_FREE(tempData);
EXIT:
CRYPT_EAL_LibCtxFree(libCtx);
return;
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PROVIDER_LOAD_DEFAULT_TC001
* Load two providers, one of which is the default provider,
* query the algorithm from the default provider, and calculate the result
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PROVIDER_LOAD_DEFAULT_TC001(char *path, char *test1, int cmd, Hex *msg, Hex *hash)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)path;
(void)test1;
(void)cmd;
(void)msg;
(void)hash;
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_MdCTX *ctx = NULL;
int32_t ret;
// Test CRYPT_EAL_LibCtxNew
libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
// Test CRYPT_EAL_ProviderSetLoadPath
ret = CRYPT_EAL_ProviderSetLoadPath(libCtx, path);
ASSERT_EQ(ret, CRYPT_SUCCESS);
// Test CRYPT_EAL_ProviderLoad
ret = CRYPT_EAL_ProviderLoad(libCtx, cmd, test1, NULL, NULL);
ASSERT_EQ(ret, CRYPT_SUCCESS);
// Test CRYPT_EAL_ProviderLoad
ret = CRYPT_EAL_ProviderLoad(libCtx, BSL_SAL_LIB_FMT_OFF, "default", NULL, NULL);
ASSERT_EQ(ret, CRYPT_SUCCESS);
// Test CRYPT_EAL_ProviderLoad
ret = CRYPT_EAL_ProviderLoad(libCtx, BSL_SAL_LIB_FMT_OFF, "default", NULL, NULL);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ctx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_SHA224, "provider=default");
ASSERT_TRUE(ctx != NULL);
uint8_t output[32];
uint32_t outLen = sizeof(output);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, msg->x, msg->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
EXIT:
CRYPT_EAL_LibCtxFree(libCtx);
CRYPT_EAL_MdFreeCtx(ctx);
return;
#endif
}
/* END_CASE */
#ifdef HITLS_CRYPTO_PROVIDER
static int32_t GroupCapsCallback(BSL_Param *param, void *args)
{
int *count = (int *)args;
(*count)++;
BSL_Param *groupNameParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_GROUP_IANA_GROUP_NAME);
ASSERT_TRUE(groupNameParam != NULL);
ASSERT_EQ(groupNameParam->valueType, BSL_PARAM_TYPE_OCTETS_PTR);
ASSERT_TRUE(groupNameParam->value != NULL);
BSL_Param *groupIdParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_GROUP_IANA_GROUP_ID);
ASSERT_TRUE(groupIdParam != NULL);
ASSERT_EQ(groupIdParam->valueType, BSL_PARAM_TYPE_UINT16);
ASSERT_TRUE(groupIdParam->value != NULL);
ASSERT_TRUE(groupIdParam->valueLen == sizeof(uint16_t));
groupIdParam->useLen = sizeof(uint16_t);
BSL_Param *paraIdParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_GROUP_PARA_ID);
ASSERT_TRUE(paraIdParam != NULL);
ASSERT_EQ(paraIdParam->valueType, BSL_PARAM_TYPE_INT32);
ASSERT_TRUE(paraIdParam->value != NULL);
ASSERT_TRUE(paraIdParam->valueLen == sizeof(int32_t));
paraIdParam->useLen = sizeof(int32_t);
BSL_Param *algIdParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_GROUP_ALG_ID);
ASSERT_TRUE(algIdParam != NULL);
ASSERT_EQ(algIdParam->valueType, BSL_PARAM_TYPE_INT32);
ASSERT_TRUE(algIdParam->value != NULL);
ASSERT_TRUE(algIdParam->valueLen == sizeof(int32_t));
algIdParam->useLen = sizeof(int32_t);
BSL_Param *secBitsParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_GROUP_SEC_BITS);
ASSERT_TRUE(secBitsParam != NULL);
ASSERT_EQ(secBitsParam->valueType, BSL_PARAM_TYPE_INT32);
ASSERT_TRUE(secBitsParam->value != NULL);
ASSERT_TRUE(secBitsParam->valueLen == sizeof(int32_t));
secBitsParam->useLen = sizeof(int32_t);
BSL_Param *versionBitsParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_GROUP_VERSION_BITS);
ASSERT_TRUE(versionBitsParam != NULL);
ASSERT_EQ(versionBitsParam->valueType, BSL_PARAM_TYPE_UINT32);
ASSERT_TRUE(versionBitsParam->value != NULL);
ASSERT_TRUE(versionBitsParam->valueLen == sizeof(uint32_t));
versionBitsParam->useLen = sizeof(uint32_t);
BSL_Param *isKemParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_GROUP_IS_KEM);
ASSERT_TRUE(isKemParam != NULL);
ASSERT_EQ(isKemParam->valueType, BSL_PARAM_TYPE_BOOL);
ASSERT_TRUE(isKemParam->valueLen == sizeof(bool));
isKemParam->useLen = sizeof(bool);
if (groupNameParam->value != NULL && strcmp((char *)groupNameParam->value, "secp256r1") == 0) {
ASSERT_EQ(*((uint16_t *)groupIdParam->value), HITLS_EC_GROUP_SECP256R1);
ASSERT_EQ(*((int32_t *)paraIdParam->value), CRYPT_ECC_NISTP256);
ASSERT_EQ(*((int32_t *)algIdParam->value), CRYPT_PKEY_ECDH);
ASSERT_EQ(*((int32_t *)secBitsParam->value), 128);
ASSERT_EQ(*((uint32_t *)versionBitsParam->value), (TLS_VERSION_MASK | DTLS_VERSION_MASK));
ASSERT_EQ(*((bool *)isKemParam->value), false);
} else if (groupNameParam->value != NULL && strcmp((char *)groupNameParam->value, "test_new_group") == 0) {
// Verify the custom group parameters from provider_get_cap_test1
ASSERT_EQ(*((uint16_t *)groupIdParam->value), 477);
ASSERT_EQ(*((int32_t *)paraIdParam->value), NEW_PARA_ALGID);
ASSERT_EQ(*((int32_t *)algIdParam->value), NEW_PKEY_ALGID);
ASSERT_EQ(*((int32_t *)secBitsParam->value), 1024);
ASSERT_EQ(*((uint32_t *)versionBitsParam->value), (TLS12_VERSION_BIT | TLS13_VERSION_BIT));
ASSERT_EQ(*((bool *)isKemParam->value), false);
}
return CRYPT_SUCCESS;
EXIT:
return CRYPT_NOT_SUPPORT;
}
static int32_t SigAlgCapsCallback(BSL_Param *param, void *args)
{
int *count = (int *)args;
(*count)++;
// 验证必要参数存在
BSL_Param *sigNameParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_SIGNALG_IANA_SIGN_NAME);
ASSERT_TRUE(sigNameParam != NULL);
ASSERT_EQ(sigNameParam->valueType, BSL_PARAM_TYPE_OCTETS_PTR);
BSL_Param *sigIanaIdParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_SIGNALG_IANA_SIGN_ID);
ASSERT_TRUE(sigIanaIdParam != NULL);
ASSERT_EQ(sigIanaIdParam->valueType, BSL_PARAM_TYPE_UINT16);
ASSERT_TRUE(sigIanaIdParam->valueLen == sizeof(uint16_t));
sigIanaIdParam->useLen = sizeof(uint16_t);
BSL_Param *keyTypeParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_SIGNALG_KEY_TYPE);
ASSERT_TRUE(keyTypeParam != NULL);
ASSERT_EQ(keyTypeParam->valueType, BSL_PARAM_TYPE_INT32);
ASSERT_TRUE(keyTypeParam->valueLen == sizeof(int32_t));
keyTypeParam->useLen = sizeof(int32_t);
BSL_Param *paraIdParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_SIGNALG_PARA_ID);
ASSERT_TRUE(paraIdParam != NULL);
ASSERT_EQ(paraIdParam->valueType, BSL_PARAM_TYPE_INT32);
ASSERT_TRUE(paraIdParam->valueLen == sizeof(int32_t));
paraIdParam->useLen = sizeof(int32_t);
BSL_Param *signHashAlgIdParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_SIGNALG_SIGNWITHMD_ID);
ASSERT_TRUE(signHashAlgIdParam != NULL);
ASSERT_EQ(signHashAlgIdParam->valueType, BSL_PARAM_TYPE_INT32);
ASSERT_TRUE(signHashAlgIdParam->valueLen == sizeof(int32_t));
signHashAlgIdParam->useLen = sizeof(int32_t);
BSL_Param *signHashAlgOidParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_SIGNALG_SIGNWITHMD_OID);
BSL_Param *signHashAlgNameParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_SIGNALG_SIGNWITHMD_NAME);
BSL_Param *signAlgIdParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_SIGNALG_SIGN_ID);
ASSERT_TRUE(signAlgIdParam != NULL);
ASSERT_EQ(signAlgIdParam->valueType, BSL_PARAM_TYPE_INT32);
ASSERT_TRUE(signAlgIdParam->valueLen == sizeof(int32_t));
signAlgIdParam->useLen = sizeof(int32_t);
BSL_Param *hashAlgIdParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_SIGNALG_MD_ID);
ASSERT_TRUE(hashAlgIdParam != NULL);
ASSERT_EQ(hashAlgIdParam->valueType, BSL_PARAM_TYPE_INT32);
ASSERT_TRUE(hashAlgIdParam->valueLen == sizeof(int32_t));
hashAlgIdParam->useLen = sizeof(int32_t);
BSL_Param *hashAlgOidParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_SIGNALG_MD_OID);
BSL_Param *hashAlgNameParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_SIGNALG_MD_NAME);
BSL_Param *secBitsParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_SIGNALG_SEC_BITS);
ASSERT_TRUE(secBitsParam != NULL);
ASSERT_EQ(secBitsParam->valueType, BSL_PARAM_TYPE_INT32);
ASSERT_TRUE(secBitsParam->valueLen == sizeof(int32_t));
secBitsParam->useLen = sizeof(int32_t);
BSL_Param *certVersionParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_SIGNALG_CERT_VERSION_BITS);
ASSERT_TRUE(certVersionParam != NULL);
ASSERT_EQ(certVersionParam->valueType, BSL_PARAM_TYPE_UINT32);
ASSERT_TRUE(certVersionParam->valueLen == sizeof(uint32_t));
certVersionParam->useLen = sizeof(uint32_t);
BSL_Param *chainVersionParam = BSL_PARAM_FindParam(param, CRYPT_PARAM_CAP_TLS_SIGNALG_CHAIN_VERSION_BITS);
ASSERT_TRUE(chainVersionParam != NULL);
ASSERT_EQ(chainVersionParam->valueType, BSL_PARAM_TYPE_UINT32);
ASSERT_TRUE(chainVersionParam->valueLen == sizeof(uint32_t));
chainVersionParam->useLen = sizeof(uint32_t);
if (sigNameParam->value != NULL && strcmp((char *)sigNameParam->value, "ecdsa_secp256r1_sha256") == 0) {
ASSERT_EQ(*((uint16_t *)sigIanaIdParam->value), CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256);
ASSERT_EQ(*((int32_t *)keyTypeParam->value), TLS_CERT_KEY_TYPE_ECDSA);
ASSERT_EQ(*((int32_t *)paraIdParam->value), CRYPT_ECC_NISTP256);
ASSERT_EQ(*((int32_t *)signHashAlgIdParam->value), BSL_CID_ECDSAWITHSHA256);
ASSERT_EQ(*((int32_t *)signAlgIdParam->value), CRYPT_PKEY_ECDSA);
ASSERT_EQ(*((int32_t *)hashAlgIdParam->value), HITLS_HASH_SHA_256);
ASSERT_EQ(*((int32_t *)secBitsParam->value), 128);
ASSERT_EQ(*((uint32_t *)certVersionParam->value), (TLS_VERSION_MASK | DTLS_VERSION_MASK));
ASSERT_EQ(*((uint32_t *)chainVersionParam->value), (TLS_VERSION_MASK | DTLS_VERSION_MASK));
} else if (sigNameParam->value != NULL && strcmp((char *)sigNameParam->value, "test_new_sign_alg_name") == 0) {
ASSERT_EQ(*((uint16_t *)sigIanaIdParam->value), 23333);
ASSERT_EQ(*((int32_t *)keyTypeParam->value), CRYPT_PKEY_ECDSA);
ASSERT_EQ(*((int32_t *)paraIdParam->value), BSL_CID_SECP384R1);
if (signHashAlgOidParam != NULL) {
char *signHashAlgOid = (char *)signHashAlgOidParam->value;
ASSERT_EQ(strcmp(signHashAlgOid, "\150\40\66\77\55"), 0);
}
if (signHashAlgNameParam != NULL) {
char *signHashAlgName = (char *)signHashAlgNameParam->value;
ASSERT_EQ(strcmp(signHashAlgName, "test_new_sign_with_md_name"), 0);
}
ASSERT_EQ(*((int32_t *)signHashAlgIdParam->value), NEW_SIGN_HASH_ALGID);
ASSERT_EQ(*((int32_t *)signAlgIdParam->value), CRYPT_PKEY_ECDSA);
ASSERT_EQ(*((int32_t *)hashAlgIdParam->value), NEW_HASH_ALGID);
if (hashAlgOidParam != NULL) {
char *hashAlgOid = (char *)hashAlgOidParam->value;
ASSERT_EQ(strcmp(hashAlgOid, "\150\40\66\71\55"), 0);
}
if (hashAlgNameParam != NULL) {
char *hashAlgName = (char *)hashAlgNameParam->value;
ASSERT_EQ(strcmp(hashAlgName, "test_new_md_name"), 0);
}
ASSERT_EQ(*((int32_t *)secBitsParam->value), 1024);
ASSERT_EQ(*((uint32_t *)certVersionParam->value), (TLS12_VERSION_BIT | TLS13_VERSION_BIT));
ASSERT_EQ(*((uint32_t *)chainVersionParam->value), (TLS12_VERSION_BIT | TLS13_VERSION_BIT));
}
return CRYPT_SUCCESS;
EXIT:
return CRYPT_NOT_SUPPORT;
}
#endif
/**
* @test SDV_CRYPTO_PROVIDER_GET_CAPS_TC002
* @title Test CRYPT_EAL_ProviderGetCaps for default provider capabilities
* @precon None
* @brief
* 1. Test getting group capabilities (curves)
* 2. Test getting signature algorithm capabilities
* @expect
* 1. Successfully get and verify group parameters
* 2. Successfully get and verify signature algorithm parameters
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PROVIDER_GET_CAPS_TC001(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_ProvMgrCtx *providerMgr = NULL;
CRYPT_EAL_ProvMgrCtx provMgrWithGetCapCb = {0};
int groupCount = 0;
int sigAlgCount = 0;
libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
// Load default provider
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, BSL_SAL_LIB_FMT_OFF, "default", NULL, &providerMgr), 0);
ASSERT_TRUE(providerMgr != NULL);
// Test getting group capabilities
ASSERT_EQ(CRYPT_EAL_ProviderGetCaps(providerMgr, CRYPT_EAL_GET_GROUP_CAP, (CRYPT_EAL_ProcessFuncCb)GroupCapsCallback,
&groupCount), CRYPT_SUCCESS);
ASSERT_EQ(groupCount, 16);
// Test getting signature algorithm capabilities
ASSERT_EQ(CRYPT_EAL_ProviderGetCaps(providerMgr, CRYPT_EAL_GET_SIGALG_CAP, (CRYPT_EAL_ProcessFuncCb)SigAlgCapsCallback,
&sigAlgCount), CRYPT_SUCCESS);
ASSERT_EQ(sigAlgCount, 23);
// Test invalid mgrCtx
ASSERT_EQ(CRYPT_EAL_ProviderGetCaps(NULL, CRYPT_EAL_GET_GROUP_CAP, (CRYPT_EAL_ProcessFuncCb)GroupCapsCallback,
&groupCount), CRYPT_NULL_INPUT);
// Test invalid CRYPT_EAL_ProcessFuncCb
ASSERT_EQ(CRYPT_EAL_ProviderGetCaps(providerMgr, CRYPT_EAL_GET_GROUP_CAP, NULL, &groupCount), CRYPT_NULL_INPUT);
// Test invalid mgrCtx
provMgrWithGetCapCb.provCtx = NULL;
provMgrWithGetCapCb.provGetCap = NULL;
ASSERT_EQ(CRYPT_EAL_ProviderGetCaps(&provMgrWithGetCapCb, CRYPT_EAL_GET_GROUP_CAP,
(CRYPT_EAL_ProcessFuncCb)GroupCapsCallback, &groupCount), CRYPT_SUCCESS);
// Test invalid command
ASSERT_EQ(CRYPT_EAL_ProviderGetCaps(providerMgr, -1, (CRYPT_EAL_ProcessFuncCb)GroupCapsCallback, &groupCount),
CRYPT_NOT_SUPPORT);
// Cleanup
ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, BSL_SAL_LIB_FMT_OFF, "default"), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_LibCtxFree(libCtx);
return;
#endif
}
/* END_CASE */
#ifdef HITLS_CRYPTO_PROVIDER
static int32_t CountProvidersCallback(CRYPT_EAL_ProvMgrCtx *provMgr, void *args)
{
(void)provMgr;
int *count = (int *)args;
if (count != NULL) {
(*count)++;
}
return CRYPT_SUCCESS;
}
// Callback function that returns an error
static int32_t ErrorCallback(CRYPT_EAL_ProvMgrCtx *provMgr, void *args)
{
(void)provMgr;
int *count = (int *)args;
if (count != NULL) {
(*count)++;
}
return CRYPT_NOT_SUPPORT;
}
#endif
/**
* @test SDV_CRYPTO_PROVIDER_PROC_ALL_TC001
* @title Test CRYPT_EAL_ProviderProcessAll functionality
* @precon None
* @brief
* 1. Test processing all loaded providers with a callback function
* 2. Test error handling for NULL inputs
* 3. Test error propagation from callback function
* @expect
* 1. Successfully process all providers
* 2. Return CRYPT_NULL_INPUT for NULL inputs
* 3. Properly propagate errors from callback function
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PROVIDER_PROC_ALL_TC001(char *path, char *test1, char *test2, int cmd)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)path;
(void)test1;
(void)test2;
(void)cmd;
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
int providerCount = 0;
int errorProviderCount = 0;
// Initialize library context
libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
// Set provider path
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, path), CRYPT_SUCCESS);
// Load multiple providers
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, test1, NULL, NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, test2, NULL, NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, BSL_SAL_LIB_FMT_OFF, "default", NULL, NULL), CRYPT_SUCCESS);
// Test 1: Process all providers with a counting callback
ASSERT_EQ(CRYPT_EAL_ProviderProcessAll(libCtx, CountProvidersCallback, &providerCount), CRYPT_SUCCESS);
ASSERT_EQ(providerCount, 3); // Should have processed 3 providers
// Test 2: Test NULL libCtx
providerCount = 0;
ASSERT_EQ(CRYPT_EAL_ProviderProcessAll(NULL, CountProvidersCallback, &providerCount), CRYPT_SUCCESS);
ASSERT_EQ(providerCount, 1);
// Test 3: Test NULL inputs
ASSERT_EQ(CRYPT_EAL_ProviderProcessAll(libCtx, NULL, &providerCount), CRYPT_NULL_INPUT);
// Test 4: Test error propagation from callback
ASSERT_EQ(CRYPT_EAL_ProviderProcessAll(libCtx, ErrorCallback, &errorProviderCount), CRYPT_NOT_SUPPORT);
ASSERT_EQ(errorProviderCount, 1); // Should have processed only the first provider before error
// Cleanup
ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, cmd, test1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, cmd, test2), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, BSL_SAL_LIB_FMT_OFF, "default"), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_LibCtxFree(libCtx);
return;
#endif
}
/* END_CASE */
#ifdef HITLS_CRYPTO_PROVIDER
typedef struct {
int totalProviders;
int providersWithMd5;
int providersWithSha256;
} ProviderStats;
int32_t CheckAlgorithmsCallback(CRYPT_EAL_ProvMgrCtx *provMgr, void *args)
{
ProviderStats *stats = (ProviderStats *)args;
if (stats != NULL) {
stats->totalProviders++;
const CRYPT_EAL_Func *funcs;
void *provCtx;
int32_t ret = CRYPT_EAL_ProviderGetFuncs(provMgr->libCtx, CRYPT_EAL_OPERAID_HASH,
CRYPT_MD_MD5, NULL, &funcs, &provCtx);
if (ret == CRYPT_SUCCESS && funcs != NULL) {
stats->providersWithMd5++;
}
ret = CRYPT_EAL_ProviderGetFuncs(provMgr->libCtx, CRYPT_EAL_OPERAID_HASH,
CRYPT_MD_SHA256, NULL, &funcs, &provCtx);
if (ret == CRYPT_SUCCESS && funcs != NULL) {
stats->providersWithSha256++;
}
}
return CRYPT_SUCCESS;
}
#endif
/**
* @test SDV_CRYPTO_PROVIDER_PROC_ALL_TC002
* @title Test CRYPT_EAL_ProviderProcessAll with specific provider operations
* @precon None
* @brief
* 1. Test processing all providers to collect specific information
* 2. Test processing all providers to perform specific operations
* @expect
* 1. Successfully collect information from all providers
* 2. Successfully perform operations on all providers
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PROVIDER_PROC_ALL_TC002(char *path, char *test1, char *test2, int cmd)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)path;
(void)test1;
(void)test2;
(void)cmd;
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
ProviderStats stats = {0};
// Initialize library context
libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
// Set provider path
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, path), CRYPT_SUCCESS);
// Load multiple providers
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, test1, NULL, NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, test2, NULL, NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, BSL_SAL_LIB_FMT_OFF, "default", NULL, NULL), CRYPT_SUCCESS);
// Process all providers to collect algorithm information
ASSERT_EQ(CRYPT_EAL_ProviderProcessAll(libCtx, CheckAlgorithmsCallback, &stats), CRYPT_SUCCESS);
// Verify results
ASSERT_EQ(stats.totalProviders, 3);
ASSERT_TRUE(stats.providersWithMd5 > 0); // At least one provider should support MD5
ASSERT_TRUE(stats.providersWithSha256 > 0); // At least one provider should support SHA256
// Test with empty provider list
CRYPT_EAL_LibCtx *emptyLibCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(emptyLibCtx != NULL);
ProviderStats emptyStats = {0};
ASSERT_EQ(CRYPT_EAL_ProviderProcessAll(emptyLibCtx, CheckAlgorithmsCallback, &emptyStats), CRYPT_SUCCESS);
ASSERT_EQ(emptyStats.totalProviders, 0); // No providers should be processed
// Cleanup
ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, cmd, test1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, cmd, test2), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderUnload(libCtx, BSL_SAL_LIB_FMT_OFF, "default"), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_LibCtxFree(libCtx);
CRYPT_EAL_LibCtxFree(emptyLibCtx);
return;
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PROVIDER_GET_CAP_TEST_TC001
* @title Test provider_get_cap_test1 provider functionality
* @precon None
* @brief
* 1. Load provider_get_cap_test1 provider
* 2. Test key generation, shared key computation, signing and verification
* @expect
* 1. Successfully load the provider
* 2. Successfully perform cryptographic operations
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PROVIDER_GET_CAP_TEST_TC001(char *path, char *get_cap_test1, int cmd)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)path;
(void)get_cap_test1;
(void)cmd;
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_ProvMgrCtx *providerMgr = NULL;
CRYPT_EAL_PkeyCtx *keyCtx1 = NULL;
CRYPT_EAL_PkeyCtx *keyCtx2 = NULL;
uint8_t sharedKey1[256] = {0};
uint32_t sharedKeyLen1 = sizeof(sharedKey1);
uint8_t sharedKey2[256] = {0};
uint32_t sharedKeyLen2 = sizeof(sharedKey2);
// Initialize library context
libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, path), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, get_cap_test1, NULL, &providerMgr), CRYPT_SUCCESS);
ASSERT_TRUE(providerMgr != NULL);
int groupCount = 0;
int sigAlgCount = 0;
ASSERT_EQ(CRYPT_EAL_ProviderGetCaps(providerMgr, CRYPT_EAL_GET_GROUP_CAP,
(CRYPT_EAL_ProcessFuncCb)GroupCapsCallback, &groupCount), CRYPT_SUCCESS);
ASSERT_EQ(groupCount, 2);
ASSERT_EQ(CRYPT_EAL_ProviderGetCaps(providerMgr, CRYPT_EAL_GET_SIGALG_CAP,
(CRYPT_EAL_ProcessFuncCb)SigAlgCapsCallback, &sigAlgCount), CRYPT_SUCCESS);
ASSERT_EQ(sigAlgCount, 1);
keyCtx1 = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, NEW_PKEY_ALGID, CRYPT_EAL_PKEY_UNKNOWN_OPERATE,
"provider=provider_get_cap_test1");
ASSERT_TRUE(keyCtx1 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(keyCtx1, NEW_PARA_ALGID), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(keyCtx1), CRYPT_SUCCESS);
keyCtx2 = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, NEW_PKEY_ALGID, CRYPT_EAL_PKEY_UNKNOWN_OPERATE,
"provider=provider_get_cap_test1");
ASSERT_TRUE(keyCtx2 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(keyCtx2, NEW_PARA_ALGID), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(keyCtx2), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(keyCtx1, keyCtx2, sharedKey1, &sharedKeyLen1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(keyCtx2, keyCtx1, sharedKey2, &sharedKeyLen2), CRYPT_SUCCESS);
ASSERT_TRUE(sharedKeyLen1 > 0);
ASSERT_TRUE(sharedKeyLen2 > 0);
ASSERT_EQ(memcmp(sharedKey1, sharedKey2, sharedKeyLen1), 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(keyCtx1);
CRYPT_EAL_PkeyFreeCtx(keyCtx2);
CRYPT_EAL_ProviderUnload(libCtx, cmd, get_cap_test1);
CRYPT_EAL_LibCtxFree(libCtx);
return;
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PROVIDER_GET_CAP_TEST_TC002
* @title Test provider_get_cap_test1 provider signature and verification
* @precon None
* @brief
* 1. Load provider_get_cap_test1 provider
* 2. Test signature generation and verification with ECDSA
* @expect
* 1. Successfully load the provider
* 2. Successfully sign and verify data
* 3. Verification fails with modified signature
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PROVIDER_GET_CAP_TEST_TC002(char *path, char *get_cap_test1, int cmd)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)path;
(void)get_cap_test1;
(void)cmd;
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_ProvMgrCtx *providerMgr = NULL;
CRYPT_EAL_PkeyCtx *keyCtx = NULL;
uint8_t signature[128] = {0};
uint32_t signatureLen = sizeof(signature);
uint8_t testData[] = "Test data for signing and verification with ECDSA";
uint32_t testDataLen = sizeof(testData) - 1;
libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, path), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, get_cap_test1, NULL, &providerMgr), CRYPT_SUCCESS);
ASSERT_TRUE(providerMgr != NULL);
keyCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_ECDSA, 0, "provider=provider_get_cap_test1");
ASSERT_TRUE(keyCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(keyCtx, NEW_PARA_ALGID), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(keyCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySign(keyCtx, CRYPT_MD_SHA256, testData, testDataLen, signature, &signatureLen), 0);
ASSERT_TRUE(signatureLen > 0);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(keyCtx, CRYPT_MD_SHA256, testData, testDataLen, signature, signatureLen), CRYPT_SUCCESS);
// Test 4: Modify signature and verify it should fail
signature[10] ^= 0xFF; // Flip bits in the signature
ASSERT_EQ(CRYPT_EAL_PkeyVerify(keyCtx, CRYPT_MD_SHA256, testData, testDataLen, signature, signatureLen),
CRYPT_ECDSA_VERIFY_FAIL);
EXIT:
CRYPT_EAL_PkeyFreeCtx(keyCtx);
CRYPT_EAL_ProviderUnload(libCtx, cmd, get_cap_test1);
CRYPT_EAL_LibCtxFree(libCtx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_PROVIDER_GET_CAP_TEST_TC003(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, 0, "default", NULL, NULL), CRYPT_SUCCESS);
CRYPT_EAL_ProviderUnload(libCtx, 0, "default");
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, 0, "default", NULL, NULL), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_ProviderUnload(libCtx, 0, "default");
CRYPT_EAL_LibCtxFree(libCtx);
#endif
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/provider/test_suite_sdv_eal_provider_load.c | C | unknown | 42,989 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include "securec.h"
#include "crypt_params_key.h"
#include "crypt_errno.h"
#include "crypt_eal_md.h"
#include "crypt_eal_provider.h"
#include "crypt_eal_implprovider.h"
#include "crypt_provider.h"
/* END_HEADER */
#define PROVIDER_A_NAME "provider_a"
#define PROVIDER_B_NAME "provider_b"
#define PROVIDER_DEFAULT_NAME "default"
#define PROVIDER_A_ATTR "provider=a,md=sha256"
#define PROVIDER_B_ATTR "provider=b,md=md5"
#define PROVIDER_DEFAULT_ATTR "provider=default"
#define DEFAULT_SHA256_INIT_RET 0
#define DEFAULT_MD5_INIT_RET 0
#define PROVIDER_A_SHA256_INIT_RET (-1)
#define PROVIDER_B_MD5_INIT_RET (-2)
uint8_t md = 1;
static void *MdNewCtx(void *provCtx, int32_t algId)
{
(void)provCtx;
(void)algId;
return &md;
}
static int32_t MdInitA(void *ctx, BSL_Param *param)
{
(void)ctx;
(void)param;
return PROVIDER_A_SHA256_INIT_RET;
}
static int32_t MdInitB(void *ctx, BSL_Param *param)
{
(void)ctx;
(void)param;
return PROVIDER_B_MD5_INIT_RET;
}
static int32_t MdDeinit(void *ctx)
{
(void)ctx;
return 0;
}
static int32_t MdCopyCtx(void *dst, const void *src)
{
(void)dst;
(void)src;
return 0;
}
static int32_t MdUpdate(void *ctx, const uint8_t *data, uint32_t nbytes)
{
(void)ctx;
(void)data;
(void)nbytes;
return 0;
}
static int32_t MdFinal(void *ctx, uint8_t *digest, uint32_t *outlen)
{
(void)ctx;
(void)digest;
(void)outlen;
return 0;
}
static void *MdDupCtx(const void *src)
{
(void)src;
return NULL;
}
static void MdFreeCtx(void *ctx)
{
(void)ctx;
return;
}
static int32_t MdGetParam(void *ctx, BSL_Param *param)
{
(void)ctx;
(void)param;
return 0;
}
// SHA256 algorithm function table
const CRYPT_EAL_Func providerAMd[] = {
{CRYPT_EAL_IMPLMD_NEWCTX, MdNewCtx},
{CRYPT_EAL_IMPLMD_INITCTX, MdInitA},
{CRYPT_EAL_IMPLMD_UPDATE, MdUpdate},
{CRYPT_EAL_IMPLMD_FINAL, MdFinal},
{CRYPT_EAL_IMPLMD_DEINITCTX, MdDeinit},
{CRYPT_EAL_IMPLMD_DUPCTX, MdDupCtx},
{CRYPT_EAL_IMPLMD_COPYCTX, MdCopyCtx},
{CRYPT_EAL_IMPLMD_GETPARAM, MdGetParam},
{CRYPT_EAL_IMPLMD_FREECTX, MdFreeCtx},
CRYPT_EAL_FUNC_END,
};
// Algorithm information table
static const CRYPT_EAL_AlgInfo providerAMds[] = {
{CRYPT_MD_SHA256, providerAMd, PROVIDER_A_ATTR},
CRYPT_EAL_ALGINFO_END
};
// SHA256 algorithm function table
const CRYPT_EAL_Func providerBMd[] = {
{CRYPT_EAL_IMPLMD_NEWCTX, MdNewCtx},
{CRYPT_EAL_IMPLMD_INITCTX, MdInitB},
{CRYPT_EAL_IMPLMD_UPDATE, MdUpdate},
{CRYPT_EAL_IMPLMD_FINAL, MdFinal},
{CRYPT_EAL_IMPLMD_DEINITCTX, MdDeinit},
{CRYPT_EAL_IMPLMD_DUPCTX, MdDupCtx},
{CRYPT_EAL_IMPLMD_COPYCTX, MdCopyCtx},
{CRYPT_EAL_IMPLMD_GETPARAM, MdGetParam},
{CRYPT_EAL_IMPLMD_FREECTX, MdFreeCtx},
CRYPT_EAL_FUNC_END,
};
// Algorithm information table
static const CRYPT_EAL_AlgInfo providerBMds[] = {
{CRYPT_MD_MD5, providerBMd, PROVIDER_B_ATTR},
CRYPT_EAL_ALGINFO_END
};
static void MdProvFree(void *provCtx)
{
(void)provCtx;
return;
}
static int32_t MdProvQueryA(void *provCtx, int32_t operaId, const CRYPT_EAL_AlgInfo **algInfos)
{
(void)provCtx;
switch (operaId) {
case CRYPT_EAL_OPERAID_HASH:
*algInfos = providerAMds;
return 0;
default:
return 1;
}
}
static int32_t MdProvQueryB(void *provCtx, int32_t operaId, const CRYPT_EAL_AlgInfo **algInfos)
{
(void)provCtx;
switch (operaId) {
case CRYPT_EAL_OPERAID_HASH:
*algInfos = providerBMds;
return 0;
default:
return 1;
}
}
// Provider output functions table
static CRYPT_EAL_Func providerAProvOutFuncs[] = {
{CRYPT_EAL_PROVCB_QUERY, MdProvQueryA},
{CRYPT_EAL_PROVCB_FREE, MdProvFree},
{CRYPT_EAL_PROVCB_CTRL, NULL},
CRYPT_EAL_FUNC_END
};
static CRYPT_EAL_Func providerBProvOutFuncs[] = {
{CRYPT_EAL_PROVCB_QUERY, MdProvQueryB},
{CRYPT_EAL_PROVCB_FREE, MdProvFree},
{CRYPT_EAL_PROVCB_CTRL, NULL},
CRYPT_EAL_FUNC_END
};
// Provider initialization function
int32_t ProviderAInit(CRYPT_EAL_ProvMgrCtx *mgrCtx,
BSL_Param *param, CRYPT_EAL_Func *capFuncs, CRYPT_EAL_Func **outFuncs, void **provCtx)
{
(void)mgrCtx;
(void)param;
(void)capFuncs;
*outFuncs = providerAProvOutFuncs;
*provCtx = NULL;
return 0;
}
int32_t ProviderBInit(CRYPT_EAL_ProvMgrCtx *mgrCtx,
BSL_Param *param, CRYPT_EAL_Func *capFuncs, CRYPT_EAL_Func **outFuncs, void **provCtx)
{
(void)mgrCtx;
(void)param;
(void)capFuncs;
*outFuncs = providerBProvOutFuncs;
*provCtx = NULL;
return 0;
}
/**
* @test SDV_CRYPTO_PROVIDER_REG_FUNC_TC001
* @title Register default provider first and then register custom provider
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PROVIDER_REG_FUNC_TC001(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
CRYPT_EAL_MdCTX *mdCtx = NULL;
TestMemInit();
CRYPT_EAL_LibCtx *libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
// 1st: default provider, 2nd: A provider, 3rd: B provider
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, PROVIDER_DEFAULT_NAME, NULL, NULL, NULL), 0);
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, PROVIDER_A_NAME, ProviderAInit, NULL, NULL), 0);
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, PROVIDER_B_NAME, ProviderBInit, NULL, NULL), 0);
mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_SHA256, "provider=default");
ASSERT_TRUE(mdCtx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(mdCtx), DEFAULT_SHA256_INIT_RET);
CRYPT_EAL_MdFreeCtx(mdCtx);
mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_SHA256, NULL);
ASSERT_TRUE(mdCtx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(mdCtx), DEFAULT_SHA256_INIT_RET);
CRYPT_EAL_MdFreeCtx(mdCtx);
mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_SHA256, "provider=a");
ASSERT_TRUE(mdCtx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(mdCtx), PROVIDER_A_SHA256_INIT_RET);
CRYPT_EAL_MdFreeCtx(mdCtx);
mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_SHA256, "provider=b");
ASSERT_TRUE(mdCtx == NULL);
mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_MD5, "provider=a");
ASSERT_TRUE(mdCtx == NULL);
mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_SHA256, "md=sha256");
ASSERT_TRUE(mdCtx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(mdCtx), PROVIDER_A_SHA256_INIT_RET);
CRYPT_EAL_MdFreeCtx(mdCtx);
mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_MD5, "provider=b");
ASSERT_TRUE(mdCtx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(mdCtx), PROVIDER_B_MD5_INIT_RET);
EXIT:
CRYPT_EAL_LibCtxFree(libCtx);
CRYPT_EAL_MdFreeCtx(mdCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PROVIDER_REG_FUNC_TC002
* @title Register custom provider first and then register default provider
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PROVIDER_REG_FUNC_TC002(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
CRYPT_EAL_MdCTX *mdCtx = NULL;
TestMemInit();
CRYPT_EAL_LibCtx *libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
// 1st: A provider, 2nd: B provider, 3rd: default provider
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, PROVIDER_A_NAME, ProviderAInit, NULL, NULL), 0);
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, PROVIDER_B_NAME, ProviderBInit, NULL, NULL), 0);
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, PROVIDER_DEFAULT_NAME, NULL, NULL, NULL), 0);
mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_SHA256, NULL);
ASSERT_TRUE(mdCtx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(mdCtx), PROVIDER_A_SHA256_INIT_RET);
CRYPT_EAL_MdFreeCtx(mdCtx);
mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_MD5, NULL);
ASSERT_TRUE(mdCtx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(mdCtx), PROVIDER_B_MD5_INIT_RET);
CRYPT_EAL_MdFreeCtx(mdCtx);
mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_SHA256, "provider?default");
ASSERT_TRUE(mdCtx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(mdCtx), DEFAULT_SHA256_INIT_RET);
CRYPT_EAL_MdFreeCtx(mdCtx);
mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, CRYPT_MD_MD5, "provider=default");
ASSERT_TRUE(mdCtx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(mdCtx), DEFAULT_MD5_INIT_RET);
EXIT:
CRYPT_EAL_LibCtxFree(libCtx);
CRYPT_EAL_MdFreeCtx(mdCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_PROVIDER_REG_API_TC001
* @title Api test for CRYPT_EAL_ProviderRegister
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPTO_PROVIDER_REG_API_TC001(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
TestMemInit();
CRYPT_EAL_LibCtx *libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
/* Test case 1: libCtx test */
// 1.1 Test with NULL libCtx and NULL providerName
ASSERT_EQ(CRYPT_EAL_ProviderRegister(NULL, NULL, ProviderAInit, NULL, NULL), CRYPT_INVALID_ARG);
// 1.2 Test with NULL libCtx and valid providerName but NULL init for non-default
ASSERT_EQ(CRYPT_EAL_ProviderRegister(NULL, "non_default_null_init", NULL, NULL, NULL), CRYPT_NULL_INPUT);
// 1.3 libCtx is NULL (should use global context)
ASSERT_EQ(CRYPT_EAL_ProviderRegister(NULL, PROVIDER_DEFAULT_NAME, NULL, NULL, NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderRegister(NULL, PROVIDER_DEFAULT_NAME, ProviderAInit, NULL, NULL), CRYPT_SUCCESS);
/* Test case 2: provider name test */
// 2.1 Test with NULL provider name
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, NULL, ProviderAInit, NULL, NULL), CRYPT_INVALID_ARG);
// 2.2 Test with empty provider name
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, "", ProviderAInit, NULL, NULL), CRYPT_INVALID_ARG);
// 2.3 Test with very long provider name
char longProviderName[4096];
(void)memset_s(longProviderName, sizeof(longProviderName), 'a', sizeof(longProviderName) - 1);
longProviderName[sizeof(longProviderName) - 1] = '\0';
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, longProviderName, ProviderAInit, NULL, NULL), CRYPT_INVALID_ARG);
// 2.4 Test with special characters in provider name
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, "special_chars_!@#$%", ProviderAInit, NULL, NULL), CRYPT_SUCCESS);
// 2.5 Register the same provider twice
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, PROVIDER_A_NAME, ProviderAInit, NULL, NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, PROVIDER_A_NAME, ProviderAInit, NULL, NULL), CRYPT_SUCCESS);
// 2.6 Test with different init function for same provider name
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, "same_name_different_init", ProviderAInit, NULL, NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, "same_name_different_init", ProviderBInit, NULL, NULL), CRYPT_SUCCESS);
// 2.7 Test that default provider can be registered multiple times
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, PROVIDER_DEFAULT_NAME, NULL, NULL, NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, PROVIDER_DEFAULT_NAME, NULL, NULL, NULL), CRYPT_SUCCESS);
/* Test case 3: Init function test */
// 3.1 For non-predefined provider, init function is NULL
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, "non_default_provider", NULL, NULL, NULL), CRYPT_NULL_INPUT);
// 3.2 For predefined provider (default), init function can be NULL
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, PROVIDER_DEFAULT_NAME, NULL, NULL, NULL), CRYPT_SUCCESS);
// 3.3 Test with valid param but NULL init function for non-default provider
BSL_Param validParam[] = {{0}};
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, "provider_valid_param_null_init", NULL, validParam, NULL),
CRYPT_NULL_INPUT);
/* Test case 4: mgrCtx test */
// 4.1 mgrCtx is not NULL but *mgrCtx is not NULL
CRYPT_EAL_ProvMgrCtx *dummyCtx = (CRYPT_EAL_ProvMgrCtx *)0x12345678;
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, PROVIDER_A_NAME, ProviderAInit, NULL, &dummyCtx), CRYPT_INVALID_ARG);
// 4.2 Register provider with valid mgrCtx parameter
CRYPT_EAL_ProvMgrCtx *mgrCtx = NULL;
ASSERT_EQ(CRYPT_EAL_ProviderRegister(libCtx, PROVIDER_B_NAME, ProviderBInit, NULL, &mgrCtx), CRYPT_SUCCESS);
ASSERT_TRUE(mgrCtx != NULL);
EXIT:
CRYPT_EAL_LibCtxFree(libCtx);
#endif
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/provider/test_suite_sdv_eal_provider_reg.c | C | unknown | 12,926 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
#include "securec.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "crypt_eal_init.h"
#include "crypt_eal_provider.h"
#include "crypt_provider_local.h"
#include "crypt_eal_implprovider.h"
#include "crypt_provider.h"
#include "crypt_eal_mac.h"
#include "eal_mac_local.h"
#include "crypt_eal_kdf.h"
#include "eal_kdf_local.h"
#include "crypt_eal_md.h"
#include "eal_md_local.h"
#include "crypt_eal_pkey.h"
#include "eal_pkey_local.h"
#include "test.h"
#include "crypt_eal_cmvp.h"
#include "crypt_errno.h"
#include "bsl_sal.h"
#include "bsl_list.h"
#include "bsl_errno.h"
#include "crypt_eal_md.h"
#include "hitls_crypt_type.h"
#include "hitls_cert_type.h"
#include "hitls_type.h"
#include "crypt_eal_entropy.h"
#include "crypt_util_rand.h"
/* END_HEADER */
#ifdef HITLS_CRYPTO_CMVP_SM_PURE_C
#define HITLS_CRYPTO_CMVP_SM
#define HITLS_SM_PROVIDER_PATH "../../output/CMVP/C/lib"
#endif
#ifdef HITLS_CRYPTO_CMVP_SM_ARMV8_LE
#define HITLS_CRYPTO_CMVP_SM
#define HITLS_SM_PROVIDER_PATH "../../output/CMVP/armv8_le/lib"
#endif
#ifdef HITLS_CRYPTO_CMVP_SM_X86_64
#define HITLS_CRYPTO_CMVP_SM
#define HITLS_SM_PROVIDER_PATH "../../output/CMVP/x86_64/lib"
#endif
#ifdef HITLS_CRYPTO_CMVP_SM
#define HITLS_SM_LIB_NAME "libhitls_sm.so"
#define HITLS_SM_PROVIDER_ATTR "provider=sm"
static CRYPT_EAL_LibCtx *SM_ProviderLoad(void)
{
CRYPT_EAL_LibCtx *libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, HITLS_SM_PROVIDER_PATH), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, 0, HITLS_SM_LIB_NAME, NULL, NULL), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderRandInitCtx(libCtx, CRYPT_RAND_SM3, HITLS_SM_PROVIDER_ATTR, NULL, 0, NULL),
CRYPT_SUCCESS);
return libCtx;
EXIT:
CRYPT_EAL_LibCtxFree(libCtx);
return NULL;
}
static void SM_ProviderUnload(CRYPT_EAL_LibCtx *ctx)
{
CRYPT_EAL_RandDeinitEx(ctx);
CRYPT_EAL_LibCtxFree(ctx);
}
#endif /* HITLS_CRYPTO_CMVP_SM */
/* BEGIN_CASE */
void SDV_SM_PROVIDER_PKEY_SIGN_VERIFY_TEST_TC001()
{
#ifndef HITLS_CRYPTO_CMVP_SM
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
uint8_t signature[128] = {0};
uint32_t signatureLen = sizeof(signature);
uint8_t testData[] = "Test data for signing and verification with ECDSA";
uint32_t testDataLen = sizeof(testData) - 1;
libCtx = SM_ProviderLoad();
ASSERT_TRUE(libCtx != NULL);
pkeyCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_SM2, 0, HITLS_SM_PROVIDER_ATTR);
ASSERT_TRUE(pkeyCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkeyCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, CRYPT_MD_SM3, testData, testDataLen, signature, &signatureLen), 0);
ASSERT_TRUE(signatureLen > 0);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkeyCtx, CRYPT_MD_SM3, testData, testDataLen, signature, signatureLen),
CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
SM_ProviderUnload(libCtx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_SM_PROVIDER_DRBG_TEST_TC001(int algId)
{
#ifndef HITLS_CRYPTO_CMVP_SM
(void)algId;
SKIP_TEST();
#else
CRYPT_EAL_RndCtx *randCtx = NULL;
CRYPT_EAL_LibCtx *libCtx = NULL;
libCtx = SM_ProviderLoad();
ASSERT_TRUE(libCtx != NULL);
randCtx = CRYPT_EAL_ProviderDrbgNewCtx(libCtx, algId, NULL, NULL);
ASSERT_TRUE(randCtx != NULL);
ASSERT_EQ(CRYPT_EAL_DrbgInstantiate(randCtx, NULL, 0), CRYPT_SUCCESS);
uint8_t data[16] = {0};
uint32_t dataLen = sizeof(data);
ASSERT_EQ(CRYPT_EAL_Drbgbytes(randCtx, data, dataLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_DrbgSeed(randCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_Drbgbytes(randCtx, data, dataLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_DrbgDeinit(randCtx);
SM_ProviderUnload(libCtx);
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_SM_PROVIDER_MD_TEST_TC001(int algId)
{
#ifndef HITLS_CRYPTO_CMVP_SM
(void)algId;
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_MdCTX *mdCtx = NULL;
uint8_t plaintext[128] = {0};
uint32_t plaintextLen = sizeof(plaintext);
uint8_t md[128] = {0};
uint32_t mdLen = sizeof(md);
libCtx = SM_ProviderLoad();
ASSERT_TRUE(libCtx != NULL);
mdCtx = CRYPT_EAL_ProviderMdNewCtx(libCtx, algId, HITLS_SM_PROVIDER_ATTR);
ASSERT_TRUE(mdCtx != NULL);
int32_t ret = CRYPT_EAL_MdInit(mdCtx);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_MdUpdate(mdCtx, plaintext, plaintextLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_MdFinal(mdCtx, md, &mdLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MdFreeCtx(mdCtx);
SM_ProviderUnload(libCtx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_SM_PROVIDER_MAC_TEST_TC001(int algId, int keyLen)
{
#ifndef HITLS_CRYPTO_CMVP_SM
(void)algId;
(void)keyLen;
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_MacCtx *macCtx = NULL;
uint8_t macKey[32] = {0};
uint32_t macKeyLen = keyLen;
uint8_t plaintext[128] = {0};
uint32_t plaintextLen = sizeof(plaintext);
uint8_t mac[128] = {0};
uint32_t macLen = sizeof(mac);
libCtx = SM_ProviderLoad();
ASSERT_TRUE(libCtx != NULL);
macCtx = CRYPT_EAL_ProviderMacNewCtx(libCtx, algId, HITLS_SM_PROVIDER_ATTR);
ASSERT_TRUE(macCtx != NULL);
int32_t ret = CRYPT_EAL_MacInit(macCtx, macKey, macKeyLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
if (algId == CRYPT_MAC_CBC_MAC_SM4) {
CRYPT_PaddingType padType = CRYPT_PADDING_ZEROS;
ASSERT_EQ(CRYPT_EAL_MacCtrl(macCtx, CRYPT_CTRL_SET_CBC_MAC_PADDING, &padType, sizeof(CRYPT_PaddingType)),
CRYPT_SUCCESS);
}
ret = CRYPT_EAL_MacUpdate(macCtx, plaintext, plaintextLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_MacFinal(macCtx, mac, &macLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(macCtx);
SM_ProviderUnload(libCtx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_SM_PROVIDER_KDF_TEST_TC001(int macId, int iter, int saltLen)
{
#ifndef HITLS_CRYPTO_CMVP_SM
(void)macId;
(void)iter;
(void)saltLen;
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_KdfCTX *kdfCtx = NULL;
uint8_t password[32] = {0};
uint32_t passwordLen = sizeof(password);
uint8_t salt[32] = {0};
uint8_t derivedKey[32] = {0};
uint32_t derivedKeyLen = sizeof(derivedKey);
libCtx = SM_ProviderLoad();
ASSERT_TRUE(libCtx != NULL);
kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_PBKDF2, HITLS_SM_PROVIDER_ATTR);
ASSERT_TRUE(kdfCtx != NULL);
BSL_Param param[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};
(void)BSL_PARAM_InitValue(¶m[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32, &macId, sizeof(macId));
(void)BSL_PARAM_InitValue(¶m[1], CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS, password, passwordLen);
(void)BSL_PARAM_InitValue(¶m[2], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS, salt, saltLen);
(void)BSL_PARAM_InitValue(¶m[3], CRYPT_PARAM_KDF_ITER, BSL_PARAM_TYPE_UINT32, &iter, sizeof(iter));
int32_t ret = CRYPT_EAL_KdfSetParam(kdfCtx, param);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_KdfDerive(kdfCtx, derivedKey, derivedKeyLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_KdfFreeCtx(kdfCtx);
SM_ProviderUnload(libCtx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_SM_PROVIDER_CMVP_SELFTEST_Test_TC001()
{
#ifndef HITLS_CRYPTO_CMVP_SM
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_SelftestCtx *selftestCtx = NULL;
libCtx = SM_ProviderLoad();
ASSERT_TRUE(libCtx != NULL);
selftestCtx = CRYPT_CMVP_SelftestNewCtx(libCtx, HITLS_SM_PROVIDER_ATTR);
ASSERT_TRUE(selftestCtx != NULL);
const char *version = CRYPT_CMVP_GetVersion(selftestCtx);
ASSERT_TRUE(version != NULL);
BSL_Param params[3] = {{0}, BSL_PARAM_END, BSL_PARAM_END};
int32_t type = CRYPT_CMVP_KAT_TEST;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_CMVP_SELFTEST_TYPE, BSL_PARAM_TYPE_INT32,
&type, sizeof(type)), CRYPT_SUCCESS);
int32_t ret = CRYPT_CMVP_Selftest(selftestCtx, params);
ASSERT_EQ(ret, CRYPT_SUCCESS);
type = CRYPT_CMVP_INTEGRITY_TEST;
ret = CRYPT_CMVP_Selftest(selftestCtx, params);
ASSERT_EQ(ret, CRYPT_SUCCESS);
type = CRYPT_CMVP_RANDOMNESS_TEST;
uint8_t random[32] = {0};
uint32_t randomLen = sizeof(random);
ASSERT_EQ(CRYPT_EAL_RandbytesEx(libCtx, random, randomLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_CMVP_RANDOM, BSL_PARAM_TYPE_OCTETS,
random, randomLen), CRYPT_SUCCESS);
ret = CRYPT_CMVP_Selftest(selftestCtx, params);
ASSERT_TRUE(ret == CRYPT_SUCCESS || ret == CRYPT_CMVP_RANDOMNESS_ERR);
EXIT:
CRYPT_CMVP_SelftestFreeCtx(selftestCtx);
SM_ProviderUnload(libCtx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_SM_PROVIDER_CIPHPER_TEST_TC001()
{
#ifndef HITLS_CRYPTO_CMVP_SM
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_CipherCtx *cipherCtx = NULL;
uint8_t key[32] = {0};
uint32_t keyLen = 16;
uint8_t iv[32] = {0};
uint32_t ivLen = 16;
uint8_t plain[] = "Test data for signing and verification with ECDSA";
uint32_t plainLen = sizeof(plainLen) - 1;
uint8_t cipher[128] = {0};
uint32_t cipherLen = sizeof(cipher);
libCtx = SM_ProviderLoad();
ASSERT_TRUE(libCtx != NULL);
cipherCtx = CRYPT_EAL_ProviderCipherNewCtx(libCtx, CRYPT_CIPHER_SM4_CBC, HITLS_SM_PROVIDER_ATTR);
ASSERT_TRUE(cipherCtx != NULL);
int32_t ret = CRYPT_EAL_CipherInit(cipherCtx, key, keyLen, iv, ivLen, true);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherSetPadding(cipherCtx, CRYPT_PADDING_PKCS7);
ASSERT_EQ(ret, CRYPT_SUCCESS);
uint32_t tmpLen = cipherLen;
ret = CRYPT_EAL_CipherUpdate(cipherCtx, plain, plainLen, cipher, &tmpLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
cipherLen = tmpLen;
tmpLen = sizeof(cipher) - cipherLen;
ret = CRYPT_EAL_CipherFinal(cipherCtx, cipher + cipherLen, &tmpLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
cipherLen += tmpLen;
EXIT:
CRYPT_EAL_CipherFreeCtx(cipherCtx);
SM_ProviderUnload(libCtx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_SM_PROVIDER_KDF_PARAM_CHECK_TC001()
{
#ifndef HITLS_CRYPTO_CMVP_SM
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_KdfCTX *kdfCtx = NULL;
uint8_t password[32] = {0};
uint32_t passwordLen = sizeof(password);
uint8_t salt[32] = {0};
uint8_t derivedKey[32] = {0};
libCtx = SM_ProviderLoad();
ASSERT_TRUE(libCtx != NULL);
kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_PBKDF2, HITLS_SM_PROVIDER_ATTR);
ASSERT_TRUE(kdfCtx != NULL);
int32_t iter = 1024;
int32_t saltLen = 8;
int32_t macId = CRYPT_MAC_HMAC_SHA256;
BSL_Param param[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};
(void)BSL_PARAM_InitValue(¶m[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32, &macId, sizeof(macId));
(void)BSL_PARAM_InitValue(¶m[1], CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS, password, passwordLen);
(void)BSL_PARAM_InitValue(¶m[2], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS, salt, saltLen);
(void)BSL_PARAM_InitValue(¶m[3], CRYPT_PARAM_KDF_ITER, BSL_PARAM_TYPE_UINT32, &iter, sizeof(iter));
int32_t ret = CRYPT_EAL_KdfSetParam(kdfCtx, param);
ASSERT_EQ(ret, CRYPT_CMVP_ERR_PARAM_CHECK);
macId = CRYPT_MAC_HMAC_SM3;
ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, param), CRYPT_SUCCESS);
iter = 1023;
ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, param), CRYPT_CMVP_ERR_PARAM_CHECK);
iter = 1024;
ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, param), CRYPT_SUCCESS);
saltLen = 7;
(void)BSL_PARAM_InitValue(¶m[2], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS, salt, saltLen);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, param), CRYPT_CMVP_ERR_PARAM_CHECK);
saltLen = 8;
(void)BSL_PARAM_InitValue(¶m[2], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS, salt, saltLen);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(kdfCtx, param), CRYPT_SUCCESS);
uint32_t derivedKeyLen = 1;
ret = CRYPT_EAL_KdfDerive(kdfCtx, derivedKey, derivedKeyLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_KdfFreeCtx(kdfCtx);
SM_ProviderUnload(libCtx);
return;
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_SM_PROVIDER_SM2_CHECK_TEST_TC001()
{
#ifndef HITLS_CRYPTO_CMVP_SM
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
libCtx = SM_ProviderLoad();
ASSERT_TRUE(libCtx != NULL);
pkeyCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_SM2, 0, HITLS_SM_PROVIDER_ATTR);
ASSERT_TRUE(pkeyCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkeyCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkeyCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pkeyCtx, pkeyCtx), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
SM_ProviderUnload(libCtx);
return;
#endif
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/provider/test_suite_sdv_eal_sm_provider.c | C | unknown | 13,864 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
#include <pthread.h>
#include "crypt_bn.h"
#include "bsl_sal.h"
#include "crypt_algid.h"
#include "crypt_types.h"
#include "crypt_eal_pkey.h"
#include "crypt_errno.h"
#include "stub_replace.h"
#include "crypt_eal_rand.h"
#include "crypt_util_rand.h"
#include "eal_pkey_local.h"
#include "crypt_rsa.h"
#include "rsa_local.h"
#include "bn_basic.h"
#include "securec.h"
#define SUCCESS 0
#define FAIL (-1)
#define RSA_MAX_KEYLEN 2048
#define RSA_MIN_KEYLEN 128
#define MAX_PARAM_LEN 2048
#define MAX_CIPHERTEXT_LEN 2048
#define PUB_EXP 3
#define KEYLEN_IN_BYTES(keyLen) ((keyLen) >> 3)
int32_t RandFunc(uint8_t *randNum, uint32_t randLen)
{
const int maxNum = 255;
for (uint32_t i = 0; i < randLen; i++) {
randNum[i] = (uint8_t)(rand() % maxNum);
}
return 0;
}
int32_t RandFuncEx(void *libCtx, uint8_t *randNum, uint32_t randLen)
{
(void)libCtx;
const int maxNum = 255;
for (uint32_t i = 0; i < randLen; i++) {
randNum[i] = (uint8_t)(rand() % maxNum);
}
return 0;
}
void *malloc_fail(uint32_t size)
{
(void)size;
return NULL;
}
void PubkeyFree(CRYPT_EAL_PkeyPub *pubkey)
{
if (pubkey == NULL) {
return;
}
free(pubkey);
}
void PrvkeyFree(CRYPT_EAL_PkeyPrv *prvkey)
{
if (prvkey == NULL) {
return;
}
free(prvkey);
}
#define TMP_BUFF_LEN 2048
static uint8_t g_RandBuf[TMP_BUFF_LEN];
int32_t STUB_ReplaceRandom(uint8_t *r, uint32_t randLen)
{
if (randLen > TMP_BUFF_LEN) {
return -1;
}
for (uint32_t i = 0; i < randLen; i++) {
r[i] = g_RandBuf[i];
}
return 0;
}
int32_t STUB_ReplaceRandomEx(void *libCtx, uint8_t *r, uint32_t randLen)
{
(void)libCtx;
if (randLen > TMP_BUFF_LEN) {
return -1;
}
for (uint32_t i = 0; i < randLen; i++) {
r[i] = g_RandBuf[i];
}
return 0;
}
void SetRsaPara(CRYPT_EAL_PkeyPara *para, uint8_t *e, uint32_t eLen, uint32_t bits)
{
para->id = CRYPT_PKEY_RSA;
para->para.rsaPara.e = e;
para->para.rsaPara.eLen = eLen;
para->para.rsaPara.bits = bits;
}
void SetRsaPubKey(CRYPT_EAL_PkeyPub *pubKey, uint8_t *n, uint32_t nLen, uint8_t *e, uint32_t eLen)
{
pubKey->id = CRYPT_PKEY_RSA;
pubKey->key.rsaPub.n = n;
pubKey->key.rsaPub.nLen = nLen;
pubKey->key.rsaPub.e = e;
pubKey->key.rsaPub.eLen = eLen;
}
void SetRsaPrvKey(CRYPT_EAL_PkeyPrv *prvKey, uint8_t *n, uint32_t nLen, uint8_t *d, uint32_t dLen)
{
prvKey->id = CRYPT_PKEY_RSA;
prvKey->key.rsaPrv.n = n;
prvKey->key.rsaPrv.nLen = nLen;
prvKey->key.rsaPrv.d = d;
prvKey->key.rsaPrv.dLen = dLen;
}
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/rsa/test_suite_sdv_eal_rsa.base.c | C | unknown | 3,217 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* INCLUDE_BASE test_suite_sdv_eal_rsa */
/* BEGIN_HEADER */
#include "bsl_params.h"
#include "bsl_err.h"
#include "crypt_params_key.h"
#include "bn_bincal.h"
#include "bn_basic.h"
/* END_HEADER */
#define CRYPT_EAL_PKEY_KEYMGMT_OPERATE 0
/**
* @test SDV_CRYPTO_RSA_NEW_API_TC001
* @title RSA CRYPT_EAL_PkeyNewCtx test.
* @precon nan
* @brief
* 1. Call the CRYPT_EAL_PkeyNewCtx method to create ctx, algId is CRYPT_PKEY_RSA, expected result 1.
* 2. Release the ctx.
* 3. Repeat steps 1 to 2 for 100 times.
* @expect
* 1. The returned result is not empty.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_NEW_API_TC001(int isProvider)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = NULL;
/* Run 100 times */
for (int i = 0; i < 100; i++) {
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
CRYPT_EAL_PkeyFreeCtx(pkey);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_NEW_API_TC002
* @title RSA CRYPT_EAL_PkeyNewCtx test: Malloc failed.
* @precon Mock BSL_SAL_Malloc to malloc_fail.
* @brief
* 1. Call the CRYPT_EAL_PkeyNewCtx method to create ctx, algId is CRYPT_PKEY_RSA, expected result 1.
* 2. Release the ctx.
* 3. Reset the BSL_SAL_Malloc.
* @expect
* 1. Failed to create the ctx.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_NEW_API_TC002(int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
FuncStubInfo tmpRpInfo = {0};
STUB_Init();
ASSERT_TRUE(STUB_Replace(&tmpRpInfo, BSL_SAL_Malloc, malloc_fail) == 0);
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey == NULL);
EXIT:
STUB_Reset(&tmpRpInfo);
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_PARA_API_TC001
* @title RSA CRYPT_EAL_PkeySetPara: The e value of para is invalid.
* @precon Create the contexts of the rsa algorithm.
* @brief
* 1. Call the CRYPT_EAL_PkeySetPara method:
* (1) e = NULL, expected result 1.
* (2) e len = 0, expected result 1.
* (3) e = 0, expected result 2.
* (4) e is even, expected result 2.
* (5) e len = 1025, expected result 1.
* @expect
* 1. CRYPT_EAL_ERR_NEW_PARA_FAIL
* 2. CRYPT_RSA_ERR_E_VALUE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_PARA_API_TC001(int isProvider)
{
uint8_t e[] = {1, 0, 1};
uint8_t e2[] = {1, 0};
uint8_t e0[] = {0, 0, 0};
uint8_t longE[1025] = {0};
longE[0] = 0x01;
longE[1024] = 0x01; // The tail of 1024 is set to 1.
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyCtx *pkey = NULL;
SetRsaPara(¶, e, 3, 1024); // bits: 1024 is valid
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
para.para.rsaPara.e = NULL;
ASSERT_TRUE_AND_LOG("e = NULL", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_EAL_ERR_NEW_PARA_FAIL);
para.para.rsaPara.eLen = 0;
ASSERT_TRUE_AND_LOG("e len = 0", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_EAL_ERR_NEW_PARA_FAIL);
para.para.rsaPara.e = e0;
para.para.rsaPara.eLen = 1;
ASSERT_TRUE_AND_LOG("e = 0", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_RSA_ERR_E_VALUE);
para.para.rsaPara.eLen = 2;
para.para.rsaPara.e = e2;
ASSERT_TRUE_AND_LOG("e is even", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_RSA_ERR_E_VALUE);
para.para.rsaPara.eLen = 1025; // 1025 is invalid, but the length is sufficient.
para.para.rsaPara.e = longE;
ASSERT_TRUE_AND_LOG("e len = 1025", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_EAL_ERR_NEW_PARA_FAIL);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_PARA_API_TC002
* @title RSA CRYPT_EAL_PkeySetPara: The bits value of para is invalid.
* @precon Create the contexts of the rsa algorithm.
* @brief
* 1. Call the CRYPT_EAL_PkeySetPara method with invalid bits, expected result 1.
* @expect
* 1. CRYPT_EAL_ERR_NEW_PARA_FAIL
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_PARA_API_TC002(int bits, int isProvider)
{
uint8_t e[] = {1, 0, 1};
CRYPT_EAL_PkeyPara para = {0};
SetRsaPara(¶, e, 3, bits); // eLen = 3
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = NULL;
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_EAL_ERR_NEW_PARA_FAIL);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_PARA_API_TC003
* @title RSA CRYPT_EAL_PkeySetPara: Success.
* @precon Create the contexts of the rsa algorithm.
* @brief
* 1. Call the CRYPT_EAL_PkeySetPara method, key len is 1024|1025|5120|16384 bits, expected result 1.
* @expect
* 1. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_PARA_API_TC003(int isProvider)
{
uint8_t e3[] = {1, 0, 1};
uint8_t e5[] = {1, 0, 0, 0, 1};
uint8_t e7[] = {1, 0, 0, 0, 0, 0, 1};
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyCtx *pkey = NULL;
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
SetRsaPara(¶, e3, 3, 1024); // Valid parameters: elen = 3, bits =1024
ASSERT_TRUE_AND_LOG("1k key", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
para.para.rsaPara.bits = 1025;
ASSERT_TRUE_AND_LOG("1025 bits key", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
SetRsaPara(¶, e5, 5, 5120);
ASSERT_TRUE_AND_LOG("5k key", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
SetRsaPara(¶, e7, 7, 16384);
ASSERT_TRUE_AND_LOG("16k key", CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_GEN_API_TC001
* @title RSA CRYPT_EAL_PkeyGen: No regist rand.
* @precon Create the contexts of the rsa algorithm and set para.
* @brief
* 1. Call the CRYPT_EAL_PkeyGen method to generate a key pair, expected result 1.
* @expect
* 1. Failed to genrate a key pair, the return value is CRYPT_NO_REGIST_RAND.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_GEN_API_TC001(int isProvider)
{
uint8_t e[] = {1, 0, 1};
CRYPT_EAL_PkeyPara para = {0};
SetRsaPara(¶, e, 3, 1024); // Valid parameters: elen = 3, bits =1024
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = NULL;
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_NO_REGIST_RAND);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_GET_PUB_API_TC001
* @title RSA CRYPT_EAL_PkeyGetPub test.
* @precon 1. Create the context of the rsa algorithm.
* 2. Initialize the DRBG.
* @brief
* 1. Call the CRYPT_EAL_PkeyGetPub method without public key, expected result 1
* 2. Set para and generate a key pair, expected result 2
* 3. Call the CRYPT_EAL_PkeyGetPub method:
* (1) pkey = NULL, expected result 1.
* (2) pub = NULL, expected result 1.
* (3) n = NULL, expected result 1.
* (4) n != NULL and nLen = 0, expected result 3.
* (5) e = NULL, expected result 1.
* (6) e != NULL, eLen = 0, expected result 3.
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_SUCCESS
* 3. CRYPT_BN_BUFF_LEN_NOT_ENOUGH
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_GET_PUB_API_TC001(int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
uint8_t e[] = {1, 0, 1};
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPub pubKey = {0};
uint8_t pubE[600];
uint8_t pubN[600];
SetRsaPara(¶, e, 3, 1024);
SetRsaPubKey(&pubKey, pubE, 600, pubN, 600); // 600 bytes > 1024 bits
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
/* Missing public key */
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(NULL, &pubKey), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, NULL), CRYPT_NULL_INPUT);
/* n = NULL */
pubKey.key.rsaPub.n = NULL;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_NULL_INPUT);
pubKey.key.rsaPub.n = pubN;
/* n != NULL and nLen = 0 */
pubKey.key.rsaPub.nLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_BN_BUFF_LEN_NOT_ENOUGH);
pubKey.key.rsaPub.nLen = 600;
/* e = NULL */
pubKey.key.rsaPub.e = NULL;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_NULL_INPUT);
pubKey.key.rsaPub.e = pubE;
/* e != NULL, eLen = 0 */
pubKey.key.rsaPub.eLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_BN_BUFF_LEN_NOT_ENOUGH);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_GET_PRV_API_TC001
* @title RSA CRYPT_EAL_PkeyGetPrv: Bad private key.
* @precon 1. Create the context of the rsa algorithm.
* 2. Initialize the DRBG.
* @brief
* 1. Call the CRYPT_EAL_PkeyGetPrv method without private key, expected result 1
* 2. Set para and generate a key pair, expected result 2
* 3. Call the CRYPT_EAL_PkeyGetPrv method:
* (1) pkey = NULL, expected result 1.
* (2) prv = NULL, expected result 1.
* (3) p = NULL and q = NULL, expected result 2.
* (4) p = NULL and q != NULL, expected result 1.
* (5) p != NULL and q != NULL, expected result 2.
* (6) d = NULL, expected result 1.
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_GET_PRV_API_TC001(int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPrv prvKey = {0};
CRYPT_EAL_PkeyPara para = {0};
uint8_t e[] = {1, 0, 1};
uint8_t prvD[600];
uint8_t prvN[600];
uint8_t prvP[600];
uint8_t prvQ[600];
SetRsaPrvKey(&prvKey, prvN, 600, prvD, 600);
SetRsaPara(¶, e, 3, 1024);
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
/* Missing private key */
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(NULL, &prvKey), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, NULL), CRYPT_NULL_INPUT);
/* p is NULL and q is NULL */
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey), CRYPT_SUCCESS);
/* p = NULL and q != NULL */
prvKey.key.rsaPrv.q = prvQ;
prvKey.key.rsaPrv.qLen = 600;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey), CRYPT_NULL_INPUT);
/* p != NULL and q != NULL */
prvKey.key.rsaPrv.p = prvP;
prvKey.key.rsaPrv.pLen = 600;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey), CRYPT_SUCCESS);
/* d = NULL */
prvKey.key.rsaPrv.d = NULL;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey), CRYPT_NULL_INPUT);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_SET_PRV_API_TC001
* @title RSA CRYPT_EAL_PkeySetPrv: Bad private key.
* @precon Create the contexts of the rsa algorithm and set para:
* pkey1: Generate a key pair.
* pkey2: set the private key.
* @brief
* 1. Call the CRYPT_EAL_PkeySetPrv method:
* (1) d is 0, expected result 1.
* (2) d is 1, expected result 1.
* (3) n is 0, expected result 2.
* (4) p is 0, expected result 1.
* (5) q is 0, expected result 1.
* (6) nLen is 2049, expected result 2.
* (7) p is null, expected result 3.
* @expect
* 1. CRYPT_RSA_ERR_INPUT_VALUE
* 2. CRYPT_RSA_ERR_KEY_BITS
* 3. CRYPT_RSA_NO_KEY_INFO
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_SET_PRV_API_TC001(int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyCtx *pkey2 = NULL;
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPrv prvKey = {0};
uint8_t e[] = {1, 0, 1};
uint8_t prvD[600];
uint8_t prvN[2500];
uint8_t prvP[600];
uint8_t prvQ[600];
uint8_t prvE[600];
SetRsaPrvKey(&prvKey, prvN, 600, prvD, 600);
SetRsaPara(¶, e, 3, 1024);
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL && pkey2 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey2, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
(void)memset_s(prvD, sizeof(prvD), 0x00, sizeof(prvD));
ASSERT_TRUE_AND_LOG("d is 0", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_RSA_ERR_INPUT_VALUE);
prvD[sizeof(prvD) - 1] = 1;
ASSERT_TRUE_AND_LOG("d is 1", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_RSA_ERR_INPUT_VALUE);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
(void)memset_s(prvN, sizeof(prvN), 0x00, sizeof(prvN));
ASSERT_TRUE_AND_LOG("n is 0", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_RSA_ERR_KEY_BITS);
prvKey.key.rsaPrv.q = prvQ;
prvKey.key.rsaPrv.qLen = 600; // 600 bytes > 1024 bits
prvKey.key.rsaPrv.p = prvP;
prvKey.key.rsaPrv.pLen = 600; // 600 bytes > 1024 bits
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
(void)memset_s(prvP, sizeof(prvP), 0x00, sizeof(prvP));
ASSERT_TRUE_AND_LOG("p is 0", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_RSA_ERR_INPUT_VALUE);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
(void)memset_s(prvQ, sizeof(prvQ), 0x00, sizeof(prvQ));
ASSERT_TRUE_AND_LOG("q is 0", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_RSA_ERR_INPUT_VALUE);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
prvKey.key.rsaPrv.nLen = 2049; // 2049 > MAx n len
ASSERT_TRUE_AND_LOG("nLen is 2049", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_RSA_ERR_KEY_BITS);
prvKey.key.rsaPrv.nLen = 600; // 600 bytes > 1024 bits
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
prvKey.key.rsaPrv.p = NULL;
ASSERT_TRUE_AND_LOG("p is NULL", CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_RSA_NO_KEY_INFO);
prvKey.key.rsaPrv.p = prvP;
prvKey.key.rsaPrv.e = prvE;
prvKey.key.rsaPrv.eLen = 600;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey), CRYPT_SUCCESS);
ASSERT_COMPARE("rsa e", prvKey.key.rsaPrv.e, prvKey.key.rsaPrv.eLen, e, 3);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey2, &prvKey) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(pkey2, &prvKey) == CRYPT_SUCCESS);
ASSERT_COMPARE("rsa e", prvKey.key.rsaPrv.e, prvKey.key.rsaPrv.eLen, e, 3);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(pkey2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_SET_PRV_API_TC002
* @title RSA CRYPT_EAL_PkeySetPrv: Specification test.
* @precon Create the context(pkey) of the rsa algorithm.
* @brief
* 1. Call the CRYPT_EAL_PkeySetPrv method:
* (1) d = n, expected result 1
* (2) n less than 1024 bits, expected result 2
* (3) n greater than 16384 bits, expected result 2
* (4) d greater than 16384 bits, expected result 2
* (5) d greater than n, expected result 2
* (6) Min len success case, expected result 3
* (7) Max len success case, expected result 3
* @expect
* 1. CRYPT_RSA_ERR_INPUT_VALUE
* 2. CRYPT_RSA_ERR_KEY_BITS
* 3. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_SET_PRV_API_TC002(int isProvider)
{
uint8_t prvD[2050]; // max rsa key len is 16384 bits, 16384/8 = 2048, 2050 > 2048
uint8_t prvN[2050]; // max rsa key len is 16384 bits, 16384/8 = 2048, 2050 > 2048
CRYPT_EAL_PkeyPrv prvKey = {0};
(void)memset_s(prvD, sizeof(prvD), 0xff, sizeof(prvD));
(void)memset_s(prvN, sizeof(prvN), 0xff, sizeof(prvN));
SetRsaPrvKey(&prvKey, prvN, RSA_MIN_KEYLEN, prvD, RSA_MIN_KEYLEN);
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = NULL;
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE_AND_LOG("d = n", CRYPT_EAL_PkeySetPrv(pkey, &prvKey) == CRYPT_RSA_ERR_INPUT_VALUE);
prvKey.key.rsaPrv.nLen = RSA_MIN_KEYLEN - 1;
ASSERT_TRUE_AND_LOG("n less than 1024 bits", CRYPT_EAL_PkeySetPrv(pkey, &prvKey) == CRYPT_RSA_ERR_KEY_BITS);
prvKey.key.rsaPrv.nLen = RSA_MAX_KEYLEN + 1;
ASSERT_TRUE_AND_LOG("n greater than 16384 bits", CRYPT_EAL_PkeySetPrv(pkey, &prvKey) == CRYPT_RSA_ERR_KEY_BITS);
prvKey.key.rsaPrv.nLen = RSA_MAX_KEYLEN;
prvKey.key.rsaPrv.dLen = RSA_MAX_KEYLEN + 1;
ASSERT_TRUE_AND_LOG("d greater than 16384 bits", CRYPT_EAL_PkeySetPrv(pkey, &prvKey) == CRYPT_RSA_ERR_KEY_BITS);
prvKey.key.rsaPrv.nLen = RSA_MIN_KEYLEN;
prvKey.key.rsaPrv.dLen = RSA_MIN_KEYLEN + 1;
ASSERT_TRUE_AND_LOG("d greater than n", CRYPT_EAL_PkeySetPrv(pkey, &prvKey) == CRYPT_RSA_ERR_KEY_BITS);
prvKey.key.rsaPrv.dLen = RSA_MIN_KEYLEN;
prvD[0] = 0;
ASSERT_TRUE_AND_LOG("Min len success case", CRYPT_EAL_PkeySetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
prvKey.key.rsaPrv.nLen = RSA_MAX_KEYLEN;
prvKey.key.rsaPrv.dLen = RSA_MAX_KEYLEN;
ASSERT_TRUE_AND_LOG("Max len success case", CRYPT_EAL_PkeySetPrv(pkey, &prvKey) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_SET_PUB_API_TC001
* @title RSA CRYPT_EAL_PkeyGetPub: Bad public key.
* @precon Create the contexts of the rsa algorithm and set para:
* pkey1: Generate a key pair.
* pkey2: Set the public key..
* @brief
* 1. Call the CRYPT_EAL_PkeyGetPub method:
* (1) nLen > maxNLen, expected result 1
* (2) n is Null, expected result 2
* (3) n is 0, expected result 1
* (4) e is NULL, expected result 2
* (5) e is 0, expected result 3
* @ex pect
* 1. CRYPT_RSA_ERR_KEY_BITS
* 2. CRYPT_NULL_INPUT
* 3. CRYPT_RSA_ERR_INPUT_VALUE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_SET_PUB_API_TC001(int isProvider)
{
uint8_t e[] = {1, 0, 1};
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyCtx *pkey2 = NULL;
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPub pubKey;
uint8_t pubE[600];
uint8_t pubN[2500];
SetRsaPara(¶, e, 3, 1024);
SetRsaPubKey(&pubKey, pubN, 600, pubE, 600);
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL && pkey2 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey2, ¶) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pubKey) == CRYPT_SUCCESS);
pubKey.key.rsaPub.nLen = 2049;
ASSERT_TRUE_AND_LOG("nLen > maxNLen", CRYPT_EAL_PkeySetPub(pkey2, &pubKey) == CRYPT_RSA_ERR_KEY_BITS);
pubKey.key.rsaPub.nLen = 600; // 600 bytes > 1024 bits
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pubKey) == CRYPT_SUCCESS);
pubKey.key.rsaPub.n = NULL;
ASSERT_TRUE_AND_LOG("n is Null", CRYPT_EAL_PkeySetPub(pkey2, &pubKey) == CRYPT_NULL_INPUT);
pubKey.key.rsaPub.n = pubN;
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pubKey) == CRYPT_SUCCESS);
(void)memset_s(pubN, sizeof(pubN), 0x00, sizeof(pubN));
ASSERT_TRUE_AND_LOG("n is 0", CRYPT_EAL_PkeySetPub(pkey2, &pubKey) == CRYPT_RSA_ERR_KEY_BITS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pubKey) == CRYPT_SUCCESS);
pubKey.key.rsaPub.e = NULL;
ASSERT_TRUE_AND_LOG("e is Null", CRYPT_EAL_PkeySetPub(pkey2, &pubKey) == CRYPT_NULL_INPUT);
pubKey.key.rsaPub.e = pubE;
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(pkey, &pubKey) == CRYPT_SUCCESS);
(void)memset_s(pubE, sizeof(pubE), 0x00, sizeof(pubE));
ASSERT_TRUE_AND_LOG("e is 0", CRYPT_EAL_PkeySetPub(pkey2, &pubKey) == CRYPT_RSA_ERR_INPUT_VALUE);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(pkey2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_SET_PUB_API_TC002
* @title RSA CRYPT_EAL_PkeySetPub: Specification test.
* @precon Create the context(pkey) of the rsa algorithm.
* @brief
* 1. Call the CRYPT_EAL_PkeySetPub method:
* (1) e = n, expected result 1
* (2) nLen < 1024 bits, expected result 2
* (3) eLen > 16384 bits, expected result 2
* (3) nLen > 16384 bits, expected result 2
* (4) e > n, expected result 2
* (6) Min len success case, expected result 3
* (7) Max len success case, expected result 3
* (8) e = 1, expected result 1
* (9) n = 1, expected result 1
* @expect
* 1. CRYPT_RSA_ERR_INPUT_VALUE
* 2. CRYPT_RSA_ERR_KEY_BITS
* 3. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_SET_PUB_API_TC002(int isProvider)
{
uint8_t pubE[2050]; // max rsa key len is 16384 bits, 16384/8 = 2048, 2050 > 2048
uint8_t pubN[2050]; // max rsa key len is 16384 bits, 16384/8 = 2048, 2050 > 2048
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPub pubKey = {0};
SetRsaPubKey(&pubKey, pubN, RSA_MIN_KEYLEN, pubE, RSA_MIN_KEYLEN);
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
(void)memset_s(pubE, sizeof(pubE), 0xff, sizeof(pubE));
(void)memset_s(pubN, sizeof(pubN), 0xff, sizeof(pubN));
ASSERT_TRUE_AND_LOG("e = n", CRYPT_EAL_PkeySetPub(pkey, &pubKey) == CRYPT_RSA_ERR_INPUT_VALUE);
pubKey.key.rsaPub.nLen = RSA_MIN_KEYLEN - 1;
ASSERT_TRUE_AND_LOG("n less than 1024 bits", CRYPT_EAL_PkeySetPub(pkey, &pubKey) == CRYPT_RSA_ERR_KEY_BITS);
pubKey.key.rsaPub.nLen = RSA_MAX_KEYLEN;
pubKey.key.rsaPub.eLen = RSA_MAX_KEYLEN + 1;
ASSERT_TRUE_AND_LOG("e greater than 16384 bits", CRYPT_EAL_PkeySetPub(pkey, &pubKey) == CRYPT_RSA_ERR_KEY_BITS);
pubKey.key.rsaPub.nLen = RSA_MAX_KEYLEN + 1;
pubKey.key.rsaPub.eLen = RSA_MAX_KEYLEN;
ASSERT_TRUE_AND_LOG("n greater than 16384 bits", CRYPT_EAL_PkeySetPub(pkey, &pubKey) == CRYPT_RSA_ERR_KEY_BITS);
pubKey.key.rsaPub.nLen = RSA_MIN_KEYLEN;
pubKey.key.rsaPub.eLen = RSA_MIN_KEYLEN + 1;
ASSERT_TRUE_AND_LOG("e greater than n", CRYPT_EAL_PkeySetPub(pkey, &pubKey) == CRYPT_RSA_ERR_KEY_BITS);
pubE[0] = 0;
pubKey.key.rsaPub.eLen = RSA_MIN_KEYLEN;
ASSERT_TRUE_AND_LOG("Min len success case", CRYPT_EAL_PkeySetPub(pkey, &pubKey) == CRYPT_SUCCESS);
pubKey.key.rsaPub.nLen = RSA_MAX_KEYLEN;
pubKey.key.rsaPub.eLen = RSA_MAX_KEYLEN;
ASSERT_TRUE_AND_LOG("Max len failed case", CRYPT_EAL_PkeySetPub(pkey, &pubKey) == CRYPT_RSA_ERR_KEY_BITS);
(void)memset_s(pubE, sizeof(pubE), 0, sizeof(pubE));
ASSERT_TRUE_AND_LOG("e = 0", CRYPT_EAL_PkeySetPub(pkey, &pubKey) == CRYPT_RSA_ERR_INPUT_VALUE);
pubE[RSA_MAX_KEYLEN - 1] = 1;
ASSERT_TRUE_AND_LOG("e = 1", CRYPT_EAL_PkeySetPub(pkey, &pubKey) == CRYPT_RSA_ERR_INPUT_VALUE);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_ENC_API_TC001
* @title RSA CRYPT_EAL_PkeyEncrypt: Test the validity of input parameters.
* @precon Create the context of the rsa algorithm:
* @brief
* 1. Call the CRYPT_EAL_PkeyEncrypt method without public key, expected result 1
* 2. Set pubkey and call the CRYPT_EAL_PkeyEncrypt method, expected result 2
* 3. Set the oaep paading mode, expected result 3
* 4. Call the CRYPT_EAL_PkeyEncrypt method:
* (1) pkey = NULL, expected result 4
* (2) data = NULL, expected result 4
* (3) data != NULL, dataLen = 0, expected result 3
* (4) data != NULL dataLen > k - 2*hashLen - 2, expected result 5
* (5) out = NULL, expected result 4
* (6) outLen = NULL, expected result 4
* (7) outLen = 0, expected result 6
* @expect
* 1. CRYPT_RSA_NO_KEY_INFO
* 2. CRYPT_RSA_PAD_NO_SET_ERROR
* 3. CRYPT_SUCCESS
* 4. CRYPT_NULL_INPUT
* 5. CRYPT_RSA_ERR_ENC_BITS
* 6. CRYPT_RSA_BUFF_LEN_NOT_ENOUGH
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_ENC_API_TC001(Hex *n, Hex *e, int hashId, Hex *in, int isProvider)
{
uint8_t crypt[TMP_BUFF_LEN];
uint32_t cryptLen = TMP_BUFF_LEN;
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPub pubkey = {0};
BSL_Param oaepParam[3] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &hashId, sizeof(hashId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &hashId, sizeof(hashId), 0},
BSL_PARAM_END};
SetRsaPubKey(&pubkey, n->x, n->len, e->x, e->len);
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyEncrypt(pkey, in->x, in->len, crypt, &cryptLen), CRYPT_RSA_NO_KEY_INFO);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey, &pubkey) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, in->x, in->len, crypt, &cryptLen) == CRYPT_RSA_PAD_NO_SET_ERROR);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_RSAES_OAEP, oaepParam, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(NULL, in->x, in->len, crypt, &cryptLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, NULL, in->len, crypt, &cryptLen) == CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyEncrypt(pkey, in->x, 0, crypt, &cryptLen), CRYPT_SUCCESS);
// inLen > k-2hashLen-2 , 87 = (128 - 2 * 20 - 2)
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, in->x, 87, crypt, &cryptLen) == CRYPT_RSA_ERR_ENC_BITS);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, in->x, in->len, NULL, &cryptLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, in->x, in->len, crypt, NULL) == CRYPT_NULL_INPUT);
cryptLen = 0;
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, in->x, in->len, crypt, &cryptLen) == CRYPT_RSA_BUFF_LEN_NOT_ENOUGH);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_DEC_API_TC001
* @title RSA CRYPT_EAL_PkeyDecrypt: Test the validity of input parameters.
* @precon Create the context of the rsa algorithm:
* @brief
* 1. Call the CRYPT_EAL_PkeyDecrypt method without private key, expected result 1
* 2. Set private and call the CRYPT_EAL_PkeyDecrypt method, expected result 2
* 3. Set the oaep paading mode, expected result 3
* 4. Call the CRYPT_EAL_PkeyDecrypt method:
* (1) pkey = NULL, expected result 4
* (2) data = NULL, expected result 4
* (3) data != NULL, dataLen = 0, expected result 3
* (4) data != NULL, dataLen iis invalid , expected result 5
* (5) out = NULL, expected result 4
* (6) outLen = NULL, expected result 4
* (7) outLen = 0, expected result 6
* (8) outLen = 2049(invalid), expected result 6
* @expect
* 1. CRYPT_RSA_NO_KEY_INFO
* 2. CRYPT_RSA_PAD_NO_SET_ERROR
* 3. CRYPT_SUCCESS
* 4. CRYPT_NULL_INPUT
* 5. CRYPT_RSA_ERR_DEC_BITS
* 6. CRYPT_RSA_ERR_INPUT_VALUE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_DEC_API_TC001(Hex *n, Hex *d, int hashId, Hex *in, int isProvider)
{
uint8_t crypt[TMP_BUFF_LEN];
uint32_t cryptLen = TMP_BUFF_LEN;
CRYPT_EAL_PkeyPrv prvkey = {0};
CRYPT_EAL_PkeyCtx *pkey = NULL;
BSL_Param oaepParam[3] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &hashId, sizeof(hashId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &hashId, sizeof(hashId), 0},
BSL_PARAM_END};
SetRsaPrvKey(&prvkey, n->x, n->len, d->x, d->len);
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, in->x, in->len, crypt, &cryptLen) == CRYPT_RSA_NO_KEY_INFO);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey, &prvkey) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyDecrypt(pkey, in->x, in->len, crypt, &cryptLen), CRYPT_RSA_PAD_NO_SET_ERROR);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_RSAES_OAEP, oaepParam, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(NULL, in->x, in->len, crypt, &cryptLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, NULL, in->len, crypt, &cryptLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, in->x, 0, crypt, &cryptLen) == CRYPT_RSA_ERR_DEC_BITS);
const uint32_t invalidInLen = 1025; // 1025: invalid data length
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, in->x, invalidInLen, crypt, &cryptLen) == CRYPT_RSA_ERR_DEC_BITS);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, in->x, in->len, NULL, &cryptLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, in->x, in->len, crypt, NULL) == CRYPT_NULL_INPUT);
cryptLen = 0;
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, in->x, in->len, crypt, &cryptLen) == CRYPT_RSA_ERR_INPUT_VALUE);
cryptLen = 2049; // 2049 is an invalid data length.
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, in->x, in->len, crypt, &cryptLen) == CRYPT_RSA_ERR_INPUT_VALUE);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_CTRL_API_TC001
* @title Rsa CRYPT_EAL_PkeyCtrl test.
* @precon Create the context of the rsa algorithm and set the private key(n, d).
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_CTRL_API_TC001(Hex *n, Hex *d, Hex *salt, int hashId, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPrv prvkey = {0};
int32_t pssSaltLen = salt->len;
int32_t pssMdId = hashId;
int32_t pssMgfId = hashId;
BSL_Param pssParam[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &pssMdId, sizeof(pssMdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &pssMgfId, sizeof(pssMgfId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &pssSaltLen, sizeof(pssSaltLen), 0},
BSL_PARAM_END};
int32_t pkcsv15 = hashId;
uint8_t badSalt[2500];
(void)memset_s(badSalt, sizeof(badSalt), 'A', sizeof(badSalt));
const uint32_t badSaltLen = 2500; // 2500 is greater than the maximum length.
SetRsaPrvKey(&prvkey, n->x, n->len, d->x, d->len);
TestMemInit();
CRYPT_RandRegist(STUB_ReplaceRandom);
CRYPT_RandRegistEx(STUB_ReplaceRandomEx);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prvkey), CRYPT_SUCCESS);
// OAEP The parameter is a null pointer.
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_RSAES_OAEP, NULL, 0), CRYPT_NULL_INPUT);
// PKCS1.5 The parameter is a null pointer.
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_RSAES_PKCSV15, NULL, sizeof(pkcsv15)), CRYPT_NULL_INPUT);
// PKCS1.5 The parameter length is 0.
ASSERT_EQ(
CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_RSAES_PKCSV15, &pkcsv15, 0), CRYPT_RSA_SET_EMS_PKCSV15_LEN_ERROR);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PSS, NULL, 0), CRYPT_NULL_INPUT);
/* PSS saltLen: - 1 - 2 - 3 0 are valid values, -4 is invalid. */
pssSaltLen = -4;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PSS, pssParam, 0), CRYPT_RSA_ERR_SALT_LEN);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_SALT, salt->x, salt->len), CRYPT_RSA_SET_SALT_NOT_PSS_ERROR);
pssSaltLen = salt->len;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PSS, pssParam, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_SALT, badSalt, badSaltLen), CRYPT_RSA_ERR_SALT_LEN);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_SALT, salt->x, salt->len), CRYPT_SUCCESS);
int32_t pad = CRYPT_EMSA_PKCSV15;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_PADDING, NULL, sizeof(pad)), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_PADDING, &pad, 2), CRYPT_INVALID_ARG);
pad = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_PADDING, &pad, sizeof(pad)), CRYPT_INVALID_ARG);
pad = CRYPT_RSA_PADDINGMAX;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_PADDING, &pad, sizeof(pad)), CRYPT_INVALID_ARG);
pad = CRYPT_EMSA_PKCSV15;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_PADDING, &pad, sizeof(pad)), CRYPT_SUCCESS);
pad = CRYPT_RSA_NO_PAD;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_PADDING, &pad, sizeof(pad)), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_CTRL_API_TC002
* @title Rsa CRYPT_EAL_PkeyCtrl test.
* @precon Create the context of the rsa algorithm, set the private key(n, d) and set the padding type to pss.
* @brief
* 1. Call the CRYPT_EAL_PkeyCtrl method:
* (1) opt = CRYPT_CTRL_GET_RSA_PADDING, val is null, expected result 1
* (2) opt = CRYPT_CTRL_GET_RSA_PADDING, expected result 2
* (3) opt = CRYPT_CTRL_GET_RSA_MD, val is null, expected result 3
* (4) opt = CRYPT_CTRL_GET_RSA_MD, expected result 4
* (5) opt = CRYPT_CTRL_GET_RSA_MGF, val is null, expected result 5
* (6) opt = CRYPT_CTRL_GET_RSA_MGF, expected result 6
* (7) opt = CRYPT_CTRL_GET_RSA_SALT, val is null, expected result 7
* (8) opt = CRYPT_CTRL_GET_RSA_SALT, expected result 8
* (9) opt = CRYPT_CTRL_CLR_RSA_FLAG, val is null, expected result 9
* (10) opt = CRYPT_CTRL_CLR_RSA_FLAG, expected result 10
* @expect
* 1. CRYPT_NULL_INPUT
* 2. The return value is CRYPT_SUCCESS, and the output parameter(padType) value is pss.
* 3. CRYPT_NULL_INPUT
* 4. The return value is CRYPT_SUCCESS, and the output parameter(mdType) value is hashId.
* 5. CRYPT_NULL_INPUT
* 6. The return value is CRYPT_SUCCESS, and the output parameter(mgfId) value is hashId.
* 7. CRYPT_NULL_INPUT
* 8. The return value is CRYPT_SUCCESS, and the output parameter(saltLen) value is para.saltLen.
* 9. CRYPT_NULL_INPUT
* 10. CRYPT_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_CTRL_API_TC002(Hex *n, Hex *d, int hashId, int isProvider)
{
uint32_t flag = CRYPT_RSA_BLINDING;
CRYPT_EAL_PkeyPrv prvkey = {0};
int32_t pssSaltLen = 10;
int32_t pssMdId = hashId;
int32_t pssMgfId = hashId;
BSL_Param pssParam[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &pssMdId, sizeof(pssMdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &pssMgfId, sizeof(pssMgfId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &pssSaltLen, sizeof(pssSaltLen), 0},
BSL_PARAM_END};
CRYPT_EAL_PkeyCtx *pkey = NULL;
SetRsaPrvKey(&prvkey, n->x, n->len, d->x, d->len);
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prvkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PSS, pssParam, 0), CRYPT_SUCCESS);
RSA_PadType padType = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GET_RSA_PADDING, NULL, sizeof(RSA_PadType)), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GET_RSA_PADDING, &padType, sizeof(RSA_PadType)), CRYPT_SUCCESS);
ASSERT_EQ(padType, CRYPT_EMSA_PSS);
CRYPT_MD_AlgId mdType = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GET_RSA_MD, NULL, sizeof(CRYPT_MD_AlgId)), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GET_RSA_MD, &mdType, sizeof(CRYPT_MD_AlgId)), CRYPT_SUCCESS);
ASSERT_EQ(mdType, hashId);
CRYPT_MD_AlgId mgfId = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GET_RSA_MGF, NULL, sizeof(CRYPT_MD_AlgId)), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GET_RSA_MGF, &mgfId, sizeof(CRYPT_MD_AlgId)), CRYPT_SUCCESS);
ASSERT_EQ(mgfId, hashId);
int32_t saltLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GET_RSA_SALTLEN, NULL, sizeof(int32_t)), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GET_RSA_SALTLEN, &saltLen, sizeof(int32_t)), CRYPT_SUCCESS);
ASSERT_EQ(saltLen, pssSaltLen);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_CLR_RSA_FLAG, NULL, sizeof(uint32_t)) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_CLR_RSA_FLAG, (void *)&flag, sizeof(uint32_t)) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_CTRL_API_TC003
* @title Rsa CRYPT_EAL_PkeyCtrl test.
* @precon Create the context of the rsa algorithm, set the private key(n, d) and set the different saltLen to pss.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_CTRL_API_TC003(Hex *n, Hex *d, int isProvider)
{
CRYPT_EAL_PkeyPrv prvkey = {0};
int32_t pssSaltLen = CRYPT_RSA_SALTLEN_TYPE_HASHLEN;
int32_t pssMdId = CRYPT_MD_SHA256;
int32_t pssMgfId = CRYPT_MD_SHA256;
int32_t saltLen = 0;
BSL_Param pssParam[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &pssMdId, sizeof(pssMdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &pssMgfId, sizeof(pssMgfId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &pssSaltLen, sizeof(pssSaltLen), 0},
BSL_PARAM_END};
CRYPT_EAL_PkeyCtx *pkey = NULL;
SetRsaPrvKey(&prvkey, n->x, n->len, d->x, d->len);
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prvkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PSS, pssParam, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GET_RSA_SALTLEN, &saltLen, sizeof(int32_t)), CRYPT_SUCCESS);
ASSERT_EQ(saltLen, 32); // saltLen = MdSize(32)
pssSaltLen = CRYPT_RSA_SALTLEN_TYPE_MAXLEN;
pssParam[2].value = &pssSaltLen; // salt-len index = 2
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PSS, pssParam, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GET_RSA_SALTLEN, &saltLen, sizeof(int32_t)), CRYPT_SUCCESS);
ASSERT_EQ(saltLen, CRYPT_EAL_PkeyGetKeyLen(pkey) - 32 - 2); // saltLen = keyBytes - MdSize(32) - 2
pssSaltLen = CRYPT_RSA_SALTLEN_TYPE_AUTOLEN;
pssParam[2].value = &pssSaltLen; // salt-len index = 2
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PSS, pssParam, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GET_RSA_SALTLEN, &saltLen, sizeof(int32_t)), CRYPT_SUCCESS);
ASSERT_EQ(saltLen, CRYPT_EAL_PkeyGetKeyLen(pkey) - 32 - 2); // saltLen = keyBytes - MdSize(32) - 2
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
int Compare_PubKey(CRYPT_EAL_PkeyPub *pubKey1, CRYPT_EAL_PkeyPub *pubKey2)
{
if (pubKey1->key.rsaPub.nLen != pubKey2->key.rsaPub.nLen || pubKey1->key.rsaPub.eLen != pubKey2->key.rsaPub.eLen) {
return -1; // -1 indicates failure
}
if (memcmp(pubKey1->key.rsaPub.n, pubKey2->key.rsaPub.n, pubKey1->key.rsaPub.nLen) != 0 ||
memcmp(pubKey1->key.rsaPub.e, pubKey2->key.rsaPub.e, pubKey1->key.rsaPub.eLen) != 0) {
return -1; // -1 indicates failure
}
return 0;
}
int Compare_PrvKey(CRYPT_EAL_PkeyPrv *prvKey1, CRYPT_EAL_PkeyPrv *prvKey2)
{
if (prvKey1->key.rsaPrv.dLen != prvKey2->key.rsaPrv.dLen || prvKey1->key.rsaPrv.nLen != prvKey2->key.rsaPrv.nLen ||
prvKey1->key.rsaPrv.pLen != prvKey2->key.rsaPrv.pLen || prvKey1->key.rsaPrv.qLen != prvKey2->key.rsaPrv.qLen) {
return -1; // -1 indicates failure
}
if (memcmp(prvKey1->key.rsaPrv.d, prvKey2->key.rsaPrv.d, prvKey1->key.rsaPrv.dLen) != 0 ||
memcmp(prvKey1->key.rsaPrv.n, prvKey2->key.rsaPrv.n, prvKey1->key.rsaPrv.nLen) != 0 ||
memcmp(prvKey1->key.rsaPrv.p, prvKey2->key.rsaPrv.p, prvKey1->key.rsaPrv.pLen) != 0 ||
memcmp(prvKey1->key.rsaPrv.q, prvKey2->key.rsaPrv.q, prvKey1->key.rsaPrv.qLen) != 0) {
return -1; // -1 indicates failure
}
return 0;
}
/**
* @test SDV_CRYPTO_RSA_SET_KEY_API_TC001
* @title Rsa: Set the public key and private key multiple times.
* @precon Create the contexts of the rsa algorithm and:
* pkey1: Set paran and generate a key pair: test obtaining the key.
* pkey2: Test set keys, and verify that the public and private keys can exist at the same time.
* @brief
* 1. pkey1: Get public key and get private key, expected result 1
* 2. pkey2:
* (1) Set public key and set private key, expected result 1
* (2) Get public key, get private key and check private key, expected result 2
* (3) Set private key and set public key, expected result 3
* (4) Get private key, get public key and check public key, expected result 4
* @expect
* 1. CRYPT_SUCCESS
* 2. The obtained private key is equal to the set private key.
* 3. CRYPT_SUCCESS
* 4. The obtained public key is equal to the set public key.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_SET_KEY_API_TC001(int isProvider)
{
uint8_t e[] = {1, 0, 1};
uint8_t pubE[600];
uint8_t pubN[600];
uint8_t prvD[600];
uint8_t prvN[600];
uint8_t prvP[600];
uint8_t prvQ[600];
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPub pubKey = {0};
CRYPT_EAL_PkeyPrv prvKey = {0};
SetRsaPubKey(&pubKey, pubE, 600, pubN, 600); // 600 bytes > 1024 bits
SetRsaPrvKey(&prvKey, prvN, 600, prvD, 600);
prvKey.key.rsaPrv.p = prvP;
prvKey.key.rsaPrv.pLen = 600;
prvKey.key.rsaPrv.q = prvQ;
prvKey.key.rsaPrv.qLen = 600;
SetRsaPara(¶, e, 3, 1024);
TestMemInit();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
CRYPT_EAL_PkeyCtx *pkey1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default",
isProvider);
CRYPT_EAL_PkeyCtx *pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default",
isProvider);
ASSERT_TRUE(pkey1 != NULL && pkey2 != NULL);
/* pkey1 */
/* Generate a key pair. */
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey1, ¶) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey1), CRYPT_SUCCESS);
/* Get keys. */
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey1, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey1, &prvKey), CRYPT_SUCCESS);
/* pkey2 */
/* Set public key and set private key. */
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey2, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey2, &prvKey), CRYPT_SUCCESS);
/* Get public key, get private key and check private key.*/
SetRsaPubKey(&pubKey, pubE, 600, pubN, 600);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey2, &pubKey), CRYPT_SUCCESS);
SetRsaPrvKey(&prvKey, prvN, 600, prvD, 600);
prvKey.key.rsaPrv.p = prvP;
prvKey.key.rsaPrv.pLen = 600;
prvKey.key.rsaPrv.q = prvQ;
prvKey.key.rsaPrv.qLen = 600;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey2, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(Compare_PrvKey(&prvKey, &prvKey), 0);
/* Set private key and set public key. */
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey2, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey2, &pubKey), CRYPT_SUCCESS);
/* Get private key, get public key and check public key.*/
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey2, &prvKey), CRYPT_SUCCESS);
SetRsaPubKey(&pubKey, pubE, 600, pubN, 600);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey2, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(Compare_PubKey(&pubKey, &pubKey), 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_DUP_CTX_API_TC001
* @title RSA CRYPT_EAL_PkeyDupCtx test.
* @precon Create the contexts of the rsa algorithm, set para and generate a key pair.
* @brief
* 1. Call the CRYPT_EAL_PkeyDupCtx mehod to dup rsa, expected result 1
* @expect
* 1. Success.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_DUP_CTX_API_TC001(Hex *e, int bits, int isProvider)
{
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyCtx *newPkey = NULL;
CRYPT_EAL_PkeyCtx *pkey = NULL;
SetRsaPara(¶, e->x, e->len, bits);
TestMemInit();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), 0);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
CRYPT_RSA_Ctx *rsaCtx = (CRYPT_RSA_Ctx *)pkey->key;
ASSERT_TRUE(rsaCtx != NULL);
newPkey = CRYPT_EAL_PkeyDupCtx(pkey);
ASSERT_TRUE(newPkey != NULL);
ASSERT_EQ(newPkey->references.count, 1);
CRYPT_RSA_Ctx *rsaCtx2 = (CRYPT_RSA_Ctx *)newPkey->key;
ASSERT_TRUE(rsaCtx2 != NULL);
ASSERT_COMPARE("rsa compare n",
rsaCtx->prvKey->n->data,
rsaCtx->prvKey->n->size * sizeof(BN_UINT),
rsaCtx2->prvKey->n->data,
rsaCtx2->prvKey->n->size * sizeof(BN_UINT));
ASSERT_COMPARE("rsa compare d",
rsaCtx->prvKey->d->data,
rsaCtx->prvKey->d->size * sizeof(BN_UINT),
rsaCtx2->prvKey->d->data,
rsaCtx2->prvKey->d->size * sizeof(BN_UINT));
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(newPkey);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_CMP_API_TC001
* @title RSA: CRYPT_EAL_PkeyCmp invalid parameter test.
* @precon para id and public key.
* @brief
* 1. Create the contexts(ctx1, ctx2) of the rsa algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 2
* 3. Set public key for ctx1, expected result 3
* 4. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 4
* 5. Set different public key for ctx2, expected result 5
* 6. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 6
* @expect
* 1. Success, and contexts are not NULL.
* 2. CRYPT_RSA_NO_KEY_INFO
* 3. CRYPT_SUCCESS
* 4. CRYPT_RSA_NO_KEY_INFO
* 5. CRYPT_SUCCESS
* 6. CRYPT_RSA_PUBKEY_NOT_EQUAL
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_CMP_API_TC001(Hex *n, Hex *e, int isProvider)
{
uint8_t tmpE[] = {1, 0, 1};
CRYPT_EAL_PkeyPub pub = {0};
SetRsaPubKey(&pub, n->x, n->len, e->x, e->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default",
isProvider);
CRYPT_EAL_PkeyCtx *ctx2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default",
isProvider);
ASSERT_TRUE(ctx1 != NULL && ctx2 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_RSA_NO_KEY_INFO); // no key
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx1, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_RSA_NO_KEY_INFO); // ctx2 no pubkey
SetRsaPubKey(&pub, n->x, n->len, tmpE, 3);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx2, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_RSA_PUBKEY_NOT_EQUAL);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_GET_SECURITY_BITS_FUNC_TC001
* @title RSA CRYPT_EAL_PkeyGetSecurityBits test.
* @precon nan
* @brief
* 1. Create the context of the rsa algorithm, expected result 1
* 2. Set public key, expected result 2
* 3. Call the CRYPT_EAL_PkeyVerify method and the parameter is correct, expected result 3
* @expect
* 1. Success, and the context is not null.
* 2. CRYPT_SUCCESS
* 3. The return value is not 0.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_GET_SECURITY_BITS_FUNC_TC001(Hex *n, Hex *e, int securityBits, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPub pub = {0};
SetRsaPubKey(&pub, n->x, n->len, e->x, e->len);
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetSecurityBits(pkey), securityBits);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
#define RSA_TEST_REFERENCE_COUNT 10000
static void *RsaTestAtomic(void *arg)
{
CRYPT_EAL_PkeyCtx *pkey = (CRYPT_EAL_PkeyCtx *)arg;
int ref = 0;
for (int i = 0; i < RSA_TEST_REFERENCE_COUNT; i++) {
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_UP_REFERENCES, &ref, sizeof(int)), CRYPT_SUCCESS);
CRYPT_RSA_Ctx *ctx = (CRYPT_RSA_Ctx *)pkey->key;
ASSERT_EQ(CRYPT_RSA_GetBits(ctx), 2048); // RSA2048
CRYPT_RSA_FreeCtx(ctx);
}
EXIT:
return NULL;
}
static int32_t pthreadRWLockNew(BSL_SAL_ThreadLockHandle *lock)
{
pthread_rwlock_t *newLock;
newLock = (pthread_rwlock_t *)BSL_SAL_Malloc(sizeof(pthread_rwlock_t));
if (newLock == NULL) {
return BSL_MALLOC_FAIL;
}
if (pthread_rwlock_init(newLock, NULL) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
*lock = newLock;
return BSL_SUCCESS;
}
static void pthreadRWLockFree(BSL_SAL_ThreadLockHandle lock)
{
pthread_rwlock_destroy((pthread_rwlock_t *)lock);
BSL_SAL_FREE(lock);
}
static int32_t pthreadRWLockReadLock(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
if (pthread_rwlock_rdlock((pthread_rwlock_t *)lock) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
return BSL_SUCCESS;
}
static int32_t pthreadRWLockWriteLock(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
if (pthread_rwlock_wrlock((pthread_rwlock_t *)lock) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
return BSL_SUCCESS;
}
static int32_t pthreadRWLockUnlock(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
if (pthread_rwlock_unlock((pthread_rwlock_t *)lock) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
return BSL_SUCCESS;
}
static uint64_t pthreadGetId(void)
{
return (uint64_t)pthread_self();
}
/**
* @test SDV_CRYPTO_RSA_REFERENCES_API_TC001
* @title Multi-threaded reference counting test.
* @precon Create the context of the rsa algorithm, set the private key(n, d).
* @brief
* 1. Create multiple threads to use ctx at the same time.
* 2. Check whether the CTX is finally released.
* @expect
* 1. The reference counting is as expected.
* 2. The memory is released successfully, and no memory leakage occurs.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_REFERENCES_API_TC001(Hex *n, Hex *d, int isProvider)
{
BSL_ERR_Init();
pthread_t pid1;
pthread_t pid2;
CRYPT_EAL_PkeyPrv prvkey = {0};
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyCtx *pkey1 = NULL;
CRYPT_EAL_PkeyCtx *pkey2 = NULL;
SetRsaPrvKey(&prvkey, n->x, n->len, d->x, d->len);
TestMemInit();
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_NEW_CB_FUNC, pthreadRWLockNew) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_FREE_CB_FUNC, pthreadRWLockFree) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_READ_LOCK_CB_FUNC, pthreadRWLockReadLock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_WRITE_LOCK_CB_FUNC, pthreadRWLockWriteLock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_UNLOCK_CB_FUNC, pthreadRWLockUnlock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_GET_ID_CB_FUNC, pthreadGetId) == BSL_SUCCESS);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(pkey->references.count, 1);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey, &prvkey) == CRYPT_SUCCESS);
pkey1 = pkey;
ASSERT_TRUE(CRYPT_EAL_PkeyUpRef(pkey1) == CRYPT_SUCCESS);
pkey2 = pkey;
ASSERT_TRUE(CRYPT_EAL_PkeyUpRef(pkey2) == CRYPT_SUCCESS);
ASSERT_EQ(pkey->references.count, 3); // The pkey is referenced three times.
pthread_create(&pid1, NULL, RsaTestAtomic, (void *)pkey1);
pthread_create(&pid2, NULL, RsaTestAtomic, (void *)pkey2);
pthread_join(pid1, NULL); // Wait for all child threads to end.
pthread_join(pid2, NULL);
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
ASSERT_EQ(pkey->references.count, 1);
CRYPT_RSA_Ctx *ctx = (CRYPT_RSA_Ctx *)pkey->key;
ASSERT_EQ(ctx->references.count, 1);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_GET_KEY_BITS_FUNC_TC001
* @title RSA: get key bits.
* @brief
* 1. Create a context of the RSA algorithm, expected result 1
* 2. Get key bits, expected result 2
* @expect
* 1. Success, and context is not NULL.
* 2. Equal to keyBits.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_GET_KEY_BITS_FUNC_TC001(int id, int keyBits, int isProvider)
{
uint8_t e3[] = {1, 0, 1};
CRYPT_EAL_PkeyPara para = {0};
para.id = id;
para.para.rsaPara.e = e3;
para.para.rsaPara.eLen = 3; // 3 is valid.
para.para.rsaPara.bits = 1024; // 1024 is valid.
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, id, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE_AND_LOG("1k key", CRYPT_EAL_PkeySetPara(pkey, ¶) == 0);
ASSERT_TRUE(CRYPT_EAL_PkeyGetKeyBits(pkey) == (uint32_t)keyBits);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
static int32_t STUB_Gcd(BN_BigNum *r, const BN_BigNum *a, const BN_BigNum *b, BN_Optimizer *opt)
{
(void)a;
(void)b;
(void)opt;
BN_BigNum *val = BN_Create(1);
val->data[0] = 2;
val->sign = false;
BN_Copy(r, val);
BN_Destroy(val);
return CRYPT_SUCCESS;
}
/**
* @test SDV_CRYPTO_RSA_NOR_KEYGEN_FAIL_TC001
* @title RSA: Normal Key Generation Failure Test
* @brief
* 1. Create a context of the RSA algorithm, expected result 1
* 2. Generate a key pair, expected result 2
* @expect
* 1. CRYPT_SUCCESS
* 2. CRYPT_RSA_NOR_KEYGEN_FAIL
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_NOR_KEYGEN_FAIL_TC001(int isProvider)
{
uint8_t e[] = {1, 0, 1};
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyCtx *pkey = NULL;
TestMemInit();
STUB_Init();
FuncStubInfo tmpRpInfo = {0};
SetRsaPara(¶, e, 3, 1024);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_SUCCESS);
STUB_Replace(&tmpRpInfo, BN_Gcd, STUB_Gcd);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_RSA_NOR_KEYGEN_FAIL);
STUB_Reset(&tmpRpInfo);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
STUB_Reset(&tmpRpInfo);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_SEED_KEYGEN_TC001
* @title RSA: Deterministic Seed Key Generation Test
* @precon Two RSA key generation contexts with the same seed value
* @brief
* 1. Create two RSA key pairs using the seed.
* 2. Compare if the two key pairs are identical.
* 3. Compare if the p and q of the two key pairs meet expectations.
* @expect
* 1. CRYPT_SUCCESS
* 2. The two key pairs are identical.
* 3. The p and q of the two key pairs meet expectations.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_SEED_KEYGEN_TC001(Hex *xp, Hex *xp1, Hex *xp2, Hex *xq, Hex *xq1, Hex *xq2,
Hex *p, Hex *q, int isProvider)
{
#ifdef HITLS_CRYPTO_ACVP_TESTS
TestMemInit();
uint8_t e[] = {1, 0, 1};
uint32_t bits = 1024;
uint8_t prvD1[600];
uint8_t prvN1[600];
uint8_t prvP1[600];
uint8_t prvQ1[600];
uint8_t prvD2[600];
uint8_t prvN2[600];
uint8_t prvP2[600];
uint8_t prvQ2[600];
// Initialize two key contexts
CRYPT_EAL_PkeyCtx *pkey1 = NULL;
CRYPT_EAL_PkeyCtx *pkey2 = NULL;
// Initialize two identical parameter structures
BSL_Param param[] = {
{CRYPT_PARAM_RSA_E, BSL_PARAM_TYPE_OCTETS, e, 3, 0},
{CRYPT_PARAM_RSA_BITS, BSL_PARAM_TYPE_UINT32, &bits, sizeof(bits), 0},
{CRYPT_PARAM_RSA_XP, BSL_PARAM_TYPE_OCTETS, xp->x, xp->len, 0},
{CRYPT_PARAM_RSA_XP1, BSL_PARAM_TYPE_OCTETS, xp1->x, xp1->len, 0},
{CRYPT_PARAM_RSA_XP2, BSL_PARAM_TYPE_OCTETS, xp2->x, xp2->len, 0},
{CRYPT_PARAM_RSA_XQ, BSL_PARAM_TYPE_OCTETS, xq->x, xq->len, 0},
{CRYPT_PARAM_RSA_XQ1, BSL_PARAM_TYPE_OCTETS, xq1->x, xq1->len, 0},
{CRYPT_PARAM_RSA_XQ2, BSL_PARAM_TYPE_OCTETS, xq2->x, xq2->len, 0},
BSL_PARAM_END
};
// Create the first context and generate the key
pkey1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey1 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetParaEx(pkey1, param), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey1), CRYPT_SUCCESS);
// Create the second context and generate the key
pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey2 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetParaEx(pkey2, param), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey2), CRYPT_SUCCESS);
// Get private keys
CRYPT_EAL_PkeyPrv prvKey1 = {0};
CRYPT_EAL_PkeyPrv prvKey2 = {0};
SetRsaPrvKey(&prvKey1, prvN1, sizeof(prvN1), prvD1, sizeof(prvD1));
SetRsaPrvKey(&prvKey2, prvN2, sizeof(prvN2), prvD2, sizeof(prvD2));
prvKey1.key.rsaPrv.p = prvP1;
prvKey1.key.rsaPrv.pLen = sizeof(prvP1);
prvKey1.key.rsaPrv.q = prvQ1;
prvKey1.key.rsaPrv.qLen = sizeof(prvQ1);
prvKey2.key.rsaPrv.p = prvP2;
prvKey2.key.rsaPrv.pLen = sizeof(prvP2);
prvKey2.key.rsaPrv.q = prvQ2;
prvKey2.key.rsaPrv.qLen = sizeof(prvQ2);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey1, &prvKey1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey2, &prvKey2), CRYPT_SUCCESS);
// Verify if the two keys are identical
ASSERT_EQ(Compare_PrvKey(&prvKey1, &prvKey2), 0);
// Verify if p and q are as expected
ASSERT_EQ(memcmp(prvKey1.key.rsaPrv.p, p->x, p->len), 0);
ASSERT_EQ(memcmp(prvKey1.key.rsaPrv.q, q->x, q->len), 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
#else
(void)xp;
(void)xp1;
(void)xp2;
(void)xq;
(void)xq1;
(void)xq2;
(void)p;
(void)q;
(void)isProvider;
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_CHECK_KEYPAIR_INVALID_TC001
* @brief
* invalid input test and no p, q check
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_CHECK_KEYPAIR_INVALID_TC001(Hex *n, Hex *d, int isProvider)
{
#if !defined(HITLS_CRYPTO_RSA_CHECK)
(void)n;
(void)d;
(void)isProvider;
SKIP_TEST();
#else
uint8_t e[] = {1, 0, 1};
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_EAL_PkeyPub pubKey = {0};
CRYPT_EAL_PkeyPrv prvKey = {0};
CRYPT_EAL_PkeyCtx *pkey1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE,
"provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pkey1 != NULL);
ASSERT_TRUE(pkey2 != NULL);
SetRsaPrvKey(&prvKey, n->x, n->len, d->x, d->len);
SetRsaPubKey(&pubKey, n->x, n->len, e, 3);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(NULL, pkey1), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pkey1, NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey1, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey2, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pkey2, pkey2), CRYPT_RSA_ERR_NO_PUBKEY_INFO);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pkey1, pkey1), CRYPT_RSA_ERR_NO_PRVKEY_INFO);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pkey1, pkey2), CRYPT_RSA_KEYPAIRWISE_CONSISTENCY_FAILURE); // recover p q failed.
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
TestRandDeInit();
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_CHECK_KEYPAIR_TC001
* @brief
* Create a RSA key pairs to check the key pair consistency and prv key, check crt param.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_CHECK_KEYPAIR_TC001(int bits, int isProvider)
{
#if !defined(HITLS_CRYPTO_RSA_CHECK)
(void)bits;
(void)isProvider;
SKIP_TEST();
#else
uint8_t e[] = {1, 0, 1};
CRYPT_EAL_PkeyPara para = {0};
SetRsaPara(¶, e, 3, bits); // Valid parameters: elen = 3
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS); // check ctr
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pkey, pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
TestRandDeInit();
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_CHECK_KEYPAIR_TC002
* @brief
* check p, q mode in rsa key pair. including right vector and wrong vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_CHECK_KEYPAIR_TC002(Hex *p, Hex *q, Hex *n, Hex *d, int isProvider, int expect)
{
#if !defined(HITLS_CRYPTO_RSA_CHECK)
(void)p;
(void)q;
(void)n;
(void)d;
(void)isProvider;
(void)expect;
SKIP_TEST();
#else
TestMemInit();
uint8_t e[] = {1, 0, 1};
CRYPT_EAL_PkeyPub pubKey = {0};
CRYPT_EAL_PkeyPrv prvKey = {0};
int expectRet = expect == 0 ? CRYPT_SUCCESS : CRYPT_RSA_KEYPAIRWISE_CONSISTENCY_FAILURE;
CRYPT_EAL_PkeyCtx *pkey1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE,
"provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pkey1 != NULL);
ASSERT_TRUE(pkey2 != NULL);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
SetRsaPrvKey(&prvKey, n->x, n->len, d->x, d->len);
prvKey.key.rsaPrv.p = p->x;
prvKey.key.rsaPrv.pLen = p->len;
prvKey.key.rsaPrv.q = q->x;
prvKey.key.rsaPrv.qLen = q->len;
SetRsaPubKey(&pubKey, n->x, n->len, e, 3);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey1, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey2, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pkey1, pkey2), expectRet);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey2), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
TestRandDeInit();
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_CHECK_KEYPAIR_TC003
* @brief
* Create a RSA key pairs to check the key pair consistency and prv key, check recover p q.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_CHECK_KEYPAIR_TC003(int bits, int isProvider)
{
#if !defined(HITLS_CRYPTO_RSA_CHECK)
(void)bits;
(void)isProvider;
SKIP_TEST();
#else
uint8_t e[] = {1, 0, 1};
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPub pubKey = {0};
CRYPT_EAL_PkeyPrv prvKey = {0};
SetRsaPara(¶, e, 3, bits); // Valid parameters: elen = 3
TestMemInit();
uint8_t pubE[600];
uint8_t pubN[600];
uint8_t pubD[600];
SetRsaPubKey(&pubKey, pubN, 600, pubE, 600);
SetRsaPrvKey(&prvKey, pubN, 600, pubD, 600);
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE,
"provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pubCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE,
"provider=default", isProvider);
CRYPT_EAL_PkeyCtx *prvCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(pubCtx != NULL);
ASSERT_TRUE(prvCtx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubCtx, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(pubCtx);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
TestRandDeInit();
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_CHECK_KEYPAIR_TC004
* @title RSA: Deterministic Seed Key Generation Test
* @precon Two RSA key generation contexts with the same seed value
* @brief
* 1. Create two RSA key pairs using the seed.
* 2. Compare if the two key pairs are identical.
* 3. Compare if the p and q of the two key pairs meet expectations.
* @expect
* 1. CRYPT_SUCCESS
* 2. The two key pairs are identical.
* 3. The p and q of the two key pairs meet expectations.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_CHECK_KEYPAIR_TC004(int bits, int isProvider)
{
#if !defined(HITLS_CRYPTO_RSA_CHECK)
(void)bits;
(void)isProvider;
SKIP_TEST();
#else
TestMemInit();
CRYPT_EAL_PkeyPub pubKey = {0};
CRYPT_EAL_PkeyPrv prvKey = {0};
CRYPT_EAL_PkeyPara para = {0};
uint8_t e[] = {1, 0, 1};
uint8_t prvD[600];
uint8_t prvP[600];
uint8_t prvQ[600];
uint8_t prvN[600];
uint8_t prvDp[600];
uint8_t prvDq[600];
uint8_t prvQInv[600];
uint8_t wrong[600] = {1};
SetRsaPara(¶, e, 3, bits); // Valid parameters: elen = 3
prvKey.id = CRYPT_PKEY_RSA;
pubKey.id = CRYPT_PKEY_RSA;
prvKey.key.rsaPrv.p = prvP;
prvKey.key.rsaPrv.pLen = sizeof(prvP);
prvKey.key.rsaPrv.q = prvQ;
prvKey.key.rsaPrv.qLen = sizeof(prvQ);
prvKey.key.rsaPrv.d = prvD;
prvKey.key.rsaPrv.dLen = sizeof(prvD);
prvKey.key.rsaPrv.n = prvN;
prvKey.key.rsaPrv.nLen = sizeof(prvN);
prvKey.key.rsaPrv.dQ = prvDq;
prvKey.key.rsaPrv.dQLen = sizeof(prvDq);
prvKey.key.rsaPrv.dP = prvDp;
prvKey.key.rsaPrv.dPLen = sizeof(prvDp);
prvKey.key.rsaPrv.e = e;
prvKey.key.rsaPrv.eLen = sizeof(e);
prvKey.key.rsaPrv.qInv = prvQInv;
prvKey.key.rsaPrv.qInvLen = sizeof(prvQInv);
pubKey.key.rsaPub.e = e;
pubKey.key.rsaPub.eLen = sizeof(e);
pubKey.key.rsaPub.n = prvN;
pubKey.key.rsaPub.nLen = sizeof(prvN);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE,
"provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pubCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE,
"provider=default", isProvider);
CRYPT_EAL_PkeyCtx *prvCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(pubCtx != NULL);
ASSERT_TRUE(prvCtx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubCtx, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(prvCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_SUCCESS);
prvKey.key.rsaPrv.dQ = wrong;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_RSA_KEYPAIRWISE_CONSISTENCY_FAILURE);
prvKey.key.rsaPrv.dQ = prvDq;
prvKey.key.rsaPrv.dP = wrong;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_RSA_KEYPAIRWISE_CONSISTENCY_FAILURE);
prvKey.key.rsaPrv.dP = prvDp;
prvKey.key.rsaPrv.qInv = wrong;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_RSA_KEYPAIRWISE_CONSISTENCY_FAILURE);
prvKey.key.rsaPrv.qInv = prvQInv;
prvKey.key.rsaPrv.d = wrong;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_RSA_KEYPAIRWISE_CONSISTENCY_FAILURE);
prvKey.key.rsaPrv.d = prvD;
prvKey.key.rsaPrv.p = wrong;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_RSA_KEYPAIRWISE_CONSISTENCY_FAILURE);
prvKey.key.rsaPrv.p = prvP;
prvKey.key.rsaPrv.q = wrong;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_RSA_KEYPAIRWISE_CONSISTENCY_FAILURE);
prvKey.key.rsaPrv.q = prvQ;
prvKey.key.rsaPrv.e = wrong;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_RSA_KEYPAIRWISE_CONSISTENCY_FAILURE);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(pubCtx);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
TestRandDeInit();
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_CHECK_PRV_TC001
* @brief
* Create a RSA key pairs to check the prv key.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_CHECK_PRV_TC001(int bits, int isProvider)
{
#if !defined(HITLS_CRYPTO_RSA_CHECK)
(void)bits;
(void)isProvider;
SKIP_TEST();
#else
uint8_t e[] = {1, 0, 1};
CRYPT_EAL_PkeyPara para = {0};
BN_BigNum *n = NULL;
BN_BigNum *d = NULL;
CRYPT_RSA_Ctx *ctx = NULL;
BN_BigNum *zero = BN_Create(0);
SetRsaPara(¶, e, 3, bits);
TestMemInit();
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPara(pkey, ¶) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_RSA_ERR_NO_PRVKEY_INFO);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SUCCESS);
ctx = (CRYPT_RSA_Ctx *)pkey->key;
n = ctx->prvKey->n;
d = ctx->prvKey->d;
ctx->prvKey->n = NULL;
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_RSA_ERR_NO_PRVKEY_INFO);
ctx->prvKey->n = zero;
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_RSA_ERR_INVALID_PRVKEY);
ctx->prvKey->n = n;
ctx->prvKey->d = ctx->prvKey->n;
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_RSA_ERR_INVALID_PRVKEY);
ctx->prvKey->d = d;
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
BN_Destroy(zero);
TestRandDeInit();
#endif
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/rsa/test_suite_sdv_eal_rsa_api.c | C | unknown | 73,400 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* INCLUDE_BASE test_suite_sdv_eal_rsa */
/* BEGIN_HEADER */
#include <stdint.h>
#include "bsl_params.h"
#include "crypt_params_key.h"
/* END_HEADER */
#define CRYPT_EAL_PKEY_KEYMGMT_OPERATE 0
static bool NeedPadSkip(int padMode)
{
switch (padMode) {
#ifdef HITLS_CRYPTO_RSAES_OAEP
case CRYPT_CTRL_SET_RSA_RSAES_OAEP:
return false;
#endif
#ifdef HITLS_CRYPTO_RSAES_PKCSV15
case CRYPT_CTRL_SET_RSA_RSAES_PKCSV15:
return false;
#endif
#ifdef HITLS_CRYPTO_RSAES_PKCSV15_TLS
case CRYPT_CTRL_SET_RSA_RSAES_PKCSV15_TLS:
return false;
#endif
#ifdef HITLS_CRYPTO_RSA_NO_PAD
case CRYPT_CTRL_SET_RSA_PADDING:
return false;
#endif
default:
return true;
}
}
/**
* @test SDV_CRYPTO_RSA_CRYPT_FUNC_TC001
* @title RSA: public key encryption and private key
* @precon Vectors: a rsa key pair.
* @brief
* 1. Create the context(pkey) of the rsa algorithm, expected result 1
* 2. Initialize the DRBG.
* 3. Set private key and padding mode, expected result 2
* 4. Call the CRYPT_EAL_PkeyDecrypt to decrypt ciphertext, expected result 3
* 5. Compare the decrypted output with the expected output, expected result 4
* 6. Set public key and padding mode, expected result 5
* 7. Call the CRYPT_EAL_PkeyEncrypt to encrypt plaintext, expected result 6
* 8. Check the length of output data, expected result 7
* 9. Call the CRYPT_EAL_PkeyDecrypt to decrypt the output data of step 6, expected result 8
* 10. Compare the output data of step 8 with the output data of step 6, expected result 9
* @expect
* 1. Success, and context is not NULL.
* 2-3. CRYPT_SUCCESS
* 4. Both are the same.
* 5-6. CRYPT_SUCCESS
* 7. It is equal to ciphertext->len.
* 8. CRYPT_SUCCESS
* 9. Both are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_CRYPT_FUNC_TC001(
int keyLen, int padMode, int hashId, Hex *n, Hex *e, Hex *d, Hex *plaintext, Hex *ciphertext, int isProvider)
{
if (NeedPadSkip(padMode) || IsMdAlgDisabled(hashId)) {
SKIP_TEST();
}
int paraSize;
void *paraPtr;
CRYPT_EAL_PkeyPrv prvkey = {0};
CRYPT_EAL_PkeyPub pubkey = {0};
CRYPT_EAL_PkeyCtx *pkey = NULL;
BSL_Param oaepParam[3] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &hashId, sizeof(hashId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &hashId, sizeof(hashId), 0},
BSL_PARAM_END};
int32_t pkcsv15 = hashId;
#ifdef HITLS_CRYPTO_RSA_DECRYPT
uint8_t pt[MAX_CIPHERTEXT_LEN] = {0};
uint32_t ptLen = MAX_CIPHERTEXT_LEN;
#endif
#ifdef HITLS_CRYPTO_RSA_ENCRYPT
uint8_t ct[MAX_CIPHERTEXT_LEN] = {0};
uint32_t ctLen = MAX_CIPHERTEXT_LEN;
#endif
int32_t noPad = CRYPT_RSA_NO_PAD;
SetRsaPrvKey(&prvkey, n->x, n->len, d->x, d->len);
SetRsaPubKey(&pubkey, n->x, n->len, e->x, e->len);
if (padMode == CRYPT_CTRL_SET_RSA_RSAES_OAEP) {
paraSize = 0;
paraPtr = oaepParam;
} else if (padMode == CRYPT_CTRL_SET_RSA_RSAES_PKCSV15) {
paraSize = sizeof(pkcsv15);
paraPtr = &pkcsv15;
} else if (padMode == CRYPT_CTRL_SET_RSA_PADDING) {
paraSize = sizeof(noPad);
paraPtr = &noPad;
}
ASSERT_TRUE(ciphertext->len == KEYLEN_IN_BYTES((uint32_t)keyLen));
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
#ifdef HITLS_CRYPTO_DRBG
if (padMode != CRYPT_CTRL_SET_RSA_PADDING) {
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
}
#endif
#ifdef HITLS_CRYPTO_RSA_DECRYPT
/* HiTLS private key decrypts the data. */
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prvkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, padMode, paraPtr, paraSize), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyDecrypt(pkey, ciphertext->x, ciphertext->len, pt, &ptLen), CRYPT_SUCCESS);
ASSERT_EQ(ptLen, plaintext->len);
ASSERT_EQ(memcmp(pt, plaintext->x, ptLen), 0);
#endif
#ifdef HITLS_CRYPTO_RSA_ENCRYPT
/* HiTLS public key encrypt */
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pubkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, padMode, paraPtr, paraSize), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyEncrypt(pkey, plaintext->x, plaintext->len, ct, &ctLen), CRYPT_SUCCESS);
ASSERT_EQ(ctLen, ciphertext->len);
#endif
#if defined(HITLS_CRYPTO_RSA_DECRYPT) && defined(HITLS_CRYPTO_RSA_ENCRYPT)
/* HiTLS private key decrypt */
ASSERT_EQ(CRYPT_EAL_PkeyDecrypt(pkey, ct, ctLen, pt, &ptLen), CRYPT_SUCCESS);
ASSERT_EQ(ptLen, plaintext->len);
ASSERT_EQ(memcmp(pt, plaintext->x, ptLen), 0);
#endif
EXIT:
#ifdef HITLS_CRYPTO_DRBG
CRYPT_EAL_RandDeinit();
#endif
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_CRYPT_FUNC_TC002
* @title RSA EAL abnormal test: The encryption and decryption padding modes do not match.
* @precon Vectors: a rsa key pair, plaintext
* @brief
* 1. Create the context(pkey) of the rsa algorithm, expected result 1
* 2. Initialize the DRBG.
* 3. Set public key, and set padding mode to OAEP, expected result 2
* 4. Call the CRYPT_EAL_PkeyEncrypt to encrypt plaintext, expected result 3
* 5. Set private key, and set padding mode to PKCSV15, expected result 4
* 6. Call the CRYPT_EAL_PkeyDecrypt to decrypt the output of step 4, expected result 5
* 7. Set private key, and set padding mode to OAEP, expected result 6
* 8. Call the CRYPT_EAL_PkeyDecrypt to decrypt the output of step 4, expected result 7
* 9. Compare the output data of step 8 with plaintext, expected result 8
* @expect
* 1. Success, and context is not NULL.
* 2-4. CRYPT_SUCCESS
* 5. CRYPT_RSA_NOR_VERIFY_FAIL
* 6-7. CRYPT_SUCCESS
* 8. Both are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_CRYPT_FUNC_TC002(Hex *n, Hex *e, Hex *d, Hex *plaintext, int isProvider)
{
TestMemInit();
uint8_t ct[MAX_CIPHERTEXT_LEN] = {0};
uint8_t pt[MAX_CIPHERTEXT_LEN] = {0};
uint32_t msgLen = MAX_CIPHERTEXT_LEN;
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyPrv prvkey = {0};
CRYPT_EAL_PkeyPub pubkey = {0};
int32_t hashId = CRYPT_MD_SHA1;
BSL_Param oaepParam[3] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &hashId, sizeof(hashId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &hashId, sizeof(hashId), 0},
BSL_PARAM_END};
int32_t pkcsv15 = CRYPT_MD_SHA1;
SetRsaPrvKey(&prvkey, n->x, n->len, d->x, d->len);
SetRsaPubKey(&pubkey, n->x, n->len, e->x, e->len);
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
#ifdef HITLS_CRYPTO_DRBG
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
#endif
/* HiTLS public key encrypt: OAEP */
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey, &pubkey) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_RSAES_OAEP, oaepParam, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, plaintext->x, plaintext->len, ct, &msgLen) == CRYPT_SUCCESS);
/* HiTLS private key encrypt: PKCSV15 */
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey, &prvkey) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_RSAES_PKCSV15, &pkcsv15, sizeof(pkcsv15)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, ct, msgLen, pt, &msgLen) == CRYPT_RSA_NOR_VERIFY_FAIL);
/* HiTLS private key encrypt: OAEP */
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_RSAES_OAEP, oaepParam, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, ct, msgLen, pt, &msgLen) == CRYPT_SUCCESS);
ASSERT_TRUE(msgLen == plaintext->len);
ASSERT_TRUE(memcmp(pt, plaintext->x, msgLen) == 0);
EXIT:
#ifdef HITLS_CRYPTO_DRBG
CRYPT_EAL_RandDeinit();
#endif
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_CRYPT_FUNC_TC003
* @title RSA: Label test for OAP encryption and decryption
* @precon Vectors: a rsa key pair, plaintext and label.
* @brief
* 1. Create the context(pkey) of the rsa algorithm, expected result 1
* 2. Initialize the DRBG.
* 3. Set public key and private key, expected result 2
* 4. Set padding type to OAEP and set oaep-label, expected result 3
* 5. Call the CRYPT_EAL_PkeyEncrypt to encrypt plaintext, expected result 4
* 6. Call the CRYPT_EAL_PkeyDecrypt to decrypt the output of step 6, expected result 5
* 7. Compare the output data of step 6 with plaintext, expected result 6
* 8. Call the CRYPT_EAL_PkeyCopyCtx to copy pkey, expected result 7
* 9. Call the CRYPT_EAL_PkeyEncrypt to encrypt plaintext, expected result 8
* 10. Call the CRYPT_EAL_PkeyDecrypt to decrypt the output of step 8, expected result 9
* @expect
* 1. Success, and context is not NULL.
* 2-5. CRYPT_SUCCESS
* 6. Both are the same.
* 7-9. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_CRYPT_FUNC_TC003(Hex *n, Hex *e, Hex *d, Hex *plaintext, Hex *label, int isProvider)
{
#if !defined(HITLS_CRYPTO_SHA2) || !defined(HITLS_CRYPTO_RSA_ENCRYPT) || !defined(HITLS_CRYPTO_RSA_DECRYPT) || \
!defined(HITLS_CRYPTO_RSAES_OAEP)
SKIP_TEST();
#endif
uint8_t ct[MAX_CIPHERTEXT_LEN] = {0};
uint8_t pt[MAX_CIPHERTEXT_LEN] = {0};
uint32_t msgLen = MAX_CIPHERTEXT_LEN;
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyCtx *cpyCtx = NULL;
CRYPT_EAL_PkeyPrv prvkey = {0};
CRYPT_EAL_PkeyPub pubkey = {0};
int32_t hashId = CRYPT_MD_SHA256;
BSL_Param oaepParam[3] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &hashId, sizeof(hashId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &hashId, sizeof(hashId), 0},
BSL_PARAM_END};
SetRsaPubKey(&pubkey, n->x, n->len, e->x, e->len);
SetRsaPrvKey(&prvkey, n->x, n->len, d->x, d->len);
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
#ifdef HITLS_CRYPTO_DRBG
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
#endif
/* HiTLS pubenc, prvdec */
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(pkey, &pubkey) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(pkey, &prvkey) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_RSAES_OAEP, oaepParam, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_OAEP_LABEL, label->x, label->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyEncrypt(pkey, plaintext->x, plaintext->len, ct, &msgLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyDecrypt(pkey, ct, msgLen, pt, &msgLen), CRYPT_SUCCESS);
ASSERT_TRUE(msgLen == plaintext->len);
ASSERT_TRUE(memcmp(pt, plaintext->x, msgLen) == 0);
/* HiTLS copy ctx, pubenc, prvdec */
cpyCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(cpyCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCopyCtx(cpyCtx, pkey), CRYPT_SUCCESS);
msgLen = MAX_CIPHERTEXT_LEN;
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(cpyCtx, plaintext->x, plaintext->len, ct, &msgLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(cpyCtx, ct, msgLen, pt, &msgLen) == CRYPT_SUCCESS);
EXIT:
#ifdef HITLS_CRYPTO_DRBG
CRYPT_EAL_RandDeinit();
#endif
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(cpyCtx);
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/rsa/test_suite_sdv_eal_rsa_encrypt_decrypt.c | C | unknown | 12,277 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* INCLUDE_BASE test_suite_sdv_eal_rsa */
/* BEGIN_HEADER */
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include "bsl_errno.h"
#include "crypt_eal_md.h"
#include "bsl_params.h"
#include "crypt_params_key.h"
#include "crypt_bn.h"
/* END_HEADER */
#define CRYPT_EAL_PKEY_KEYMGMT_OPERATE 0
int MD_Data(CRYPT_MD_AlgId mdId, Hex *msgIn, Hex *mdOut)
{
uint32_t outLen;
CRYPT_EAL_MdCTX *mdCtx = NULL;
uint32_t mdOutLen = CRYPT_EAL_MdGetDigestSize(mdId);
ASSERT_TRUE(mdOutLen != 0);
mdOut->x = (uint8_t *)malloc(mdOutLen);
ASSERT_TRUE(mdOut->x != NULL);
mdOut->len = mdOutLen;
outLen = mdOutLen;
mdCtx = CRYPT_EAL_MdNewCtx(mdId);
ASSERT_TRUE_AND_LOG("CRYPT_EAL_MdNewCtx", mdCtx != NULL);
ASSERT_TRUE_AND_LOG("CRYPT_EAL_MdInit", CRYPT_EAL_MdInit(mdCtx) == 0);
ASSERT_TRUE_AND_LOG("CRYPT_EAL_MdUpdate", CRYPT_EAL_MdUpdate(mdCtx, msgIn->x, msgIn->len) == 0);
ASSERT_TRUE_AND_LOG("CRYPT_EAL_MdFinal", CRYPT_EAL_MdFinal(mdCtx, mdOut->x, &outLen) == 0);
mdOut->len = outLen;
CRYPT_EAL_MdFreeCtx(mdCtx);
return SUCCESS;
EXIT:
CRYPT_EAL_MdFreeCtx(mdCtx);
free(mdOut->x);
mdOut->x = NULL;
return FAIL;
}
/**
* @test SDV_CRYPTO_RSA_SIGN_API_TC001
* @title RSA CRYPT_EAL_PkeySign: Wrong parameters.
* @precon Create the context of the rsa algorithm, set private key and set padding type to pkcsv15:
* @brief
* 1. Call the CRYPT_EAL_PkeySetPrv method:
* (1) pkey = null, expected result 1.
* (2) data = null, dataLen = 0, expected result 2.
* (3) data = null, dataLen != 0, expected result 3.
* (4) data != null, dataLen = 0, expected result 4.
* (5) sign = null, signLen != 0, expected result 5.
* (6) sign != null, signLen = 0, expected result 6.
* (7) sign != null, signLen == NULL, expected result 7.
* 2. Call the CRYPT_EAL_PkeySetPrv method with incorrect hash id, expected result 8:
* CRYPT_MD_MD5, CRYPT_MD_SHA1, CRYPT_MD_SM3, CRYPT_MD_MAX
* @expect
* 1. CRYPT_NULL_INPUT
* 2. CRYPT_SUCCESS
* 3. CRYPT_NULL_INPUT
* 4. CRYPT_SUCCESS
* 5. CRYPT_NULL_INPUT
* 6. CRYPT_RSA_BUFF_LEN_NOT_ENOUGH
* 7. CRYPT_NULL_INPUT
* 8. Return CRYPT_RSA_ERR_ALGID or CRYPT_EAL_ERR_ALGID
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_SIGN_API_TC001(Hex *n, Hex *d, int isProvider)
{
int32_t ret;
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
CRYPT_EAL_PkeyPrv privaKey = {0};
uint8_t *data = NULL;
uint8_t *sign = NULL;
uint32_t signLen = d->len + 1;
uint32_t dataLen = signLen;
int32_t pkcsv15 = CRYPT_MD_SHA224;
CRYPT_MD_AlgId errIdList[] = {CRYPT_MD_MD5, CRYPT_MD_SHA1, CRYPT_MD_SM3, CRYPT_MD_MAX};
/* Malloc signature buffer */
sign = (uint8_t *)malloc(signLen);
data = (uint8_t *)malloc(signLen);
ASSERT_TRUE(sign != NULL && data != NULL);
SetRsaPrvKey(&privaKey, n->x, n->len, d->x, d->len);
TestMemInit();
pkeyCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkeyCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkeyCtx, &privaKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySign(NULL, CRYPT_MD_SHA224, data, dataLen, sign, &signLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, CRYPT_MD_SHA224, NULL, 0, sign, &signLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, CRYPT_MD_SHA224, NULL, dataLen, sign, &signLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, CRYPT_MD_SHA224, data, 0, sign, &signLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, CRYPT_MD_SHA224, data, dataLen, NULL, &signLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, CRYPT_MD_SHA224, data, dataLen, sign, NULL), CRYPT_NULL_INPUT);
signLen = 0;
ASSERT_EQ(
CRYPT_EAL_PkeySign(pkeyCtx, CRYPT_MD_SHA224, data, dataLen, sign, &signLen), CRYPT_RSA_BUFF_LEN_NOT_ENOUGH);
signLen = dataLen;
for (int i = 0; i < (int)(sizeof(errIdList) / sizeof(CRYPT_MD_AlgId)); i++) {
ret = CRYPT_EAL_PkeySign(pkeyCtx, errIdList[i], data, dataLen, sign, &signLen);
ASSERT_TRUE(ret == CRYPT_RSA_ERR_ALGID || ret == CRYPT_EAL_ERR_ALGID);
}
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
free(data);
free(sign);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_SIGN_PKCSV15_FUNC_TC001
* @title RSA EAL layer signature function test: PKCSV15, sha224
* @precon nan
* @brief
* 1. Create the context(pkeyCtx) of the rsa algorithm, expected result 1
* 2. Set the private key for pkeyCtx, expected result 2
* 3. Set the padding algorithm to PKCS15 and set the hash value to SHA224, expected result 3
* 4. Call the CRYPT_EAL_PkeySign method with invalid mdId, expected result 4
* 5. Call the CRYPT_EAL_PkeySign method to compute signature, expected result 5
* @expect
* 1. Success, and context is not NULL.
* 2-3. CRYPT_SUCCESS
* 4. CRYPT_EAL_ERR_ALGID
* 5. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_SIGN_PKCSV15_FUNC_TC001(Hex *n, Hex *d, Hex *msg, Hex *sign, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
CRYPT_EAL_PkeyPrv privaKey = {0};
uint8_t *signdata = NULL;
uint32_t signLen = sign->len;
int32_t pkcsv15 = CRYPT_MD_SHA224;
/* Malloc signature buffer */
signdata = (uint8_t *)malloc(signLen);
ASSERT_TRUE(signdata != NULL);
SetRsaPrvKey(&privaKey, n->x, n->len, d->x, d->len);
TestMemInit();
pkeyCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkeyCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkeyCtx, &privaKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, CRYPT_MD_SHA224, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
free(signdata);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_SIGN_PKCSV15_FUNC_TC002
* @title RSA EAL layer signature function test: PKCSV15
* @precon nan
* @brief
* 1. Create the context(pkeyCtx) of the rsa algorithm, expected result 1
* 2. Set the private key for pkeyCtx, expected result 2
* 3. Set the padding algorithm to PKCS15 and set the hash value to SHA2, expected result 3
* 4. Call the CRYPT_EAL_PkeySign method to compute signature, expected result 4
* 5. Compare the signature result and the signature vector., expected result 5
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_SUCCESS
* 4. CRYPT_SUCCESS
* 5. Both are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_SIGN_PKCSV15_FUNC_TC002(int mdId, Hex *n, Hex *d, Hex *msg, Hex *sign, int isProvider)
{
#if !defined(HITLS_CRYPTO_RSA_SIGN) || !defined(HITLS_CRYPTO_RSA_EMSA_PKCSV15)
SKIP_TEST();
#endif
if (IsMdAlgDisabled(mdId)) {
SKIP_TEST();
}
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
CRYPT_EAL_PkeyPrv privaKey = {0};
int32_t pkcsv15 = mdId;
uint8_t *signdata = NULL;
uint32_t signLen;
SetRsaPrvKey(&privaKey, n->x, n->len, d->x, d->len);
TestMemInit();
pkeyCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkeyCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkeyCtx, &privaKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)), 0);
/* Malloc signature buffer */
signLen = CRYPT_EAL_PkeyGetSignLen(pkeyCtx);
ASSERT_EQ(signLen, sign->len);
signdata = (uint8_t *)malloc(signLen);
ASSERT_TRUE(signdata != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, mdId, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);
ASSERT_COMPARE("CRYPT_EAL_PkeySign Compare", sign->x, sign->len, signdata, signLen);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
free(signdata);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_SIGN_PSS_FUNC_TC001
* @title RSA EAL layer signature function test: Pss
* @precon nan
* @brief
* 1. Create the context(pkeyCtx) of the rsa algorithm, expected result 1
* 2. Set the private key for pkeyCtx, expected result 2
* 3. Set the padding algorithm to PKCS15 and set the hash value to SHA2, expected result 3
* 4. Call the CRYPT_EAL_PkeySign method to compute signature, expected result 4
* 5. Compare the signature result and the signature vector., expected result 5
* @expect
* 1. Success, and context is not NULL.
* 2-4. CRYPT_SUCCESS
* 5. Both are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_SIGN_PSS_FUNC_TC001(int mdId, Hex *n, Hex *d, Hex *msg, Hex *sign, Hex *salt, int isProvider)
{
#if !defined(HITLS_CRYPTO_RSA_SIGN) || !defined(HITLS_CRYPTO_RSA_EMSA_PSS)
SKIP_TEST();
#endif
if (IsMdAlgDisabled(mdId)) {
SKIP_TEST();
}
int i;
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
CRYPT_EAL_PkeyPrv privaKey = {0};
BSL_Param pssParam[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &salt->len, sizeof(salt->len), 0},
BSL_PARAM_END};
uint8_t *signdata = NULL;
uint32_t signLen = sign->len;
SetRsaPrvKey(&privaKey, n->x, n->len, d->x, d->len);
/* Malloc signature buffer */
signdata = (uint8_t *)malloc(signLen);
ASSERT_TRUE(signdata != NULL);
TestMemInit();
pkeyCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkeyCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkeyCtx, &privaKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PSS, pssParam, 0), CRYPT_SUCCESS);
/* Repeat signature 2 times. */
for (i = 0; i < 2; i++) {
if (salt->len != 0) {
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_SALT, salt->x, salt->len), CRYPT_SUCCESS);
}
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, mdId, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);
ASSERT_COMPARE("Compare Sign Data", signdata, signLen, sign->x, sign->len);
signLen = sign->len;
}
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
free(signdata);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_SIGN_PSS_FUNC_TC002
* @title RSA EAL layer signature function test: Pss with different salt lengths.
* @precon nan
* @brief
* 1. Create the context(pkeyCtx) of the rsa algorithm, expected result 1
* 2. Initialize the DRBG, expected result 2
* 3. Set the private key for pkeyCtx, expected result 3
* 4. Set the padding algorithm to PSS and set the hash value to SHA2, expected result 4
* 5. Call the CRYPT_EAL_PkeySign method to compute signature, expected result 5
* @expect
* 1. Success, and context is not NULL.
* 2-5. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_SIGN_PSS_FUNC_TC002(int mdId, Hex *n, Hex *d, Hex *msg, int saltLen, int isProvider)
{
#if !defined(HITLS_CRYPTO_RSA_SIGN) || !defined(HITLS_CRYPTO_RSA_EMSA_PSS) || !defined(HITLS_CRYPTO_DRBG)
SKIP_TEST();
#endif
if (IsMdAlgDisabled(mdId)) {
SKIP_TEST();
}
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
CRYPT_EAL_PkeyPrv privaKey = {0};
uint8_t *signdata = NULL;
uint32_t signLen;
BSL_Param pssParam[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &saltLen, sizeof(saltLen), 0},
BSL_PARAM_END};
SetRsaPrvKey(&privaKey, n->x, n->len, d->x, d->len);
TestMemInit();
pkeyCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkeyCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkeyCtx, &privaKey), CRYPT_SUCCESS);
#ifdef HITLS_CRYPTO_DRBG
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
#endif
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PSS, pssParam, 0), CRYPT_SUCCESS);
/* Malloc signature buffer */
signLen = CRYPT_EAL_PkeyGetSignLen(pkeyCtx);
ASSERT_TRUE(signLen != 0);
signdata = (uint8_t *)malloc(signLen);
ASSERT_TRUE(signdata != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, mdId, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);
EXIT:
#ifdef HITLS_CRYPTO_DRBG
TestRandDeInit();
#endif
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
free(signdata);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_SIGN_PSS_FUNC_TC003
* @title RSA EAL layer signature function test: Do not set the salt length of PSS.
* @precon Vectors: private key, msg.
* @brief
* 1. Create the context(pkeyCtx) of the rsa algorithm, expected result 1
* 2. Set the private key for pkeyCtx, expected result 2
* 3. Initialize the DRBG, expected result 3
* 4. Set the padding algorithm to PSS, saltLen is 0 | -1 | -2, expected result 4
* 5. Call the CRYPT_EAL_PkeySign method to compute signature, expected result 5
* @expect
* 1. Success, and context is not NULL.
* 2-4. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_SIGN_PSS_FUNC_TC003(Hex *n, Hex *d, Hex *msg, int saltLen, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
CRYPT_EAL_PkeyPrv privaKey = {0};
uint8_t *signdata = NULL;
uint32_t signLen;
int32_t mdId = CRYPT_MD_SHA224;
BSL_Param pssParam[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &saltLen, sizeof(saltLen), 0},
BSL_PARAM_END};
SetRsaPrvKey(&privaKey, n->x, n->len, d->x, d->len);
TestMemInit();
pkeyCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkeyCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkeyCtx, &privaKey), CRYPT_SUCCESS);
#ifdef HITLS_CRYPTO_DRBG
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
#endif
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PSS, pssParam, 0), CRYPT_SUCCESS);
/* Malloc signature buffer */
signLen = CRYPT_EAL_PkeyGetSignLen(pkeyCtx);
ASSERT_TRUE(signLen != 0);
signdata = (uint8_t *)malloc(signLen);
ASSERT_TRUE(signdata != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyCtx, CRYPT_MD_SHA224, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);
EXIT:
#ifdef HITLS_CRYPTO_DRBG
TestRandDeInit();
#endif
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
free(signdata);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_GEN_SIGN_VERIFY_PKCSV15_FUNC_TC001
* @title RSA EAL sign/verify and signData/verifyData:PKCSV15, sha256
* @precon
* @brief
* 1. Create the context(pkeyCtx) of the rsa algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeySetPara, where bits are: 1024/2048/4096, expected result 2
* 3. Initialize the DRBG, expected result 3
* 4. Call the CRYPT_EAL_PkeyGen to generate a key pair, expected result 4
* 5. Call the CRYPT_EAL_PkeyGen to generate a key pair again, expected result 5
* 6. Set padding type to pkcsv15, expected result 6
* 7. Call the CRYPT_EAL_PkeySign method and use pkey to sign a piece of data, expected result 7
* 8. Call the CRYPT_EAL_PkeyVerify method and use pkey to verify the signed data, expected result 8
* 9. Call the CRYPT_EAL_PkeySignData method and use pkey to sign a piece of hash data, expected result 9
* 10. Call the CRYPT_EAL_PkeyVerifyData method and use pkey to verify the signed data, expected result 10
* 11. Allocate the memory for the CRYPT_EAL_PkeyCtx, named cpyCtx, expected result 11
* 12. Call the CRYPT_EAL_PkeyCopyCtx to copy pkeyCtx, expected result 12
* 13. Call the CRYPT_EAL_PkeySignData method and use cpyCtx to sign a piece of data, expected result 13
* 14. Call the CRYPT_EAL_PkeyVerifyData method and use cpyCtx to verify the signed data, expected result 14
* @expect
* 1. Success, and context is not NULL.
* 2-10. CRYPT_SUCCESS
* 11. Success.
* 12-14. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_GEN_SIGN_VERIFY_PKCSV15_FUNC_TC001(int bits, int isProvider)
{
#ifndef HITLS_CRYPTO_SHA256
SKIP_TEST();
#endif
uint32_t signLen = (bits + 7) >> 3; // keybytes == (keyBits + 7) >> 3 */
int mdId = CRYPT_MD_SHA256;
uint8_t data[500] = {0};
const uint32_t dataLen = sizeof(data);
uint8_t hash[32]; // SHA256 digest length: 32
const uint32_t hashLen = sizeof(hash);
uint8_t e[] = {1, 0, 1};
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyCtx *cpyCtx = NULL;
int32_t pkcsv15 = mdId;
CRYPT_EAL_PkeyPara para = {0};
SetRsaPara(¶, e, 3, bits);
uint8_t *sign = malloc(signLen);
ASSERT_TRUE_AND_LOG("Malloc Sign Buffer", sign != NULL);
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_SUCCESS);
#ifdef HITLS_CRYPTO_DRBG
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
#endif
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, mdId, data, dataLen, sign, &signLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, mdId, data, dataLen, sign, signLen), CRYPT_SUCCESS);
signLen = (bits + 7) >> 3; // keybytes == (keyBits + 7) >> 3 */
memset_s(hash, sizeof(hash), 'A', sizeof(hash));
ASSERT_EQ(CRYPT_EAL_PkeySignData(pkey, hash, hashLen, sign, &signLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerifyData(pkey, hash, hashLen, sign, signLen), CRYPT_SUCCESS);
cpyCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(cpyCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCopyCtx(cpyCtx, pkey), CRYPT_SUCCESS);
signLen = (bits + 7) >> 3;
ASSERT_EQ(CRYPT_EAL_PkeySign(cpyCtx, mdId, data, dataLen, sign, &signLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(cpyCtx, mdId, data, dataLen, sign, signLen), CRYPT_SUCCESS);
EXIT:
#ifdef HITLS_CRYPTO_DRBG
TestRandDeInit();
#endif
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(cpyCtx);
free(sign);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_GEN_SIGN_VERIFY_PSS_FUNC_TC001
* @title RSA EAL signData/verifyData: pss, sha256, saltLen=32bytes
* @precon
* @brief
* 1. Create the context(pkeyCtx) of the rsa algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeySetPara, where bits is 1025, expected result 2
* 3. Initialize the DRBG, expected result 3
* 4. Call the CRYPT_EAL_PkeyGen to generate a key pair, expected result 4
* 5. Set padding type to pkcsv15 and set salt(32 bytes), expected result 5
* 6. Call the CRYPT_EAL_PkeySignData method and use pkey to sign a piece of data, expected result 6
* 7. Call the CRYPT_EAL_PkeyVerifyData method and use pkey to verify the signed data, expected result 7
* 8. Allocate the memory for the CRYPT_EAL_PkeyCtx, named cpyCtx, expected result 8
* 9. Call the CRYPT_EAL_PkeyCopyCtx to copy pkeyCtx, expected result 9
* 10. Call the CRYPT_EAL_PkeySignData method and use cpyCtx to sign a piece of data, expected result 10
* 11. Call the CRYPT_EAL_PkeyVerifyData method and use cpyCtx to verify the signed data, expected result 11
* @expect
* 1. Success, and context is not NULL.
* 2-7. CRYPT_SUCCESS
* 8. Success.
* 9-11. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_GEN_SIGN_VERIFY_PSS_FUNC_TC001(int bits, int isProvider)
{
#ifndef HITLS_CRYPTO_SHA256
SKIP_TEST();
#endif
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyCtx *cpyCtx = NULL;
int32_t mdId = CRYPT_MD_SHA256;
int32_t saltLen = 32;
BSL_Param pssParam[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &saltLen, sizeof(saltLen), 0},
BSL_PARAM_END};
CRYPT_EAL_PkeyPara para = {0};
uint8_t e[] = {1, 0, 1};
uint8_t salt[100];
uint32_t signLen = (bits + 7) >> 3; // keybytes == (keyBits + 7) >> 3 */
uint8_t hash[32]; // SHA256 digest length 32
const uint32_t hashLen = sizeof(hash);
memset_s(hash, sizeof(hash), 'A', sizeof(hash));
(void)memset_s(salt, sizeof(salt), 'A', sizeof(salt));
uint8_t *sign = malloc(signLen);
ASSERT_TRUE(sign != NULL);
SetRsaPara(¶, e, 3, bits);
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_SUCCESS);
#ifdef HITLS_CRYPTO_DRBG
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
#endif
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("Malloc Sign Buffer", sign != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PSS, pssParam, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_SALT, (uint8_t *)salt, 32), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySignData(pkey, hash, hashLen, sign, &signLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerifyData(pkey, hash, hashLen, sign, signLen), CRYPT_SUCCESS);
cpyCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(cpyCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCopyCtx(cpyCtx, pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(cpyCtx, CRYPT_CTRL_SET_RSA_SALT, (uint8_t *)salt, 32), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySignData(cpyCtx, hash, hashLen, sign, &signLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerifyData(cpyCtx, hash, hashLen, sign, signLen), CRYPT_SUCCESS);
EXIT:
#ifdef HITLS_CRYPTO_DRBG
TestRandDeInit();
#endif
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(cpyCtx);
free(sign);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_GEN_SIGN_VERIFY_PKCSV15_FUNC_TC002
* @title RSA EAL sign/verify:Generate a key pair, set pubKey, PKCSV15, sha256
* @precon
* @brief
* 1. Create the contexts(pkey, pkey2) of the rsa algorithm, expected result 1
* 2. Set para for pkey and pkey2, expected result 2
* 3. Initialize the DRBG, expected result 3
* 4. Call the CRYPT_EAL_PkeyGen to generate a key pair, expected result 4
* 5. Get public key from pkey, expected result 5
* 6. Set public key for pkey2, expected result 6
* 7. Set padding type to pkcsv15 for pkey and pkey2, expected result 7
* 8. Call the CRYPT_EAL_PkeySign method and use pkey to sign a piece of data, expected result8
* 9. Call the CRYPT_EAL_PkeyVerify method and use pkey2 to verify the signed data, expected result 9
* @expect
* 1. Success, and context is not NULL.
* 2-9. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_GEN_SIGN_VERIFY_PKCSV15_FUNC_TC002(int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyCtx *pkey2 = NULL;
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPub pubKey = {0};
int32_t pkcsv15 = CRYPT_MD_SHA256;
uint8_t pubN[600];
uint8_t pubE[600];
uint8_t e[] = {1, 0, 1};
uint8_t sign[200];
uint32_t signLen = 200; // 200bytes is greater than 1024 bits.
uint8_t data[500] = {0};
const uint32_t dataLen = 500;
SetRsaPara(¶, e, 3, 1024);
SetRsaPubKey(&pubKey, pubN, 600, pubE, 600);
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL && pkey2 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey2, ¶), CRYPT_SUCCESS);
#ifdef HITLS_CRYPTO_DRBG
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
#endif
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey2, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey2, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SHA256, data, dataLen, sign, &signLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey2, CRYPT_MD_SHA256, data, dataLen, sign, signLen), CRYPT_SUCCESS);
EXIT:
#ifdef HITLS_CRYPTO_DRBG
TestRandDeInit();
#endif
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(pkey2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_GEN_SIGN_VERIFY_PKCSV15_FUNC_TC003
* @title RSA EAL sign/verify:Generate a key pair, set prvKey, PKCSV15, sha256
* @precon
* @brief
* 1. Create the contexts(pkey, pkey2) of the rsa algorithm, expected result 1
* 2. Set para for pkey and pkey2, expected result 2
* 3. Initialize the DRBG, expected result 3
* 4. Call the CRYPT_EAL_PkeyGen to generate a key pair, expected result 4
* 5. Get private key from pkey, expected result 5
* 6. Set private key for pkey2, expected result 6
* 7. Set padding type to pkcsv15 for pkey and pkey2, expected result 7
* 8. Call the CRYPT_EAL_PkeySign method and use pkey2 to sign a piece of data, expected result8
* 9. Call the CRYPT_EAL_PkeyVerify method and use pkey to verify the signed data, expected result 9
* @expect
* 1. Success, and context is not NULL.
* 2-9. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_GEN_SIGN_VERIFY_PKCSV15_FUNC_TC003(int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyCtx *pkey2 = NULL;
CRYPT_EAL_PkeyPara para = {0};
CRYPT_EAL_PkeyPrv prvKey = {0};
int32_t pkcsv15 = CRYPT_MD_SHA256;
uint8_t prvD[600];
uint8_t prvN[600];
uint8_t prvP[600];
uint8_t prvQ[600];
uint8_t e[] = {1, 0, 1};
uint8_t sign[600];
uint32_t signLen = 600; // 600bytes > 1024bits
uint8_t data[500] = {0};
uint32_t dataLen = sizeof(data);
SetRsaPara(¶, e, 3, 1024);
prvKey.id = CRYPT_PKEY_RSA;
prvKey.key.rsaPrv.d = prvD;
prvKey.key.rsaPrv.dLen = 600; // 600bytes > 1024bits
prvKey.key.rsaPrv.n = prvN;
prvKey.key.rsaPrv.nLen = 600; // 600bytes > 1024bits
prvKey.key.rsaPrv.p = prvP;
prvKey.key.rsaPrv.pLen = 600; // 600bytes > 1024bits
prvKey.key.rsaPrv.q = prvQ;
prvKey.key.rsaPrv.qLen = 600; // 600bytes > 1024bits
prvKey.key.rsaPrv.dP = NULL;
prvKey.key.rsaPrv.dPLen = 0;
prvKey.key.rsaPrv.dQ = NULL;
prvKey.key.rsaPrv.dQLen = 0;
prvKey.key.rsaPrv.qInv = NULL;
prvKey.key.rsaPrv.qInvLen = 0;
TestMemInit();
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
pkey2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL && pkey2 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey2, ¶), CRYPT_SUCCESS);
#ifdef HITLS_CRYPTO_DRBG
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
#endif
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey2, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey2, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkey2, CRYPT_MD_SHA256, data, dataLen, sign, &signLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA256, data, dataLen, sign, signLen), CRYPT_SUCCESS);
EXIT:
#ifdef HITLS_CRYPTO_DRBG
TestRandDeInit();
#endif
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(pkey2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_VERIFY_PKCSV15_FUNC_TC001
* @title Rsa verify-PKCS15
* @precon
* @brief
* 1. Create the context(pkeyCtx) of the rsa algorithm, expected result 1
* 2. Set public key for pkeyCtx, expected result 2
* 3. Set padding type to pkcsv15 for pkeyCtx, expected result 3
* 4. Call the CRYPT_EAL_PkeyVerify method and use pkeyCtx to verify the signed data, expected result 4
* 5. Calculate the hash value of msg, expected result 5
* 6. Call the CRYPT_EAL_PkeyVerifyData method and use pkeyCtx to verify the signed data, expected result 6
* @expect
* 1. Success, and context is not NULL.
* 2-3. CRYPT_SUCCESS
* 4. Reutrn CRYPT_SUCCESS when expect is 0, otherwise return CRYPT_RSA_NOR_VERIFY_FAIL.
* 5. SUCCESS
* 6. Reutrn CRYPT_SUCCESS when expect is 0, otherwise return CRYPT_RSA_NOR_VERIFY_FAIL.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_VERIFY_PKCSV15_FUNC_TC001(
int mdAlgId, Hex *n, Hex *e, Hex *msg, Hex *sign, int expect, int isProvider)
{
#if !defined(HITLS_CRYPTO_RSA_VERIFY) || !defined(HITLS_CRYPTO_RSA_EMSA_PKCSV15)
SKIP_TEST();
#endif
if (IsMdAlgDisabled(mdAlgId)) {
SKIP_TEST();
}
int ret;
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
CRYPT_EAL_PkeyPub publicKey = {0};
int32_t pkcsv15 = mdAlgId;
Hex mdOut = {0};
TestMemInit();
pkeyCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkeyCtx != NULL);
/* Set the public key.*/
SetRsaPubKey(&publicKey, n->x, n->len, e->x, e->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkeyCtx, &publicKey), CRYPT_SUCCESS);
/* Set padding. */
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)), CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyVerify(pkeyCtx, mdAlgId, msg->x, msg->len, sign->x, sign->len);
if (expect == SUCCESS) {
ASSERT_EQ(ret, CRYPT_SUCCESS);
} else {
ASSERT_EQ(ret, CRYPT_RSA_NOR_VERIFY_FAIL);
}
ASSERT_TRUE(MD_Data(mdAlgId, msg, &mdOut) == SUCCESS);
ret = CRYPT_EAL_PkeyVerifyData(pkeyCtx, mdOut.x, mdOut.len, sign->x, sign->len);
if (expect == SUCCESS) {
ASSERT_EQ(ret, CRYPT_SUCCESS);
} else {
ASSERT_EQ(ret, CRYPT_RSA_NOR_VERIFY_FAIL);
}
ret = CRYPT_EAL_PkeyVerifyData(NULL, mdOut.x, mdOut.len, sign->x, sign->len);
ASSERT_TRUE_AND_LOG("CRYPT_EAL_PkeyVerifyData", ret != CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
free(mdOut.x);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_VERIFY_PSS_FUNC_TC001
* @title Rsa verify-PSS
* @precon
* @brief
* 1. Create the context(pkeyCtx) of the rsa algorithm, expected result 1
* 2. Set public key for pkeyCtx, expected result 2
* 3. Set padding type to PSS for pkeyCtx, expected result 3
* 4. Call the CRYPT_EAL_PkeyVerify method and use pkeyCtx to verify the signed data, expected result 4
* 5. Calculate the hash value of msg, expected result 5
* 6. Call the CRYPT_EAL_PkeyVerifyData method and use pkeyCtx to verify the signed data, expected result 6
* @expect
* 1. Success, and context is not NULL.
* 2-3. CRYPT_SUCCESS
* 4. Reutrn CRYPT_SUCCESS when expect is 0, otherwise return CRYPT_RSA_NOR_VERIFY_FAIL.
* 5. SUCCESS
* 6. Reutrn CRYPT_SUCCESS when expect is 0, otherwise return CRYPT_RSA_NOR_VERIFY_FAIL.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_VERIFY_PSS_FUNC_TC001(
int mdAlgId, Hex *n, Hex *e, Hex *salt, Hex *msg, Hex *sign, int expect, int isProvider)
{
#if !defined(HITLS_CRYPTO_RSA_VERIFY) || !defined(HITLS_CRYPTO_RSA_EMSA_PSS)
SKIP_TEST();
#endif
if (IsMdAlgDisabled(mdAlgId)) {
SKIP_TEST();
}
int ret;
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
CRYPT_EAL_PkeyPub publicKey = {0};
BSL_Param pssParam[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdAlgId, sizeof(mdAlgId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdAlgId, sizeof(mdAlgId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &salt->len, sizeof(salt->len), 0},
BSL_PARAM_END};
Hex mdOut = {0};
TestMemInit();
pkeyCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkeyCtx != NULL);
/* Set the public key.*/
SetRsaPubKey(&publicKey, n->x, n->len, e->x, e->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkeyCtx, &publicKey), CRYPT_SUCCESS);
/* Set padding. */
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PSS, pssParam, 0), CRYPT_SUCCESS);
ret = CRYPT_EAL_PkeyVerify(pkeyCtx, mdAlgId, msg->x, msg->len, sign->x, sign->len);
if (expect == SUCCESS) {
ASSERT_EQ(ret, CRYPT_SUCCESS);
} else {
ASSERT_EQ(ret, CRYPT_RSA_NOR_VERIFY_FAIL);
}
ASSERT_TRUE(MD_Data(mdAlgId, msg, &mdOut) == SUCCESS);
ret = CRYPT_EAL_PkeyVerifyData(pkeyCtx, mdOut.x, mdOut.len, sign->x, sign->len);
if (expect == SUCCESS) {
ASSERT_EQ(ret, CRYPT_SUCCESS);
} else {
ASSERT_EQ(ret, CRYPT_RSA_NOR_VERIFY_FAIL);
}
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
if (mdOut.x != NULL) {
free(mdOut.x);
}
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_VERIFY_PSS_FUNC_TC002
* @title RSA verify PSS: saltLen is CRYPT_RSA_SALTLEN_TYPE_AUTOLEN
* @precon
* @brief
* 1. Create the context(pkeyCtx) of the rsa algorithm, expected result 1
* 2. Set public key for pkeyCtx, expected result 2
* 3. Set padding type to PSS(saltLen is CRYPT_RSA_SALTLEN_TYPE_AUTOLEN) for pkeyCtx, expected result 3
* 4. Call the CRYPT_EAL_PkeyVerify method and use pkeyCtx to verify the signed data, expected result 4
* 5. Calculate the hash value of msg, expected result 5
* 6. Call the CRYPT_EAL_PkeyVerifyData method and use pkeyCtx to verify the signed data, expected result 6
* @expect
* 1. Success, and context is not NULL.
* 2-6. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_VERIFY_PSS_FUNC_TC002(int mdAlgId, Hex *n, Hex *e, Hex *msg, Hex *sign, int isProvider)
{
if (IsMdAlgDisabled(mdAlgId)) {
SKIP_TEST();
}
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
CRYPT_EAL_PkeyPub publicKey = {0};
uint32_t signLen = CRYPT_RSA_SALTLEN_TYPE_AUTOLEN;
BSL_Param pssParam[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdAlgId, sizeof(mdAlgId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdAlgId, sizeof(mdAlgId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &signLen, sizeof(signLen), 0},
BSL_PARAM_END};
TestMemInit();
pkeyCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkeyCtx != NULL);
/* Set the public key.*/
SetRsaPubKey(&publicKey, n->x, n->len, e->x, e->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkeyCtx, &publicKey), CRYPT_SUCCESS);
/* Set padding. */
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyCtx, CRYPT_CTRL_SET_RSA_EMSA_PSS, pssParam, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkeyCtx, mdAlgId, msg->x, msg->len, sign->x, sign->len), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkeyCtx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_BLINDING_FUNC_TC001
* @title RSA EAL sign and verify with blinding.
* @precon nan
* @brief
* 1. Create the context(pkeyCtx) of the rsa algorithm, expected result 1
* 2. Set para, expected result 2
* 3. Initialize the DRBG, expected result 3
* 4. Call the CRYPT_EAL_PkeyGen to generate a key pair, expected result 4
* 5. Set CRYPT_RSA_BLINDING flag, expected result 5
* 6. Set padding type, expected result 6
* 7. Sign with HiTLS, expected result 7
* 8. Verify with HiTLS, expected result 8
* @expect
* 1. Success, and context is not NULL.
* 2-8. CRYPT_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_BLINDING_FUNC_TC001(int keyLen, int hashId, int padMode, Hex *msg, int saltLen, int isProvider)
{
TestMemInit();
if (IsMdAlgDisabled(hashId)) {
SKIP_TEST();
}
uint8_t sign[MAX_CIPHERTEXT_LEN] = {0};
uint32_t dataLen = MAX_CIPHERTEXT_LEN;
uint8_t e[] = {1, 0, 1};
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyCtx *newCtx = NULL;
CRYPT_EAL_PkeyPara para = {0};
BSL_Param pssParam[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &hashId, sizeof(hashId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &hashId, sizeof(hashId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &saltLen, sizeof(saltLen), 0},
BSL_PARAM_END};
int paraSize;
void *paraPtr;
SetRsaPara(¶, e, 3, keyLen);
int32_t pkcsv15 = hashId;
if (padMode == CRYPT_CTRL_SET_RSA_EMSA_PSS) {
paraSize = 0;
paraPtr = pssParam;
} else if (padMode == CRYPT_CTRL_SET_RSA_EMSA_PKCSV15) {
paraSize = sizeof(pkcsv15);
paraPtr = &pkcsv15;
}
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_SUCCESS);
#ifdef HITLS_CRYPTO_DRBG
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
#endif
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, padMode, paraPtr, paraSize) == CRYPT_SUCCESS);
uint32_t flag = CRYPT_RSA_BLINDING;
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_FLAG, (void *)&flag, sizeof(uint32_t)) == CRYPT_SUCCESS);
/* private key signature */
ASSERT_TRUE(CRYPT_EAL_PkeySign(pkey, hashId, msg->x, msg->len, sign, &dataLen) == CRYPT_SUCCESS);
/* public key verify */
ASSERT_TRUE(CRYPT_EAL_PkeyVerify(pkey, hashId, msg->x, msg->len, sign, dataLen) == CRYPT_SUCCESS);
newCtx = CRYPT_EAL_PkeyDupCtx(pkey);
ASSERT_TRUE(newCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySign(newCtx, hashId, msg->x, msg->len, sign, &dataLen), CRYPT_SUCCESS);
EXIT:
#ifdef HITLS_CRYPTO_DRBG
TestRandDeInit();
#endif
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(newCtx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_BLINDING_FUNC_TC002
* @title RSA: Pkcsv15, Blinding, Signature.
* @precon nan
* @brief
* 1. Create the context of the rsa algorithm, expected result 1
* 2. Set private key, EMSA_PKCSV15 and CRYPT_RSA_BLINDING flag, expected result 2
* 3. Initialize the drbg, expected result 3
* 4. Signature, expected result 4
* 5. Dup the context, and sign with new context, expected result 5
* @expect
* 1. Success, and context is not NULL.
* 2-4. CRYPT_SUCCESS.
* 5. Success.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_BLINDING_FUNC_TC002(int mdId, Hex *p, Hex *q, Hex *n, Hex *d, Hex *msg, int isProvider)
{
CRYPT_EAL_PkeyCtx *ctx = NULL;
CRYPT_EAL_PkeyCtx *newCtx = NULL;
CRYPT_EAL_PkeyPrv prv = {0};
uint8_t *signdata = NULL;
uint32_t signLen;
uint32_t flag = CRYPT_RSA_BLINDING;
int32_t pkcsv15 = mdId;
SetRsaPrvKey(&prv, n->x, n->len, d->x, d->len);
prv.key.rsaPrv.p = p->x;
prv.key.rsaPrv.pLen = p->len;
prv.key.rsaPrv.q = q->x;
prv.key.rsaPrv.qLen = q->len;
TestMemInit();
#ifdef HITLS_CRYPTO_DRBG
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS); // Random numbers need to be generated during blinding.
#endif
ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(ctx, &prv), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(pkcsv15)), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_RSA_FLAG, (void *)&flag, sizeof(uint32_t)) == CRYPT_SUCCESS);
/* Malloc signature buffer */
signLen = CRYPT_EAL_PkeyGetSignLen(ctx);
signdata = (uint8_t *)calloc(1u, signLen);
ASSERT_TRUE(signdata != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySign(ctx, mdId, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);
newCtx = CRYPT_EAL_PkeyDupCtx(ctx);
ASSERT_TRUE(newCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySign(newCtx, mdId, msg->x, msg->len, signdata, &signLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_EAL_PkeyFreeCtx(newCtx);
free(signdata);
#ifdef HITLS_CRYPTO_DRBG
TestRandDeInit();
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_KEY_PAIR_CHECK_FUNC_TC001
* @title RSA: key pair check.
* @precon Registering memory-related functions.
* @brief
* 1. Create two contexts(pubCtx, prvCtx) of the rsa algorithm, expected result 1
* 2. Set public key for pubCtx, expected result 2
* 3. Set private key for prvCtx, expected result 3
* 4. Check whether the public key matches the private key, expected result 4
* @expect
* 1. Success, and contexts are not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_SUCCESS
* 4. Return CRYPT_SUCCESS when expect is 1, CRYPT_RSA_NOR_VERIFY_FAIL otherwise.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_KEY_PAIR_CHECK_FUNC_TC001(Hex *n, Hex *e, Hex *d, int expect, int isProvider)
{
#if !defined(HITLS_CRYPTO_RSA_CHECK)
(void)n;
(void)e;
(void)d;
(void)expect;
(void)isProvider;
SKIP_TEST();
#else
#ifdef HITLS_CRYPTO_DRBG
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
#endif
CRYPT_EAL_PkeyCtx *pubCtx = NULL;
CRYPT_EAL_PkeyCtx *prvCtx = NULL;
CRYPT_EAL_PkeyPub pubKey = {0};
CRYPT_EAL_PkeyPrv prvKey = {0};
int expectRet = expect == 1 ? CRYPT_SUCCESS : CRYPT_RSA_KEYPAIRWISE_CONSISTENCY_FAILURE;
SetRsaPubKey(&pubKey, n->x, n->len, e->x, e->len);
SetRsaPrvKey(&prvKey, n->x, n->len, d->x, d->len);
TestMemInit();
pubCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
prvCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pubCtx != NULL && prvCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubCtx, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), expectRet);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pubCtx);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
#ifdef HITLS_CRYPTO_DRBG
TestRandDeInit();
#endif
#endif // HITLS_CRYPTO_RSA_CHECK
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_RSABSSA_BLINDING_FUNC_TC001
* @title RSA: Blind signature basic functionality test
* @precon Registering memory-related functions
* @brief
* 1. Create RSA context and generate key pair
* 2. Set PSS parameters and blind signature flag
* 3. Perform blind operation on message
* 4. Sign the blinded message with private key
* 5. Unblind the signature
* 6. Verify the unblinded signature with public key
* 7. Dup the context, and sign-verify with new context
* @expect
* All operations return CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_RSABSSA_BLINDING_FUNC_TC001(int mdId, Hex *n, Hex *e, Hex *d, Hex *msg, int saltLen,
int isProvider)
{
#ifndef HITLS_CRYPTO_RSA_BSSA
SKIP_TEST();
#endif
if (IsMdAlgDisabled(mdId)) {
SKIP_TEST();
}
TestMemInit();
uint8_t sign[MAX_CIPHERTEXT_LEN] = {0};
uint32_t signLen = MAX_CIPHERTEXT_LEN;
CRYPT_EAL_PkeyCtx *newCtx = NULL;
CRYPT_EAL_PkeyCtx *pkey = NULL;
#ifdef HITLS_CRYPTO_RSA_SIGN
uint8_t blindMsg[MAX_CIPHERTEXT_LEN] = {0};
uint32_t blindMsgLen = MAX_CIPHERTEXT_LEN;
#endif
#ifdef HITLS_CRYPTO_RSA_VERIFY
uint8_t unBlindSig[MAX_CIPHERTEXT_LEN] = {0};
uint32_t unBlindSigLen = MAX_CIPHERTEXT_LEN;
#endif
CRYPT_EAL_PkeyPub pubKey = {0};
CRYPT_EAL_PkeyPrv prvKey = {0};
SetRsaPubKey(&pubKey, n->x, n->len, e->x, e->len);
SetRsaPrvKey(&prvKey, n->x, n->len, d->x, d->len);
BSL_Param pssParam[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &saltLen, sizeof(saltLen), 0},
BSL_PARAM_END};
pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_RSA, CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE,
"provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
#ifdef HITLS_CRYPTO_DRBG
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
#endif
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PSS, &pssParam, 0), CRYPT_SUCCESS);
uint32_t flag = CRYPT_RSA_BSSA;
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_FLAG, (void *)&flag, sizeof(uint32_t)) == CRYPT_SUCCESS);
#ifdef HITLS_CRYPTO_RSA_SIGN
ASSERT_TRUE(CRYPT_EAL_PkeyBlind(pkey, mdId, msg->x, msg->len, blindMsg, &blindMsgLen) == CRYPT_SUCCESS);
/* private key signature */
ASSERT_TRUE(CRYPT_EAL_PkeySignData(pkey, blindMsg, blindMsgLen, sign, &signLen) == CRYPT_SUCCESS);
#endif
#ifdef HITLS_CRYPTO_RSA_VERIFY
ASSERT_TRUE(CRYPT_EAL_PkeyUnBlind(pkey, sign, signLen, unBlindSig, &unBlindSigLen) == CRYPT_SUCCESS);
/* public key verify */
ASSERT_TRUE(CRYPT_EAL_PkeyVerify(pkey, mdId, msg->x, msg->len, unBlindSig, unBlindSigLen) == CRYPT_SUCCESS);
#endif
newCtx = CRYPT_EAL_PkeyDupCtx(pkey); // dup ctx
ASSERT_TRUE(newCtx != NULL);
#ifdef HITLS_CRYPTO_RSA_SIGN
ASSERT_TRUE(CRYPT_EAL_PkeySignData(newCtx, blindMsg, blindMsgLen, sign, &signLen) == CRYPT_SUCCESS);
#endif
#ifdef HITLS_CRYPTO_VERIFY
ASSERT_TRUE(CRYPT_EAL_PkeyVerify(newCtx, mdId, msg->x, msg->len, unBlindSig, unBlindSigLen) == CRYPT_SUCCESS);
#endif
EXIT:
#ifdef HITLS_CRYPTO_DRBG
TestRandDeInit();
#endif
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(newCtx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_RSABSSA_BLINDING_FUNC_TC002
* @title RSA: Blind signature with known test vectors
* @precon Registering memory-related functions
* @brief
* 1. Initialize RSA context with known key pairs
* 2. Set PSS parameters and blind signature parameters
* 3. Verify blind factor computation
* 4. Perform blind signature operation with test vectors
* 5. Compare results with expected values
* @expect
* 1. All operations return CRYPT_SUCCESS
* 2. All computed values match the test vectors
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_RSABSSA_BLINDING_FUNC_TC002(Hex *e, Hex *nBuff, Hex *d, Hex *prepared_msg, Hex *salt, Hex *invBuf,
Hex *blindMsgBuf, Hex *blindSigBuf, Hex *sigBuf, int isStub)
{
#ifndef HITLS_CRYPTO_RSA_BSSA
SKIP_TEST();
#endif
(void)sigBuf;
TestMemInit();
uint32_t ret;
uint8_t sign[MAX_CIPHERTEXT_LEN] = {0};
uint32_t signLen = MAX_CIPHERTEXT_LEN;
uint8_t blindMsg[MAX_CIPHERTEXT_LEN] = {0};
uint32_t blindMsgLen = MAX_CIPHERTEXT_LEN;
#ifdef HITLS_CRYPTO_VERIFY
uint8_t unBlindSig[MAX_CIPHERTEXT_LEN] = {0};
uint32_t unBlindSigLen = MAX_CIPHERTEXT_LEN;
#endif
uint8_t rBuf[MAX_CIPHERTEXT_LEN] = {0};
uint32_t rBufLen = MAX_CIPHERTEXT_LEN;
BN_BigNum *invN = NULL;
BN_BigNum *inv = BN_Create(0);
BN_BigNum *n = BN_Create(0);
BN_BigNum *r = BN_Create(0);
BN_Optimizer *opt = BN_OptimizerCreate();
ASSERT_NE(inv, NULL);
ASSERT_NE(n, NULL);
ASSERT_NE(r, NULL);
ASSERT_NE(opt, NULL);
ret = BN_Bin2Bn(n, nBuff->x, nBuff->len);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = BN_Bin2Bn(inv, invBuf->x, invBuf->len);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = BN_ModInv(r, inv, n, opt);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = BN_Bn2Bin(r, rBuf, &rBufLen);
ASSERT_EQ(ret, CRYPT_SUCCESS);
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_MD_AlgId mdId = CRYPT_MD_SHA384;
uint32_t saltLen = salt->len;
BSL_Param pssParam[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &saltLen, sizeof(saltLen), 0},
BSL_PARAM_END};
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_RSA);
ASSERT_TRUE(pkey != NULL);
CRYPT_EAL_PkeyPrv priKey = {0};
CRYPT_EAL_PkeyPub pubKey = {0};
SetRsaPubKey(&pubKey, nBuff->x, nBuff->len, e->x, e->len);
SetRsaPrvKey(&priKey, nBuff->x, nBuff->len, d->x, d->len);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &priKey), CRYPT_SUCCESS);
#ifdef HITLS_CRYPTO_DRBG
if (isStub) {
CRYPT_RandRegist(STUB_ReplaceRandom);
CRYPT_RandRegistEx(STUB_ReplaceRandomEx);
} else {
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
}
#endif
// set pss param.
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PSS, &pssParam, 0)
== CRYPT_SUCCESS);
if (salt->len != 0) {
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_SALT, salt->x, salt->len) == CRYPT_SUCCESS);
}
if (isStub) {
memcpy_s(g_RandBuf, TMP_BUFF_LEN, rBuf, rBufLen);
} else {
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_BSSA_FACTOR_R, rBuf, rBufLen) == CRYPT_SUCCESS);
}
uint32_t flag = CRYPT_RSA_BSSA;
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_FLAG, (void *)&flag, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyBlind(pkey, CRYPT_MD_SHA384, prepared_msg->x, prepared_msg->len, blindMsg,
&blindMsgLen) == CRYPT_SUCCESS);
ret = memcmp(blindMsgBuf->x, blindMsg, blindMsgBuf->len);
ASSERT_EQ(ret, 0);
ASSERT_EQ(blindMsgBuf->len, blindMsgLen);
ASSERT_TRUE(CRYPT_EAL_PkeySignData(pkey, blindMsg, blindMsgLen, sign, &signLen) == CRYPT_SUCCESS);
ret = memcmp(blindSigBuf->x, sign, blindSigBuf->len);
ASSERT_EQ(ret, 0);
ASSERT_EQ(blindSigBuf->len, signLen);
#ifdef HITLS_CRYPTO_VERIFY
ASSERT_TRUE(CRYPT_EAL_PkeyUnBlind(pkey, sign, signLen, unBlindSig, &unBlindSigLen) == CRYPT_SUCCESS);
ret = memcmp(sigBuf->x, unBlindSig, sigBuf->len);
ASSERT_EQ(ret, 0);
ASSERT_EQ(sigBuf->len, unBlindSigLen);
ASSERT_TRUE(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA384, prepared_msg->x, prepared_msg->len, unBlindSig,
unBlindSigLen) == CRYPT_SUCCESS);
#endif
EXIT:
#ifdef HITLS_CRYPTO_DRBG
TestRandDeInit();
#endif
CRYPT_EAL_PkeyFreeCtx(pkey);
BN_OptimizerDestroy(opt);
BN_Destroy(inv);
BN_Destroy(n);
BN_Destroy(r);
BN_Destroy(invN);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_RSA_RSABSSA_BLINDING_INVALID_PARAM_TC001
* @title RSA: Blind signature invalid parameter test
* @precon Registering memory-related functions
* @brief
* 1. Test null pointer handling:
* - Test PkeyBlind/PkeyUnBlind with NULL context
* - Test PkeyBlind/PkeyUnBlind with NULL input/output buffers
* - Test PkeyBlind/PkeyUnBlind with NULL length pointers
* 2. Test unsupported algorithm:
* - Test blind operations with ECDH key context
* 3. Test RSA context without key information:
* - Test blind operations before setting key parameters
* 4. Test buffer size validation:
* - Test with insufficient output buffer size
* 5. Test padding configuration:
* - Test blind operations without setting padding
* - Test with mismatched hash algorithm (SHA256 vs SHA384)
* 6. Test blind parameter controls:
* - Test NULL and invalid parameters for BSSA controls
* - Test getting blind factor inverse without setting output buffer.
* @expect
* - CRYPT_NULL_INPUT for null pointer parameters
* - CRYPT_EAL_ALG_NOT_SUPPORT for unsupported algorithms
* - CRYPT_RSA_NO_KEY_INFO when key info missing
* - CRYPT_RSA_BUFF_LEN_NOT_ENOUGH for small buffers
* - CRYPT_RSA_PADDING_NOT_SUPPORTED for invalid padding
* - CRYPT_RSA_ERR_MD_ALGID for mismatched hash
* - CRYPT_INVALID_ARG for invalid blind parameters
* - CRYPT_RSA_ERR_NO_BLIND_INFO when blind factor not set
*/
/* BEGIN_CASE */
void SDV_CRYPTO_RSA_RSABSSA_BLINDING_INVALID_PARAM_TC001(void)
{
TestMemInit();
uint8_t msg[] = "test message";
uint32_t msgLen = strlen((char *)msg);
uint8_t blindMsg[MAX_CIPHERTEXT_LEN] = {0};
uint32_t blindMsgLen = MAX_CIPHERTEXT_LEN;
CRYPT_EAL_PkeyCtx *pkey = NULL;
uint8_t unBlindSig[MAX_CIPHERTEXT_LEN] = {0};
uint32_t unBlindSigLen = MAX_CIPHERTEXT_LEN;
uint8_t sign[MAX_CIPHERTEXT_LEN] = {0};
uint32_t signLen = MAX_CIPHERTEXT_LEN;
uint32_t smallLen = 16;
// Test null pointer parameters
ASSERT_TRUE(CRYPT_EAL_PkeyBlind(NULL, CRYPT_MD_SHA384, msg, msgLen, blindMsg, &blindMsgLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyUnBlind(NULL, sign, signLen, unBlindSig, &unBlindSigLen) == CRYPT_NULL_INPUT);
// gen key
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ECDH);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyBlind(pkey, CRYPT_MD_SHA384, msg, msgLen, blindMsg, NULL) == CRYPT_EAL_ALG_NOT_SUPPORT);
ASSERT_TRUE(CRYPT_EAL_PkeyUnBlind(pkey, sign, signLen, unBlindSig, &unBlindSigLen) == CRYPT_EAL_ALG_NOT_SUPPORT);
CRYPT_EAL_PkeyFreeCtx(pkey);
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_RSA);
ASSERT_TRUE(pkey != NULL);
CRYPT_EAL_PkeyPara para = {0};
uint8_t e[] = {1, 0, 1};
SetRsaPara(¶, e, 3, 1024);
// set key param
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey, ¶), CRYPT_SUCCESS);
#ifdef HITLS_CRYPTO_DRBG
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
#endif
// Test input null
ASSERT_TRUE(CRYPT_EAL_PkeyBlind(pkey, CRYPT_MD_SHA384, NULL, msgLen, blindMsg, &blindMsgLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyBlind(pkey, CRYPT_MD_SHA384, msg, msgLen, NULL, &blindMsgLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyBlind(pkey, CRYPT_MD_SHA384, msg, msgLen, blindMsg, NULL) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyUnBlind(pkey, NULL, signLen, unBlindSig, &unBlindSigLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyUnBlind(pkey, sign, signLen, NULL, &unBlindSigLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyUnBlind(pkey, sign, signLen, unBlindSig, NULL) == CRYPT_NULL_INPUT);
// Test no key info.
ASSERT_TRUE(CRYPT_EAL_PkeyBlind(pkey, CRYPT_MD_SHA384, msg, msgLen, blindMsg, &smallLen)
== CRYPT_RSA_ERR_NO_PUBKEY_INFO);
ASSERT_TRUE(CRYPT_EAL_PkeyUnBlind(pkey, sign, signLen, unBlindSig, &unBlindSigLen)
== CRYPT_RSA_ERR_NO_PUBKEY_INFO);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
// Output buff is not enough.
ASSERT_TRUE(CRYPT_EAL_PkeyBlind(pkey, CRYPT_MD_SHA384, msg, msgLen, blindMsg, &smallLen)
== CRYPT_RSA_BUFF_LEN_NOT_ENOUGH);
ASSERT_TRUE(CRYPT_EAL_PkeyUnBlind(pkey, msg, msgLen, unBlindSig, &smallLen) == CRYPT_RSA_BUFF_LEN_NOT_ENOUGH);
// pad type is wrong.
ASSERT_TRUE(CRYPT_EAL_PkeyBlind(pkey, CRYPT_MD_SHA384, msg, msgLen, blindMsg, &blindMsgLen)
== CRYPT_RSA_PADDING_NOT_SUPPORTED);
ASSERT_TRUE(CRYPT_EAL_PkeyUnBlind(pkey, msg, msgLen, unBlindSig, &unBlindSigLen)
== CRYPT_RSA_PADDING_NOT_SUPPORTED);
CRYPT_MD_AlgId mdId = CRYPT_MD_SHA384;
uint32_t saltLen = 0;
BSL_Param pssParam[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &saltLen, sizeof(saltLen), 0},
BSL_PARAM_END};
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PSS, &pssParam, 0)
== CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyBlind(pkey, CRYPT_MD_SHA256, msg, msgLen, blindMsg, &unBlindSigLen)
== CRYPT_RSA_ERR_MD_ALGID);
uint8_t rBufTest[128] = {1}; // due to key bits = 1024
uint8_t rBufTest1[128] = {0}; // due to key bits = 1024
uint32_t rBufTestLen = 128;
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_BSSA_FACTOR_R, NULL, 0) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_BSSA_FACTOR_R, rBufTest, rBufTestLen) == CRYPT_SUCCESS);
// repeated set
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_BSSA_FACTOR_R, rBufTest, rBufTestLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_BSSA_FACTOR_R, rBufTest1, rBufTestLen)
== CRYPT_RSA_ERR_BSSA_PARAM);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/rsa/test_suite_sdv_eal_rsa_sign_verify.c | C | unknown | 58,667 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "securec.h"
#include "crypt_eal_kdf.h"
#include "crypt_errno.h"
#include "bsl_sal.h"
#include "crypt_pbkdf2.h"
#include "bsl_params.h"
#include "crypt_params_key.h"
/* END_HEADER */
#define DATA_LEN (16)
/**
* @test SDV_CRYPT_EAL_KDF_SCRYPT_API_TC001
* @title Scrypt interface test.
* @precon nan
* @brief
* 1.Normal parameter test,the key and salt can be empty, expected result 1.
* 2.Abnormal parameter test,about the restriction, see the function declaration, expected result 2.
* @expect
* 1.Return CRYPT_SUCCESS.
* 2.The results are as expected.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_KDF_SCRYPT_API_TC001(void)
{
TestMemInit();
uint32_t keyLen = DATA_LEN;
uint8_t key[DATA_LEN];
uint32_t saltLen = DATA_LEN;
uint8_t salt[DATA_LEN];
uint32_t N = DATA_LEN;
uint32_t r = DATA_LEN;
uint32_t p = DATA_LEN;
uint32_t outLen = DATA_LEN;
uint8_t out[DATA_LEN];
CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_SCRYPT);
ASSERT_TRUE(ctx != NULL);
BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS,
key, keyLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
salt, saltLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_N, BSL_PARAM_TYPE_UINT32,
&N, sizeof(N)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_R, BSL_PARAM_TYPE_UINT32,
&r, sizeof(r)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_P, BSL_PARAM_TYPE_UINT32,
&p, sizeof(p)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS,
NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
N = 0;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_N, BSL_PARAM_TYPE_UINT32,
&N, sizeof(N)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SCRYPT_PARAM_ERROR);
N = 3;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_N, BSL_PARAM_TYPE_UINT32,
&N, sizeof(N)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SCRYPT_PARAM_ERROR);
N = 6;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_N, BSL_PARAM_TYPE_UINT32,
&N, sizeof(N)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SCRYPT_PARAM_ERROR);
N = 65538;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_N, BSL_PARAM_TYPE_UINT32,
&N, sizeof(N)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SCRYPT_PARAM_ERROR);
N = 4;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_N, BSL_PARAM_TYPE_UINT32,
&N, sizeof(N)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
N = DATA_LEN;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_N, BSL_PARAM_TYPE_UINT32,
&N, sizeof(N)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
r = 0;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_R, BSL_PARAM_TYPE_UINT32,
&r, sizeof(r)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SCRYPT_PARAM_ERROR);
r = DATA_LEN;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_R, BSL_PARAM_TYPE_UINT32,
&r, sizeof(r)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
p = 0;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_P, BSL_PARAM_TYPE_UINT32,
&p, sizeof(p)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SCRYPT_PARAM_ERROR);
p = DATA_LEN;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_P, BSL_PARAM_TYPE_UINT32,
&p, sizeof(p)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, NULL, outLen), CRYPT_SCRYPT_PARAM_ERROR);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, 0), CRYPT_SCRYPT_PARAM_ERROR);
ASSERT_EQ(CRYPT_EAL_KdfDeInitCtx(ctx), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_KdfFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_KDF_SCRYPT_API_TC002
* @title Parameters N, r, and p of the CRYPT_EAL_Scrypt interface test.
* @precon nan
* @brief
* 1.Abnormal parameter test,about the restriction, see the function declaration, expected result 1.
* @expect
* 1.The results are as expected,See Note.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_KDF_SCRYPT_API_TC002(void)
{
// Parameter limitation:
// N < 2^(128 * r / 8)
// p <= ((2^32-1) * 32) / (128 * r). Equivalent to r * p <= 2^30 - 1
// p * 128 * r < UINT32_MAX
// 32 * r * N * sizeof(uint32_t) < UINT32_MAX => N < ((UINT32_MAX / 128) / r)
// UINT32_MAX 0xffffffffU /* 4294967295U */
TestMemInit();
uint32_t keyLen = DATA_LEN;
uint8_t key[DATA_LEN];
uint32_t saltLen = DATA_LEN;
uint8_t salt[DATA_LEN];
uint32_t N = DATA_LEN;
uint32_t r = DATA_LEN;
uint32_t p = DATA_LEN;
uint32_t outLen = DATA_LEN;
uint8_t out[DATA_LEN];
CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_SCRYPT);
ASSERT_TRUE(ctx != NULL);
BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS,
key, keyLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
salt, saltLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_N, BSL_PARAM_TYPE_UINT32,
&N, sizeof(N)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_R, BSL_PARAM_TYPE_UINT32,
&r, sizeof(r)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_P, BSL_PARAM_TYPE_UINT32,
&p, sizeof(p)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
// N is 2^16 = 65536, r is 1,Not satisfied N < 2^(128 * r / 8)
N = 65536;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_N, BSL_PARAM_TYPE_UINT32,
&N, sizeof(N)), CRYPT_SUCCESS);
r = 1;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_R, BSL_PARAM_TYPE_UINT32,
&r, sizeof(r)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SCRYPT_PARAM_ERROR);
// N is 2^15 = 32768, r is 1,satisfied N < 2^(128 * r / 8)
N = 32768;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_N, BSL_PARAM_TYPE_UINT32,
&N, sizeof(N)), CRYPT_SUCCESS);
r = 1;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_R, BSL_PARAM_TYPE_UINT32,
&r, sizeof(r)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
// r = 2^16 = 65536, N = 2^9 = 512, Not satisfied N < ((UINT32_MAX / 128) / r)
N = 512;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_N, BSL_PARAM_TYPE_UINT32,
&N, sizeof(N)), CRYPT_SUCCESS);
r = 65536;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_R, BSL_PARAM_TYPE_UINT32,
&r, sizeof(r)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SCRYPT_PARAM_ERROR);
N = DATA_LEN;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_N, BSL_PARAM_TYPE_UINT32,
&N, sizeof(N)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
// r is 2^16 = 65536, p is 2^16 = 65536, Not satisfied p <= ((2^32-1) * 32) / (128 * r)
r = 65536;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_R, BSL_PARAM_TYPE_UINT32,
&r, sizeof(r)), CRYPT_SUCCESS);
p = 65536;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_P, BSL_PARAM_TYPE_UINT32,
&p, sizeof(p)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SCRYPT_PARAM_ERROR);
// r = 2^16 = 65536, p = 2^14 = 16384, Not satisfied r * p <= 2^30 - 1
r = 65536;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_R, BSL_PARAM_TYPE_UINT32,
&r, sizeof(r)), CRYPT_SUCCESS);
p = 16384;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_P, BSL_PARAM_TYPE_UINT32,
&p, sizeof(p)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SCRYPT_PARAM_ERROR);
// r = 2^16 = 65536, p = 2^9 = 512, Not satisfied p * 128 * r < UINT32_MAX
r = 65536;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_R, BSL_PARAM_TYPE_UINT32,
&r, sizeof(r)), CRYPT_SUCCESS);
p = 512;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_P, BSL_PARAM_TYPE_UINT32,
&p, sizeof(p)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SCRYPT_PARAM_ERROR);
// r = 2^8 = 256, p = 2^22 = 4194304, Not satisfied r * p <= 2^30 - 1
r = 256;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_R, BSL_PARAM_TYPE_UINT32,
&r, sizeof(r)), CRYPT_SUCCESS);
p = 4194304;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_P, BSL_PARAM_TYPE_UINT32,
&p, sizeof(p)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SCRYPT_PARAM_ERROR);
// r = 2^4 = 16, p = 2^26 = 67108864, Not satisfied r * p <= 2^30 - 1
r = 16;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_R, BSL_PARAM_TYPE_UINT32,
&r, sizeof(r)), CRYPT_SUCCESS);
p = 67108864;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_P, BSL_PARAM_TYPE_UINT32,
&p, sizeof(p)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SCRYPT_PARAM_ERROR);
// r = 2^4 = 16, p = 2^21 = 2097152, Not satisfied p * 128 * r < UINT32_MAX
r = 16;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_R, BSL_PARAM_TYPE_UINT32,
&r, sizeof(r)), CRYPT_SUCCESS);
p = 2097152;
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_P, BSL_PARAM_TYPE_UINT32,
&p, sizeof(p)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SCRYPT_PARAM_ERROR);
EXIT:
CRYPT_EAL_KdfFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_KDF_SCRYPT_FUN_TC001
* @title Scrypt vector test.
* @precon nan
* @brief
* 1.Calculate the output using the given parameters, expected result 1.
* 2.Compare the calculated result with the standard value, expected result 2.
* @expect
* 1.Calculation succeeded..
* 2.The results are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_KDF_SCRYPT_FUN_TC001(Hex *key, Hex *salt, int N, int r, int p, Hex *result)
{
TestMemInit();
uint32_t outLen = result->len;
uint8_t *out = malloc(outLen * sizeof(uint8_t));
ASSERT_TRUE(out != NULL);
CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_SCRYPT);
ASSERT_TRUE(ctx != NULL);
BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS,
key->x, key->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
salt->x, salt->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_N, BSL_PARAM_TYPE_UINT32,
&N, sizeof(N)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_R, BSL_PARAM_TYPE_UINT32,
&r, sizeof(r)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_P, BSL_PARAM_TYPE_UINT32,
&p, sizeof(p)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
EXIT:
if (out != NULL) {
free(out);
}
CRYPT_EAL_KdfFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SCRYPT_DEFAULT_PROVIDER_FUNC_TC001
* @title Default provider testing
* @precon nan
* @brief
* Load the default provider and use the test vector to test its correctness
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SCRYPT_DEFAULT_PROVIDER_FUNC_TC001(Hex *key, Hex *salt, int N, int r, int p, Hex *result)
{
TestMemInit();
uint32_t outLen = result->len;
uint8_t *out = malloc(outLen * sizeof(uint8_t));
ASSERT_TRUE(out != NULL);
CRYPT_EAL_KdfCTX *ctx = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx = CRYPT_EAL_ProviderKdfNewCtx(NULL, CRYPT_KDF_SCRYPT, "provider=default");
#else
ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_SCRYPT);
#endif
ASSERT_TRUE(ctx != NULL);
BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS,
key->x, key->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
salt->x, salt->len), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_N, BSL_PARAM_TYPE_UINT32,
&N, sizeof(N)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_R, BSL_PARAM_TYPE_UINT32,
&r, sizeof(r)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_P, BSL_PARAM_TYPE_UINT32,
&p, sizeof(p)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("result cmp", out, outLen, result->x, result->len);
EXIT:
if (out != NULL) {
free(out);
}
CRYPT_EAL_KdfFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_KDF_SCRYPT_FUN_TC002
* @title Data tests that may exceed the boundaries.
* @precon nan
* @brief
* 1. Use parameters that will go out of bounds, Call func CRYPT_EAL_KdfDerive.
* @expect
* 1.return value is CRYPT_SCRYPT_PARAM_ERROR.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_KDF_SCRYPT_FUN_TC002(int testN, int testR, int testP)
{
TestMemInit();
uint32_t keyLen = DATA_LEN;
uint8_t key[DATA_LEN];
uint32_t saltLen = DATA_LEN;
uint8_t salt[DATA_LEN];
uint32_t N = testN;
uint32_t r = testR;
uint32_t p = testP;
uint32_t outLen = DATA_LEN;
uint8_t out[DATA_LEN];
CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_SCRYPT);
ASSERT_TRUE(ctx != NULL);
BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS,
key, keyLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
salt, saltLen), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_N, BSL_PARAM_TYPE_UINT32,
&N, sizeof(N)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_R, BSL_PARAM_TYPE_UINT32,
&r, sizeof(r)), CRYPT_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_P, BSL_PARAM_TYPE_UINT32,
&p, sizeof(p)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SCRYPT_PARAM_ERROR);
EXIT:
CRYPT_EAL_KdfFreeCtx(ctx);
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/scrypt/test_suite_sdv_eal_kdf_scrypt.c | C | unknown | 17,393 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <pthread.h>
#include "securec.h"
#include "eal_md_local.h"
#include "crypt_eal_md.h"
#include "crypt_errno.h"
#include "bsl_sal.h"
/* END_HEADER */
#define SHA1_DIGEST_LEN (20)
#define DATA_MAX_LEN (65538)
typedef struct {
uint8_t *data;
uint8_t *hash;
uint32_t dataLen;
uint32_t hashLen;
} ThreadParameter;
void MultiThreadTest(void *arg)
{
ThreadParameter *threadParameter = (ThreadParameter *)arg;
uint32_t outLen = SHA1_DIGEST_LEN;
uint8_t out[SHA1_DIGEST_LEN];
CRYPT_EAL_MdCTX *ctx = NULL;
ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA1);
ASSERT_TRUE(ctx != NULL);
for (uint32_t i = 0; i < 10; i++) {
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, threadParameter->data, threadParameter->dataLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("hash result cmp", out, outLen, threadParameter->hash, threadParameter->hashLen);
}
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/**
* @test SDV_CRYPT_EAL_SHA1_API_TC001
* @title Initialization interface test
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdInit and enter NULL, expected result 1.
* 2.Call CRYPT_EAL_MdNewCtx create ctx, expected result 2.
* 3.Call CRYPT_EAL_MdInit and use the correct ID. expected result 3.
* @expect
* 1.Initialization failed, return CRYPT_NULL_INPUT
* 2.The ctx is created successfully.
* 3.Initialization successful, return CRYPT_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SHA1_API_TC001(void)
{
TestMemInit();
CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_MAX);;
ASSERT_TRUE(ctx == NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(NULL), CRYPT_NULL_INPUT);
ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA1);;
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SHA1_API_TC002
* @title CRYPT_EAL_MdUpdate and CRYPT_EAL_MdFinal test
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdDeinit the null CTX, expected result 1.
* 2.Invoke the CRYPT_EAL_MdNewCtx to create a CTX, expected result 2.
* 3.Call CRYPT_EAL_MdUpdate and CRYPT_EAL_MdFinal before initialization, expected result 3 is obtained.
* 4.Initialize the CTX and transfer null pointers to CRYPT_EAL_MdUpdate and CRYPT_EAL_MdFinal. expected result 4.
* 5.Invoke CRYPT_EAL_MdUpdate and CRYPT_EAL_MdFinal normally, expected result 5.
* 6.Call CRYPT_EAL_MdDeinit the CTX, expected result 6.
* @expect
* 1.Return CRYPT_NULL_INPUT
* 2.Successful, ctx is returned.
* 3.Return CRYPT_EAL_ERR_STATE
* 4.Return CRYPT_NULL_INPUT
* 5.Return CRYPT_SUCCESS
* 6.Return CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SHA1_API_TC002(void)
{
TestMemInit();
CRYPT_EAL_MdCTX *ctx = NULL;
const uint32_t dataLen = SHA1_DIGEST_LEN;
uint8_t data[SHA1_DIGEST_LEN];
uint32_t digestLen = SHA1_DIGEST_LEN;
uint8_t out[SHA1_DIGEST_LEN];
ASSERT_EQ(CRYPT_EAL_MdDeinit(ctx), CRYPT_NULL_INPUT);
ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA1);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, data, dataLen), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &digestLen), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(NULL, data, dataLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, NULL, dataLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, data, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, data, dataLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(NULL, out, &digestLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, NULL, &digestLen), CRYPT_NULL_INPUT);
digestLen = SHA1_DIGEST_LEN - 1;
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &digestLen), CRYPT_SHA1_OUT_BUFF_LEN_NOT_ENOUGH);
digestLen = SHA1_DIGEST_LEN;
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &digestLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdDeinit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(ctx->state, CRYPT_MD_STATE_NEW);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SHA1_API_TC003
* @title Repeated hash calculation test
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdNewCtx to create a CTX, expected result 1.
* 2.Calculate the hash, expected result 2.
* 3.Calculate the hash again, expected result 3.
* 4.Calculate the hash again, expected result 4.
* 5.Call CRYPT_EAL_MdFinal again, expected result 5.
* 6.Call CRYPT_EAL_Md to calculate the hash value, expected result 6.
* @expect
* 1.Successful, ctx is returned.
* 2.Obtains the hash of an empty string.
* 3.Obtains the hash of data
* 4.Obtains the hash of an empty string.
* 5.Return CRYPT_EAL_ERR_STATE.
* 6.Obtains the expected hash of data
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SHA1_API_TC003(Hex *hash1, Hex *data2, Hex *hash2, Hex *hash3)
{
TestMemInit();
CRYPT_EAL_MdCTX *ctx = NULL;
uint32_t digestLen = SHA1_DIGEST_LEN;
uint8_t out[SHA1_DIGEST_LEN];
ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA1);
ASSERT_TRUE(ctx != NULL);
// Hash calculation for the first time.
ASSERT_TRUE(CRYPT_EAL_MdInit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MdFinal(ctx, out, &digestLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("hash1 result cmp", out, digestLen, hash1->x, hash1->len);
// Hash calculation for the second time.
ASSERT_TRUE(CRYPT_EAL_MdInit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MdUpdate(ctx, data2->x, data2->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MdFinal(ctx, out, &digestLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("hash2 result cmp", out, digestLen, hash2->x, hash2->len);
// Hash calculation for the third time.
ASSERT_TRUE(CRYPT_EAL_MdInit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MdFinal(ctx, out, &digestLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("hash3 result cmp", out, digestLen, hash3->x, hash3->len);
ASSERT_TRUE(CRYPT_EAL_MdFinal(ctx, out, &digestLen) == CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_Md(CRYPT_MD_SHA1, data2->x, data2->len, out, &digestLen), CRYPT_SUCCESS);
ASSERT_COMPARE("hash2 result cmp", out, digestLen, hash2->x, hash2->len);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SHA1_API_TC004
* @title To test the function of obtaining the digest length of the hash algorithm.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdGetDigestSize,the input parameter ID is invalid, expected result 1.
* 2.Call CRYPT_EAL_MdGetDigestSize, Using CRYPT_MD_SHA1, expected result 2.
* @expect
* 1.Failed, return 0.
* 2.Success, return SHA1_DIGEST_LEN.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SHA1_API_TC004(void)
{
ASSERT_EQ(CRYPT_EAL_MdGetDigestSize(CRYPT_MD_MAX), 0);
ASSERT_EQ(CRYPT_EAL_MdGetDigestSize(CRYPT_MD_SHA1), SHA1_DIGEST_LEN);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SHA1_FUN_TC001
* @title Perform the vector test to check whether the calculation result is consistent with the standard output.
* @precon nan
* @brief
* 1.Calculate the hash of each group of data, expected result 1.
* 2.Compare the result to the expected value, expected result 2.
* @expect
* 1.Hash calculation succeeded.
* 2.The results are as expected.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SHA1_FUN_TC001(Hex *data, Hex *hash)
{
TestMemInit();
CRYPT_EAL_MdCTX *ctx = NULL;
uint32_t digestLen = SHA1_DIGEST_LEN;
uint8_t out[SHA1_DIGEST_LEN];
ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA1);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, data->x, data->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &digestLen), CRYPT_SUCCESS);
ASSERT_COMPARE("hash result cmp", out, digestLen, hash->x, hash->len);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SHA1_FUN_TC002
* @title Test multi-thread hash calculation.
* @precon nan
* @brief
* 1.Create two threads and calculate the hash, expected result 1.
* 2.Compare the result to the expected value, expected result 2.
* @expect
* 1.Hash calculation succeeded.
* 2.The results are as expected.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SHA1_FUN_TC002(Hex *data, Hex *hash)
{
int ret;
TestMemInit();
const uint32_t threadNum = 2;
pthread_t thrd[2];
ThreadParameter arg[2] = {
{data->x, hash->x, data->len, hash->len},
{data->x, hash->x, data->len, hash->len}
};
for (uint32_t i = 0; i < threadNum; i++) {
ret = pthread_create(&thrd[i], NULL, (void *)MultiThreadTest, &arg[i]);
ASSERT_TRUE(ret == 0);
}
for (uint32_t i = 0; i < threadNum; i++) {
pthread_join(thrd[i], NULL);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SHA1_FUN_TC003
* @title Hash calculation for multiple updates,comparison with standard results.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdNewCtx to create a ctx and initialize, expected result 1.
* 2.Call CRYPT_EAL_MdUpdate to calculate the hash of a data segmentxpected result 2.
* 3.Call CRYPT_EAL_MdUpdate to calculate the next data segmentxpected result 3.
* 4.Call CRYPT_EAL_MdUpdate to calculate the next data segmentxpected result 4.
* 5.Call CRYPT_EAL_MdFinal get the result, expected result 5.
* @expect
* 1.Successful
* 2.Successful
* 3.Successful
* 4.Successful
* 5.The results are as expected.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SHA1_FUN_TC003(Hex *plain_text1, Hex *plain_text2, Hex *plain_text3, Hex *hash)
{
unsigned char output[SHA1_DIGEST_LEN];
uint32_t outLen = SHA1_DIGEST_LEN;
TestMemInit();
CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA1);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, plain_text1->x, plain_text1->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, plain_text2->x, plain_text2->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, plain_text3->x, plain_text3->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("sha1", output, outLen, hash->x, hash->len);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SHA1_COPY_CTX_FUNC_TC001
* @title SHA1 copy ctx function test.
* @precon nan
* @brief
* 1. Create the context ctx of md algorithm, expected result 1
* 2. Call to CRYPT_EAL_MdCopyCtx method to copy ctx, expected result 2
* 2. Call to CRYPT_EAL_MdCopyCtx method to copy a null ctx, expected result 3
* 3. Calculate the hash of msg, and compare the calculated result with hash vector, expected result 4
* 4. Call to CRYPT_EAL_MdDupCtx method to copy ctx, expected result 5
* 3. Calculate the hash of msg, and compare the calculated result with hash vector, expected result 6
* @expect
* 1. Success, the context is not null.
* 2. CRYPT_SUCCESS
* 3. CRYPT_NULL_INPUT
* 4. Success, the context is not null.
* 5. CRYPT_SUCCESS
* 6. Success, the hashs are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SHA1_COPY_CTX_FUNC_TC001(int id, Hex *msg, Hex *hash)
{
TestMemInit();
CRYPT_EAL_MdCTX *cpyCtx = NULL;
CRYPT_EAL_MdCTX *dupCtx = NULL;
CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdNewCtx(id);
ASSERT_TRUE(ctx != NULL);
uint8_t output[SHA1_DIGEST_LEN];
uint32_t outLen = SHA1_DIGEST_LEN;
dupCtx=CRYPT_EAL_MdDupCtx(cpyCtx);
ASSERT_TRUE(dupCtx == NULL);
ASSERT_EQ(CRYPT_MD_MAX, CRYPT_EAL_MdGetId(dupCtx));
ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, ctx), CRYPT_NULL_INPUT);
cpyCtx = CRYPT_EAL_MdNewCtx(id);
ASSERT_TRUE(cpyCtx != NULL);
ASSERT_TRUE(dupCtx == NULL);
ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, dupCtx), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdInit(cpyCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(cpyCtx, msg->x, msg->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(cpyCtx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(id, cpyCtx->id);
ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
dupCtx=CRYPT_EAL_MdDupCtx(ctx);
ASSERT_TRUE(dupCtx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(dupCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(dupCtx, msg->x, msg->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(dupCtx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(id, CRYPT_EAL_MdGetId(dupCtx));
ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
CRYPT_EAL_MdFreeCtx(cpyCtx);
CRYPT_EAL_MdFreeCtx(dupCtx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SHA1_FUN_TC004
* @title Default provider testing
* @precon nan
* @brief
* Load the default provider and use the test vector to test its correctness
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SHA1_FUN_TC004(int id, Hex *msg, Hex *hash)
{
TestMemInit();
uint8_t output[SHA1_DIGEST_LEN];
uint32_t outLen = SHA1_DIGEST_LEN;
CRYPT_EAL_MdCTX *ctx = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, id, "provider=default");
#else
(void)id;
ctx = CRYPT_EAL_MdNewCtx(id);
#endif
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, msg->x, msg->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/sha1/test_suite_sdv_eal_md_sha1.c | C | unknown | 14,377 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <pthread.h>
#include "eal_md_local.h"
#include "crypt_eal_md.h"
#include "crypt_errno.h"
#include "bsl_sal.h"
/* END_HEADER */
// 100 is greater than the digest length of all SHA algorithms.
#define SHA2_OUTPUT_MAXSIZE 100
typedef struct {
uint8_t *data;
uint8_t *hash;
uint32_t dataLen;
uint32_t hashLen;
CRYPT_MD_AlgId id;
} ThreadParameter;
void Sha2MultiThreadTest(void *arg)
{
ThreadParameter *threadParameter = (ThreadParameter *)arg;
uint32_t outLen = SHA2_OUTPUT_MAXSIZE;
uint8_t out[SHA2_OUTPUT_MAXSIZE];
CRYPT_EAL_MdCTX *ctx = NULL;
ctx = CRYPT_EAL_MdNewCtx(threadParameter->id);
ASSERT_TRUE(ctx != NULL);
for (uint32_t i = 0; i < 10; i++) { // Repeat 10 times
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, threadParameter->data, threadParameter->dataLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("hash result cmp", out, outLen, threadParameter->hash, threadParameter->hashLen);
}
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/**
* @test SDV_CRYPT_EAL_SHA2_API_TC001
* @title Create sha2 context test.
* @precon nan
* @brief
* 1.Create context with invalid id, expected result 1.
* 2.Create context using CRYPT_MD_SHA224 CRYPT_MD_SHA256 CRYPT_MD_SHA384 CRYPT_MD_SHA512, expected result 2.
* @expect
* 1.The result is NULL.
* 2.Create successful.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SHA2_API_TC001(void)
{
TestMemInit();
CRYPT_EAL_MdCTX *ctx = NULL;
ctx = CRYPT_EAL_MdNewCtx(-1);
ASSERT_TRUE(ctx == NULL);
ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_MAX);
ASSERT_TRUE(ctx == NULL);
ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA224);
ASSERT_TRUE(ctx != NULL);
CRYPT_EAL_MdFreeCtx(ctx);
ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA256);
ASSERT_TRUE(ctx != NULL);
CRYPT_EAL_MdFreeCtx(ctx);
ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA384);
ASSERT_TRUE(ctx != NULL);
CRYPT_EAL_MdFreeCtx(ctx);
ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA512);
ASSERT_TRUE(ctx != NULL);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SHA2_API_TC002
* @title SHA2 get the digest length test.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdGetDigestSize to get the digest length, expected result 1.
* @expect
* 1.The value is the same as expected.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SHA2_API_TC002(void)
{
ASSERT_EQ(CRYPT_EAL_MdGetDigestSize(-1), 0);
ASSERT_EQ(CRYPT_EAL_MdGetDigestSize(CRYPT_MD_MAX), 0);
// The length of the SHA224 digest is 28 characters.
ASSERT_EQ(CRYPT_EAL_MdGetDigestSize(CRYPT_MD_SHA224), 28);
// The length of the SHA256 digest is 32 characters.
ASSERT_EQ(CRYPT_EAL_MdGetDigestSize(CRYPT_MD_SHA256), 32);
// The length of the SHA384 digest is 48 characters.
ASSERT_EQ(CRYPT_EAL_MdGetDigestSize(CRYPT_MD_SHA384), 48);
// The length of the SHA512 digest is 64 characters.
ASSERT_EQ(CRYPT_EAL_MdGetDigestSize(CRYPT_MD_SHA512), 64);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SHA2_API_TC003
* @title update and final test.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdDeinit the null CTX, expected result 1.
* 2.Call CRYPT_EAL_MdNewCtx create the CTX, expected result 2.
* 3.Call CRYPT_EAL_MdUpdate and CRYPT_EAL_MdFinal before initialization, expected result 3.
* 4.Call CRYPT_EAL_MdUpdate and CRYPT_EAL_MdFinal use null pointer, expected result 4.
* 5.Call CRYPT_EAL_MdUpdate and CRYPT_EAL_MdFinal normally, expected result 5.
* 6.Call CRYPT_EAL_MdDeinit the CTX, expected result 6.
* @expect
* 1.Return CRYPT_NULL_INPUT
* 2.Create successful.
* 3.Return CRYPT_EAL_ERR_STATE.
* 4.Return CRYPT_NULL_INPUT.
* 5.Successful.
* 6.Return CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SHA2_API_TC003(int id)
{
TestMemInit();
CRYPT_EAL_MdCTX *ctx = NULL;
ASSERT_EQ(CRYPT_EAL_MdDeinit(ctx), CRYPT_NULL_INPUT);
ctx = CRYPT_EAL_MdNewCtx(id);
ASSERT_TRUE(ctx != NULL);
uint8_t input[SHA2_OUTPUT_MAXSIZE];
const uint32_t inLen = SHA2_OUTPUT_MAXSIZE;
uint8_t out[SHA2_OUTPUT_MAXSIZE];
uint32_t validOutLen = CRYPT_EAL_MdGetDigestSize(id);
uint32_t invalidOutLen = validOutLen - 1;
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, input, inLen), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &validOutLen), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(NULL, input, inLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, NULL, inLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, input, inLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(NULL, out, &validOutLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, NULL, &validOutLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &invalidOutLen), CRYPT_SHA2_OUT_BUFF_LEN_NOT_ENOUGH);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &validOutLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdGetId(ctx), id);
ASSERT_EQ(CRYPT_EAL_MdDeinit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdIsValidAlgId(id), true);
ASSERT_EQ(CRYPT_EAL_MdDeinit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(ctx->state, CRYPT_MD_STATE_NEW);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_MD_SHA2_FUNC_TC001
* @title Split the data and update test.
* @precon nan
* @brief
* 1.Create two ctx and initialize them, expected result 1.
* 2.Use ctx1 to update data 100 times, expected result 2.
* 3.Use ctx2 to update all data at once, expected result 3.
* 4.Compare two outputs, expected result 4.
* @expect
* 1.Successful.
* 2.Successful.
* 3.Successful.
* 4.The results are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_MD_SHA2_FUNC_TC001(int id)
{
if (IsMdAlgDisabled(id)) {
SKIP_TEST();
}
TestMemInit();
CRYPT_EAL_MdCTX *ctx1 = NULL;
CRYPT_EAL_MdCTX *ctx2 = NULL;
ctx1 = CRYPT_EAL_MdNewCtx(id);
ASSERT_TRUE(ctx1 != NULL);
ctx2 = CRYPT_EAL_MdNewCtx(id);
ASSERT_TRUE(ctx2 != NULL);
// 100! = 5050
uint8_t input[5050];
uint32_t inLenTotal = 0;
uint32_t inLenBase;
uint8_t out1[SHA2_OUTPUT_MAXSIZE];
uint8_t out2[SHA2_OUTPUT_MAXSIZE];
uint32_t outLen = CRYPT_EAL_MdGetDigestSize(id);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx2), CRYPT_SUCCESS);
for (inLenBase = 1; inLenBase <= 100; inLenBase++) {
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx1, input + inLenTotal, inLenBase), CRYPT_SUCCESS);
inLenTotal += inLenBase;
}
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx1, out1, &outLen), CRYPT_SUCCESS);
outLen = CRYPT_EAL_MdGetDigestSize(id);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx2, input, inLenTotal), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx2, out2, &outLen), CRYPT_SUCCESS);
outLen = CRYPT_EAL_MdGetDigestSize(id);
ASSERT_COMPARE("sha2", out1, outLen, out2, outLen);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx1);
CRYPT_EAL_MdFreeCtx(ctx2);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_MD_SHA2_FUNC_TC002
* @title Empty string test.
* @precon nan
* @brief
* 1.Create ctx and initialize it, expected result 1.
* 2.Call CRYPT_EAL_MdFinal to get the output, expected result 2.
* 3.Compare output and vectors, expected result 3.
* @expect
* 1.Successful.
* 2.Successful.
* 3.The results are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_MD_SHA2_FUNC_TC002(int id, Hex *digest)
{
TestMemInit();
CRYPT_EAL_MdCTX *ctx = NULL;
ctx = CRYPT_EAL_MdNewCtx(id);
ASSERT_TRUE(ctx != NULL);
uint8_t out[SHA2_OUTPUT_MAXSIZE];
uint32_t outLen = CRYPT_EAL_MdGetDigestSize(id);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("sha2", out, outLen, digest->x, digest->len);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_MD_SHA2_FUNC_TC003
* @title standard vector test.
* @precon nan
* @brief
* 1.Calculate the hash of the data and compare it with the standard vector, expected result 1.
* 2.Call CRYPT_EAL_Md to calculate the hash of the data and compare it with the standard vector, expected result 2.
* @expect
* 1.The results are the same.
* 2.The results are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_MD_SHA2_FUNC_TC003(int algId, Hex *in, Hex *digest)
{
if (IsMdAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
CRYPT_EAL_MdCTX *ctx = NULL;
uint8_t out[SHA2_OUTPUT_MAXSIZE];
uint32_t outLen = CRYPT_EAL_MdGetDigestSize(algId);
ctx = CRYPT_EAL_MdNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, in->x, in->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("sha2", out, outLen, digest->x, digest->len);
ASSERT_EQ(CRYPT_EAL_Md(algId, in->x, in->len, out, &outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("sha2", out, outLen, digest->x, digest->len);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_MD_SHA2_FUNC_TC004
* @title Hash calculation for multiple updates,comparison with standard results.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdNewCtx to create a ctx and initialize, expected result 1.
* 2.Call CRYPT_EAL_MdUpdate to calculate the hash of a data segmentxpected result 2.
* 3.Call CRYPT_EAL_MdUpdate to calculate the next data segmentxpected result 3.
* 4.Call CRYPT_EAL_MdUpdate to calculate the next data segmentxpected result 4.
* 5.Call CRYPT_EAL_MdFinal get the result, expected result 5.
* @expect
* 1.Successful
* 2.Successful
* 3.Successful
* 4.Successful
* 5.The results are as expected.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_MD_SHA2_FUNC_TC004(int algId, Hex *plain_text1, Hex *plain_text2, Hex *plain_text3, Hex *hash)
{
// 100 is greater than the digest length of all SHA algorithms.
unsigned char output[SHA2_OUTPUT_MAXSIZE];
uint32_t outLen = SHA2_OUTPUT_MAXSIZE;
TestMemInit();
CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, plain_text1->x, plain_text1->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, plain_text2->x, plain_text2->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, plain_text3->x, plain_text3->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("sha2", output, outLen, hash->x, hash->len);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_MD_SHA2_FUNC_TC005
* @title Test multi-thread hash calculation.
* @precon nan
* @brief
* 1.Create two threads and calculate the hash, expected result 1.
* 2.Compare the result to the expected value, expected result 2.
* @expect
* 1.Hash calculation succeeded.
* 2.The results are as expected.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_MD_SHA2_FUNC_TC005(int algId, Hex *data, Hex *hash)
{
int ret;
TestMemInit();
const uint32_t threadNum = 2;
pthread_t thrd[2];
ThreadParameter arg[2] = {
{data->x, hash->x, data->len, hash->len, algId},
{data->x, hash->x, data->len, hash->len, algId}
};
for (uint32_t i = 0; i < threadNum; i++) {
ret = pthread_create(&thrd[i], NULL, (void *)Sha2MultiThreadTest, &arg[i]);
ASSERT_EQ(ret, 0);
}
for (uint32_t i = 0; i < threadNum; i++) {
pthread_join(thrd[i], NULL);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SHA2_COPY_CTX_FUNC_TC001
* @title SHA2 copy ctx function test.
* @precon nan
* @brief
* 1. Create the context ctx of md algorithm, expected result 1
* 2. Call to CRYPT_EAL_MdCopyCtx method to copy ctx, expected result 2
* 2. Call to CRYPT_EAL_MdCopyCtx method to copy a null ctx, expected result 3
* 3. Calculate the hash of msg, and compare the calculated result with hash vector, expected result 4
* 4. Call to CRYPT_EAL_MdDupCtx method to copy ctx, expected result 5
* 3. Calculate the hash of msg, and compare the calculated result with hash vector, expected result 6
* @expect
* 1. Success, the context is not null.
* 2. CRYPT_SUCCESS
* 3. CRYPT_NULL_INPUT
* 4. Success, the context is not null.
* 5. CRYPT_SUCCESS
* 6. Success, the hashs are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SHA2_COPY_CTX_FUNC_TC001(int id, Hex *msg, Hex *hash)
{
if (IsMdAlgDisabled(id)) {
SKIP_TEST();
}
TestMemInit();
CRYPT_EAL_MdCTX *cpyCtx = NULL;
CRYPT_EAL_MdCTX *dupCtx = NULL;
CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdNewCtx(id);
ASSERT_TRUE(ctx != NULL);
uint8_t output[SHA2_OUTPUT_MAXSIZE];
uint32_t outLen = SHA2_OUTPUT_MAXSIZE;
dupCtx=CRYPT_EAL_MdDupCtx(cpyCtx);
ASSERT_TRUE(dupCtx == NULL);
ASSERT_EQ(CRYPT_MD_MAX, CRYPT_EAL_MdGetId(dupCtx));
ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, ctx), CRYPT_NULL_INPUT);
cpyCtx = CRYPT_EAL_MdNewCtx(id);
ASSERT_TRUE(cpyCtx != NULL);
ASSERT_TRUE(dupCtx == NULL);
ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, dupCtx), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdInit(cpyCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(cpyCtx, msg->x, msg->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(cpyCtx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(id, cpyCtx->id);
ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
dupCtx=CRYPT_EAL_MdDupCtx(ctx);
ASSERT_TRUE(dupCtx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(dupCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(dupCtx, msg->x, msg->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(dupCtx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(id, CRYPT_EAL_MdGetId(dupCtx));
ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
CRYPT_EAL_MdFreeCtx(cpyCtx);
CRYPT_EAL_MdFreeCtx(dupCtx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SHA2_DEFAULT_PROVIDER_FUNC_TC001
* @title Default provider testing
* @precon nan
* @brief
* Load the default provider and use the test vector to test its correctness
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SHA2_DEFAULT_PROVIDER_FUNC_TC001(int id, Hex *msg, Hex *hash)
{
TestMemInit();
CRYPT_EAL_MdCTX *ctx = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, id, "provider=default");
#else
ctx = CRYPT_EAL_MdNewCtx(id);
#endif
ASSERT_TRUE(ctx != NULL);
uint8_t output[SHA2_OUTPUT_MAXSIZE];
uint32_t outLen = SHA2_OUTPUT_MAXSIZE;
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, msg->x, msg->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/sha2/test_suite_sdv_eal_md_sha2.c | C | unknown | 15,895 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <pthread.h>
#include "crypt_eal_md.h"
#include "bsl_sal.h"
#include "eal_md_local.h"
#include "crypt_algid.h"
#include "crypt_errno.h"
#include "crypt_sha3.h"
#include "securec.h"
/* END_HEADER */
// 100 is greater than the digest length of all SHA algorithms.
#define SHA3_OUTPUT_MAXSIZE 100
typedef struct {
uint8_t *data;
uint8_t *hash;
uint32_t dataLen;
uint32_t hashLen;
CRYPT_MD_AlgId id;
} ThreadParameter;
void Sha3MultiThreadTest(void *arg)
{
ThreadParameter *threadParameter = (ThreadParameter *)arg;
uint32_t outLen = SHA3_OUTPUT_MAXSIZE;
uint8_t out[SHA3_OUTPUT_MAXSIZE];
CRYPT_EAL_MdCTX *ctx = NULL;
ctx = CRYPT_EAL_MdNewCtx(threadParameter->id);
ASSERT_TRUE(ctx != NULL);
for (uint32_t i = 0; i < 10; i++) {
ASSERT_TRUE(CRYPT_EAL_MdInit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MdUpdate(ctx, threadParameter->data, threadParameter->dataLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MdFinal(ctx, out, &outLen) == CRYPT_SUCCESS);
ASSERT_COMPARE("hash result cmp", out, outLen, threadParameter->hash, threadParameter->hashLen);
}
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/**
* @test SDV_CRYPT_EAL_SHA3_API_TC001
* @title SHA3 get the digest length test.
* @precon nan
* @brief
* Call CRYPT_EAL_MdGetDigestSize to get the digest length.
* @expect
* The results are correct.
*
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SHA3_API_TC001(void)
{
// The length of the SHA3_224 digest is 28.
ASSERT_EQ(CRYPT_EAL_MdGetDigestSize(CRYPT_MD_SHA3_224), 28);
// The length of the SHA3_256 digest is 32.
ASSERT_EQ(CRYPT_EAL_MdGetDigestSize(CRYPT_MD_SHA3_256), 32);
// The length of the SHA3_384 digest is 48.
ASSERT_EQ(CRYPT_EAL_MdGetDigestSize(CRYPT_MD_SHA3_384), 48);
// The length of the SHA3_512 digest is 64.
ASSERT_EQ(CRYPT_EAL_MdGetDigestSize(CRYPT_MD_SHA3_512), 64);
// The length of the SHAKE128 digest is 0.
ASSERT_EQ(CRYPT_EAL_MdGetDigestSize(CRYPT_MD_SHAKE128), 0);
// The length of the SHAKE256 digest is 0.
ASSERT_EQ(CRYPT_EAL_MdGetDigestSize(CRYPT_MD_SHAKE256), 0);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SHA3_API_TC002
* @title update and final test.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdDeinit the null CTX, expected result 1.
* 2.Call CRYPT_EAL_MdNewCtx create the CTX, expected result 2.
* 3.Call CRYPT_EAL_MdUpdate and CRYPT_EAL_MdFinal before initialization, expected result 3.
* 4.Call CRYPT_EAL_MdUpdate and CRYPT_EAL_MdFinal use null pointer, expected result 4.
* 5.Call CRYPT_EAL_MdUpdate and CRYPT_EAL_MdFinal normally, expected result 5.
* 6.Call CRYPT_EAL_MdDeinit the CTX, expected result 6.
* @expect
* 1.Return CRYPT_NULL_INPUT
* 2.Create successful.
* 3.Return CRYPT_EAL_ERR_STATE.
* 4.Return CRYPT_NULL_INPUT.
* 5.Successful.
* 6.Return CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SHA3_API_TC002(int algId)
{
TestMemInit();
CRYPT_EAL_MdCTX *sha3Ctx = NULL;
ASSERT_EQ(CRYPT_EAL_MdDeinit(sha3Ctx), CRYPT_NULL_INPUT);
uint8_t data[10] = {0x0e};
uint32_t dataLen = 1;
uint8_t output[SHA3_OUTPUT_MAXSIZE];
uint32_t outLen = SHA3_OUTPUT_MAXSIZE;
sha3Ctx = CRYPT_EAL_MdNewCtx(algId);
ASSERT_TRUE(sha3Ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdUpdate(sha3Ctx, data, dataLen), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_MdFinal(sha3Ctx, output, &outLen), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_MdInit(sha3Ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(NULL, data, dataLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdUpdate(sha3Ctx, NULL, dataLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdUpdate(sha3Ctx, data, dataLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(NULL, output, &outLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdFinal(sha3Ctx, NULL, &outLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdFinal(sha3Ctx, output, NULL), CRYPT_NULL_INPUT);
outLen = CRYPT_EAL_MdGetDigestSize(algId) - 1;
ASSERT_EQ(CRYPT_EAL_MdFinal(sha3Ctx, output, &outLen), CRYPT_SHA3_OUT_BUFF_LEN_NOT_ENOUGH);
outLen = CRYPT_EAL_MdGetDigestSize(algId);
ASSERT_EQ(CRYPT_EAL_MdFinal(sha3Ctx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdGetId(sha3Ctx), algId);
ASSERT_EQ(CRYPT_EAL_MdDeinit(sha3Ctx), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MdFreeCtx(sha3Ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SHA3_FUNC_TC001
* @title Split the data and update test.
* @precon nan
* @brief
* 1.Create two ctx and initialize them, expected result 1.
* 2.Use ctx1 to update data 100 times, expected result 2.
* 3.Use ctx2 to update all data at once, expected result 3.
* 4.Compare two outputs, expected result 4.
* @expect
* 1.Successful.
* 2.Successful.
* 3.Successful.
* 4.The results are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SHA3_FUNC_TC001(int algId)
{
TestMemInit();
CRYPT_EAL_MdCTX *ctx1 = NULL;
CRYPT_EAL_MdCTX *ctx2 = NULL;
ctx1 = CRYPT_EAL_MdNewCtx(algId);
ASSERT_TRUE(ctx1 != NULL);
ctx2 = CRYPT_EAL_MdNewCtx(algId);
ASSERT_TRUE(ctx2 != NULL);
// 100! = 5050
uint8_t input[5050];
uint32_t inLenTotal = 0;
uint32_t inLenBase;
uint8_t out1[SHA3_OUTPUT_MAXSIZE]; // 100 is greater than the digest length of all SHA algorithms.
uint8_t out2[SHA3_OUTPUT_MAXSIZE];
uint32_t outLen = CRYPT_EAL_MdGetDigestSize(algId);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx2), CRYPT_SUCCESS);
// update 100 times.
for (inLenBase = 1; inLenBase <= 100; inLenBase++) {
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx1, input + inLenTotal, inLenBase), CRYPT_SUCCESS);
inLenTotal += inLenBase;
}
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx1, out1, &outLen), CRYPT_SUCCESS);
outLen = CRYPT_EAL_MdGetDigestSize(algId);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx2, input, inLenTotal), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx2, out2, &outLen), CRYPT_SUCCESS);
outLen = CRYPT_EAL_MdGetDigestSize(algId);
ASSERT_EQ(memcmp(out1, out2, outLen), 0);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx1);
CRYPT_EAL_MdFreeCtx(ctx2);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SHA3_FUNC_TC002
* @title Test multi-thread hash calculation.
* @precon nan
* @brief
* 1.Create two threads and calculate the hash, expected result 1.
* 2.Compare the result to the expected value, expected result 2.
* @expect
* 1.Hash calculation succeeded.
* 2.The results are as expected.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SHA3_FUNC_TC002(int algId, Hex *data, Hex *hash)
{
int ret;
TestMemInit();
const uint32_t threadNum = 2;
pthread_t thrd[2];
ThreadParameter arg[2] = {
{data->x, hash->x, data->len, hash->len, algId},
{data->x, hash->x, data->len, hash->len, algId}
};
for (uint32_t i = 0; i < threadNum; i++) {
ret = pthread_create(&thrd[i], NULL, (void *)Sha3MultiThreadTest, &arg[i]);
ASSERT_TRUE(ret == 0);
}
for (uint32_t i = 0; i < threadNum; i++) {
pthread_join(thrd[i], NULL);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SHA3_FUNC_TC003
* @title Standard vector test.
* @precon nan
* @brief
* 1.Calculate the hash of the data and compare it with the standard vector, expected result 1.
* 2.Call CRYPT_EAL_Md to calculate the hash value, expected result 2.
* @expect
* 1.The results are the same.
* 2.The results are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SHA3_FUNC_TC003(int algId, Hex *in, Hex *digest)
{
TestMemInit();
CRYPT_EAL_MdCTX *ctx = NULL;
uint8_t out[SHA3_OUTPUT_MAXSIZE];
uint32_t outLen = SHA3_OUTPUT_MAXSIZE;
ctx = CRYPT_EAL_MdNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, in->x, in->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(outLen, digest->len);
ASSERT_EQ(memcmp(out, digest->x, digest->len), 0);
ASSERT_EQ(CRYPT_EAL_Md(algId, in->x, in->len, out, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(memcmp(out, digest->x, digest->len), 0);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SHA3_FUNC_TC004
* @title Standard vector test of the SHAKE algorithm.
* @precon nan
* @brief
* Calculate the hash of the data and compare it with the standard vector.
* @expect
* The results are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SHA3_FUNC_TC004(int algId, Hex *in, Hex *digest)
{
TestMemInit();
CRYPT_EAL_MdCTX *ctx = NULL;
uint8_t out[SHA3_OUTPUT_MAXSIZE];
uint32_t outLen = SHA3_OUTPUT_MAXSIZE;
ctx = CRYPT_EAL_MdNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, in->x, in->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(memcmp(out, digest->x, digest->len), 0);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SHA3_FUNC_TC005
* @title Standard vector test of the SHAKE algorithm.
* @precon nan
* @brief
* Calculate the hash of the data and compare it with the standard vector.
* @expect
* The results are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SHA3_FUNC_TC005(int algId, Hex *in, Hex *digest, int isProvider)
{
TestMemInit();
CRYPT_EAL_MdCTX *ctx = NULL;
uint8_t out[SHA3_OUTPUT_MAXSIZE];
uint32_t outLen = SHA3_OUTPUT_MAXSIZE;
#ifdef HITLS_CRYPTO_PROVIDER
if (isProvider) {
ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, algId, "provider=default");
} else
#endif
{
(void)isProvider;
ctx = CRYPT_EAL_MdNewCtx(algId);
}
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, in->x, in->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdSqueeze(ctx, out, outLen), CRYPT_SUCCESS);
ASSERT_EQ(memcmp(out, digest->x, digest->len), 0);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SHA3_FUNC_TC006
* @title Standard vector test of the SHAKE algorithm.
* @precon nan
* @brief
* Calculate the hash of the data and compare it with the standard vector.
* @expect
* The results are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SHA3_FUNC_TC006(int algId, Hex *in, int outLen, Hex *digest, int isProvider)
{
TestMemInit();
CRYPT_EAL_MdCTX *ctx = NULL;
int32_t squeezeLen = digest->len / 3;
uint8_t *out = malloc(outLen);
ASSERT_TRUE(out != NULL);
#ifdef HITLS_CRYPTO_PROVIDER
if (isProvider) {
ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, algId, "provider=default");
} else
#endif
{
(void)isProvider;
ctx = CRYPT_EAL_MdNewCtx(algId);
}
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, in->x, in->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdSqueeze(ctx, out, squeezeLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdSqueeze(ctx, out + squeezeLen, squeezeLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdSqueeze(ctx, out + squeezeLen * 2, squeezeLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdSqueeze(ctx, out + squeezeLen * 3, outLen - squeezeLen * 3), CRYPT_SUCCESS);
ASSERT_EQ(memcmp(out, digest->x, digest->len), 0);
EXIT:
free(out);
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SHA3_COPY_CTX_FUNC_TC001
* @title SHA3 copy ctx function test.
* @precon nan
* @brief
* 1. Create the context ctx of md algorithm, expected result 1
* 2. Call to CRYPT_EAL_MdCopyCtx method to copy ctx, expected result 2
* 2. Call to CRYPT_EAL_MdCopyCtx method to copy a null ctx, expected result 3
* 3. Calculate the hash of msg, and compare the calculated result with hash vector, expected result 4
* 4. Call to CRYPT_EAL_MdDupCtx method to copy ctx, expected result 5
* 3. Calculate the hash of msg, and compare the calculated result with hash vector, expected result 6
* @expect
* 1. Success, the context is not null.
* 2. CRYPT_SUCCESS
* 3. CRYPT_NULL_INPUT
* 4. Success, the context is not null.
* 5. CRYPT_SUCCESS
* 6. Success, the hashs are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SHA3_COPY_CTX_FUNC_TC001(int id, Hex *msg, Hex *hash)
{
TestMemInit();
CRYPT_EAL_MdCTX *cpyCtx = NULL;
CRYPT_EAL_MdCTX *dupCtx = NULL;
CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdNewCtx(id);
ASSERT_TRUE(ctx != NULL);
uint8_t output[SHA3_OUTPUT_MAXSIZE];
uint32_t outLen = SHA3_OUTPUT_MAXSIZE;
dupCtx=CRYPT_EAL_MdDupCtx(cpyCtx);
ASSERT_TRUE(dupCtx == NULL);
ASSERT_EQ(CRYPT_MD_MAX, CRYPT_EAL_MdGetId(dupCtx));
cpyCtx = CRYPT_EAL_MdNewCtx(id);
ASSERT_TRUE(cpyCtx != NULL);
ASSERT_TRUE(dupCtx == NULL);
ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, dupCtx), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdInit(cpyCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(cpyCtx, msg->x, msg->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(cpyCtx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(id, cpyCtx->id);
if (ctx->id != CRYPT_MD_SHAKE128 && ctx->id != CRYPT_MD_SHAKE256) {
ASSERT_TRUE(outLen == hash->len);
}
ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
dupCtx=CRYPT_EAL_MdDupCtx(ctx);
ASSERT_TRUE(dupCtx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(dupCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(dupCtx, msg->x, msg->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(dupCtx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(id, CRYPT_EAL_MdGetId(dupCtx));
ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
CRYPT_EAL_MdFreeCtx(cpyCtx);
CRYPT_EAL_MdFreeCtx(dupCtx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SHA3_DEFAULT_PROVIDER_FUNC_TC001
* @title Default provider testing
* @precon nan
* @brief
* Load the default provider and use the test vector to test its correctness
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SHA3_DEFAULT_PROVIDER_FUNC_TC001(int id, Hex *msg, Hex *hash)
{
TestMemInit();
CRYPT_EAL_MdCTX *ctx = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, id, "provider=default");
#else
ctx = CRYPT_EAL_MdNewCtx(id);
#endif
ASSERT_TRUE(ctx != NULL);
uint8_t output[SHA3_OUTPUT_MAXSIZE];
uint32_t outLen = SHA3_OUTPUT_MAXSIZE;
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, msg->x, msg->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SHA3_FUNC_TC007
* @title Standard vector test of the SHAKE algorithm.
* @precon nan
* @brief
* Calculate the hash of the data and compare it with the standard vector.
* @expect
* The results are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SHA3_FUNC_TC007(int algId, int outLen, Hex *in, Hex *digest)
{
TestMemInit();
CRYPT_EAL_MdCTX *ctx = NULL;
int32_t squeezeLen = 130;
uint32_t tmpLen = outLen;
uint8_t *out1 = malloc(outLen);
uint8_t *out2 = malloc(outLen);
ASSERT_TRUE(out1 != NULL && out2 != NULL);
ctx = CRYPT_EAL_MdNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, in->x, in->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdSqueeze(ctx, out1, squeezeLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdSqueeze(ctx, out1 + squeezeLen, outLen - squeezeLen), CRYPT_SUCCESS);
CRYPT_EAL_MdFreeCtx(ctx);
ctx = CRYPT_EAL_MdNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, in->x, in->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out2, &tmpLen), CRYPT_SUCCESS);
ASSERT_EQ(memcmp(out1, out2, outLen), 0);
ASSERT_EQ(memcmp(out1, digest->x, digest->len), 0);
EXIT:
free(out1);
free(out2);
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/sha3/test_suite_sdv_eal_md_sha3.c | C | unknown | 16,987 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "eal_mac_local.h"
#include <limits.h>
#include <pthread.h>
#include "crypt_siphash.h"
#include "securec.h"
#include "crypt_eal_mac.h"
#include "crypt_errno.h"
#include "bsl_sal.h"
#define DATA_MAX_LEN (65538) // siphash_update(key, data), data update len < DATA_MAX_LEN 2^16 = 65536
/* END_HEADER */
/* @
* @test SDV_CRYPT_EAL_SIPHASH_API_TC001
* @spec -
* @title Impact of the algorithm ID on the new interface_valid algorithm ID and invalid algorithm ID
* @precon nan
* @brief 1. Invoke the new interface with the input parameter CRYPT_MAC_SIPHASH_SHA1. Expected result 1 is obtained.
2. Invoke the new interface with the input parameter CRYPT_MAC_SIPHASH64. Expected result 2 is obtained.
3. Invoke the new interface with the input parameter CRYPT_MAC_SIPHASH128. Expected result 3 is obtained.
4. Invoke the new interface with the input parameter CRYPT_MAC_MAX. Expected result 7 is obtained.
* @expect 1. If the operation is successful, the CRYPT_EAL_MacCtx pointer is returned.
2. If the operation is successful, the CRYPT_EAL_MacCtx pointer is returned.
3. If the operation is successful, the CRYPT_EAL_MacCtx pointer is returned.
4. If the operation fails, NULL is returned.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SIPHASH_API_TC001(void)
{
TestMemInit();
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(CRYPT_MAC_SIPHASH64);
ASSERT_TRUE(ctx != NULL);
CRYPT_EAL_MacFreeCtx(ctx);
ctx = CRYPT_EAL_MacNewCtx(CRYPT_MAC_SIPHASH128);
ASSERT_TRUE(ctx != NULL);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_SIPHASH_API_TC002
* @spec -
* @title Impact of Input Parameters on the Init Interface (Valid and Invalid Input Parameters)
* @precon nan
* @brief 1. Invoke the new interface. Expected result 1 is obtained.
2. Invoke the init interface and set ctx to NULL. Expected result 2 is obtained.
3. Invoke the init interface with key set to NULL and len set to a value other than 0. Expected result 3 is obtained.
4. Invoke the init interface with key set to NULL and len set to 0. Expected result 4 is obtained.
5. Invoke the init interface. The key is not NULL and the len is 0. Expected result 5 is obtained.
6. Invoke the init interface and ensure that the input parameters are normal. Expected result 6 is obtained.
* @expect 1. If the new operation is successful, the CRYPT_EAL_MacCtx pointer is returned.
2. If the init operation fails, CRYPT_NULL_INPUT is returned.
3. If the init operation fails, CRYPT_NULL_INPUT is returned.
4. If the init operation fails, CRYPT_INVALID_ARG is returned.
5. If the init operation fails, CRYPT_INVALID_ARG is returned.
6. If the init operation is successful, CRYPT_SUCCESS is returned.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SIPHASH_API_TC002(int algId)
{
TestMemInit();
uint8_t key[SIPHASH_KEY_SIZE];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(NULL, key, SIPHASH_KEY_SIZE) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, NULL, SIPHASH_KEY_SIZE) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, NULL, 0) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, 0) == CRYPT_INVALID_ARG);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, SIPHASH_KEY_SIZE) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_SIPHASH_API_TC003
* @spec -
* @title Impact of the ctx status on the init interface
* @precon nan
* @brief 1. Invoke the new interface. Expected result 1 is obtained.
2. Invoke the init interface. Expected result 2 is obtained.
3. Invoke the init interface repeatedly. Expected result 3 is obtained.
4. Invoke the update interface. Expected result 4 is obtained.
5. Invoke the init interface. Expected result 5 is obtained.
6. Invoke the final interface. Expected result 6 is obtained.
7. Invoke the init interface. Expected result 7 is obtained.
8. Invoke the deinit interface. Expected result 8 is obtained.
9. Invoke the init interface. Expected result 9 is obtained.
10. Invoke the reinit interface. Expected result 10 is obtained.
11. Invoke the init interface. Expected result 11 is obtained.
* @expect 1. If the new operation is successful, the CRYPT_EAL_MacCtx pointer is returned.
2. If the init operation is successful, CRYPT_SUCCESS is returned.
3. If the init operation is successful, CRYPT_SUCCESS is returned.
4. If the update is successful, CRYPT_SUCCESS is returned.
5. If the init operation is successful, CRYPT_SUCCESS is returned.
6. If the final operation is successful, CRYPT_SUCCESS is returned.
7. If the init operation is successful, CRYPT_SUCCESS is returned.
8.
9. If the init operation is successful, CRYPT_SUCCESS is returned.
10. The reinit operation is successful and CRYPT_SUCCESS is returned.
11. If the init operation is successful, CRYPT_SUCCESS is returned.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SIPHASH_API_TC003(int algId)
{
TestMemInit();
uint8_t key[SIPHASH_KEY_SIZE];
uint32_t macLen = TestGetMacLen(algId);
uint8_t mac[macLen];
uint8_t message[] = "e1476ccebc8fd7a5f5d1b944bd488bafa08caa713795f87e0364227b473b1cd5d83d0c72ce4ebab3e187";
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, SIPHASH_KEY_SIZE) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, SIPHASH_KEY_SIZE) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, message, sizeof(message)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, SIPHASH_KEY_SIZE) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, SIPHASH_KEY_SIZE) == CRYPT_SUCCESS);
CRYPT_EAL_MacDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, SIPHASH_KEY_SIZE) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, SIPHASH_KEY_SIZE) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_SIPHASH_API_TC004
* @spec -
* @title Impact of Input Parameters on the Update Interface (Valid and Invalid Input Parameters)
* @precon nan
* @brief 1. Invoke the new interface. Expected result 1 is obtained.
2. Invoke the init interface. Expected result 2 is obtained.
3. Invoke the update interface and set ctx to NULL. Expected result 3 is obtained.
4. Invoke the update interface. Set in to NULL and len to a value other than 0. Expected result 4 is obtained.
5. Invoke the update interface. Set in to a value other than NULL and len to 0. Expected result 5 is obtained.
6. Invoke the update interface. Set in to NULL and len to 0. Expected result 6 is obtained.
7. Invoke the update interface and ensure that the input parameters are correct. Expected result 7 is obtained.
* @expect 1. If the new operation is successful, the CRYPT_EAL_MacCtx pointer is returned.
2. If the init operation is successful, CRYPT_SUCCESS is returned.
3. If the update fails, CRYPT_NULL_INPUT is returned.
4. If the update fails, CRYPT_NULL_INPUT is returned.
5. If the update is successful, CRYPT_SUCCESS is returned.
6. If the update is successful, CRYPT_SUCCESS is returned.
7. If the update is successful, CRYPT_SUCCESS is returned.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SIPHASH_API_TC004(int algId)
{
TestMemInit();
uint8_t key[SIPHASH_KEY_SIZE];
uint8_t message[] = "e1476ccebc8fd7a5f5d1b944bd488bafa08caa713795f87e0364227b473b1cd5d83d0c72ce4ebab3e187";
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, SIPHASH_KEY_SIZE) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(NULL, message, sizeof(message)) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, NULL, sizeof(message)) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, message, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, message, sizeof(message)) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_SIPHASH_API_TC005
* @spec -
* @title Impact of CTX status transition on the update interface_different CTX status
* @precon nan
* @brief 1. Invoke the new interface. Expected result 1 is obtained.
2. Invoke the update interface. Expected result 2 is obtained.
3. Invoke the init interface. Expected result 3 is obtained.
4. Invoke the update interface. Expected result 4 is obtained.
5. Invoke the final interface. Expected result 5 is obtained.
6. Invoke the update interface. Expected result 6 is obtained.
7. Invoke the update interface repeatedly. Expected result 7 is obtained.
8. Invoke the deinit interface. Expected result 8 is obtained.
9. Invoke the update interface. Expected result 9 is obtained.
10. Invoke the final interface. Expected result 10 is obtained.
11. Invoke the init interface. Expected result 11 is obtained.
12. Invoke the update interface. Expected result 12 is obtained.
13. Invoke the reinit interface. Expected result 13 is obtained.
14. Invoke the update interface. Expected result 14 is obtained.
15. Invoke the update interface repeatedly. (Expected result 15)
* @expect 1. If the new operation is successful, the CRYPT_EAL_MacCtx pointer is returned.
2. If the update fails, CRYPT_EAL_ERR_STATE is returned.
3. If the init operation is successful, CRYPT_SUCCESS is returned.
4. If the update is successful, CRYPT_SUCCESS is returned.
5. If the final operation is successful, CRYPT_SUCCESS is returned.
6. If the update fails, CRYPT_EAL_ERR_STATE is returned.
7. If the update fails, CRYPT_EAL_ERR_STATE is returned.
8.
9. If the update fails, CRYPT_EAL_ERR_STATE is returned.
10. If the final operation is successful, CRYPT_EAL_ERR_STATE is returned.
11. If the init operation is successful, CRYPT_SUCCESS is returned.
12. If the update is successful, CRYPT_SUCCESS is returned.
13. The reinit operation is successful and CRYPT_SUCCESS is returned.
14. If the update is successful, CRYPT_SUCCESS is returned.
15. If the update is successful, CRYPT_SUCCESS is returned.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SIPHASH_API_TC005(int algId)
{
TestMemInit();
uint8_t key[SIPHASH_KEY_SIZE];
uint32_t macLen = TestGetMacLen(algId);
uint8_t mac[macLen];
uint8_t message[] = "e1476ccebc8fd7a5f5d1b944bd488bafa08caa713795f87e0364227b473b1cd5d83d0c72ce4ebab3e187";
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, message, sizeof(message)) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, SIPHASH_KEY_SIZE) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, message, sizeof(message)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, message, sizeof(message)) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, message, sizeof(message)) == CRYPT_EAL_ERR_STATE);
CRYPT_EAL_MacDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, message, sizeof(message)) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, SIPHASH_KEY_SIZE) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, message, sizeof(message)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, message, sizeof(message)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, message, sizeof(message)) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_SIPHASH_API_TC006
* @spec -
* @title Impact of input parameters on the final interface: valid and invalid input parameters
* @precon nan
* @brief 1. Invoke the new interface. Expected result 1 is obtained.
2. Invoke the init interface. Expected result 2 is obtained.
3. Invoke the final interface and set ctx to NULL. Expected result 3 is obtained.
4. Invoke the final interface and set the value of out to NULL. Expected result 4 is obtained.
5. Invoke the final interface and set len to NULL. Expected result 5 is obtained.
6. Invoke the final interface. The value of len is less than the MAC data length. Expected result 6 is obtained.
7. Invoke the final interface. The value of len is greater than the MAC data length. Expected result 7 is obtained.
8. Invoke the init interface. Expected result 8 is obtained.
9. Invoke the final interface. The input parameters are normal. Expected result 9 is obtained.
* @expect 1. If the new operation is successful, the CRYPT_EAL_MacCtx pointer is returned.
2. If the init operation is successful, CRYPT_SUCCESS is returned.
3. If the final operation fails, CRYPT_NULL_INPUT is returned.
4. If the final operation fails, CRYPT_NULL_INPUT is returned.
5. If the final operation fails, CRYPT_NULL_INPUT is returned.
6. If the final operation fails, CRYPT_SIPHASH_OUT_BUFF_LEN_NOT_ENOUGH is returned.
7. If the final operation is successful, CRYPT_SUCCESS is returned.
8. If the init operation is successful, CRYPT_SUCCESS is returned.
9. If the final operation is successful, CRYPT_SUCCESS is returned.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SIPHASH_API_TC006(int algId)
{
TestMemInit();
uint8_t key[SIPHASH_KEY_SIZE];
uint32_t macLen = TestGetMacLen(algId);
uint8_t mac[macLen];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, SIPHASH_KEY_SIZE) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(NULL, mac, &macLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, NULL, &macLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, NULL) == CRYPT_NULL_INPUT);
macLen = TestGetMacLen(algId) - 1;
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SIPHASH_OUT_BUFF_LEN_NOT_ENOUGH);
macLen = TestGetMacLen(algId) + 1;
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, SIPHASH_KEY_SIZE) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_SIPHASH_API_TC007
* @spec -
* @title Impact of CTX status transition on the final interface_different CTX status
* @precon nan
* @brief 1. Invoke the new interface. Expected result 1 is obtained.
2. Invoke the final interface. Expected result 2 is obtained.
3. Repeat the final interface. Expected result 3 is obtained.
4. Invoke the update interface. Expected result 4 is obtained.
5. Invoke the init interface. Expected result 5 is obtained.
6. Invoke the final interface. Expected result 6 is obtained.
7. Invoke the init interface. Expected result 7 is obtained.
8. Invoke the update interface. Expected result 8 is obtained.
9. Invoke the final interface. Expected result 9 is obtained.
10. Invoke the deinit interface. Expected result 10 is obtained.
11. Invoke the final interface. Expected result 11 is obtained.
12. Invoke the init interface. Expected result 12 is obtained.
13. Invoke the reinit interface. Expected result 13 is obtained.
14. Invoke the final interface. Expected result 14 is obtained.
15. Invoke the final interface repeatedly. Expected result 15 is obtained.
* @expect 1. If the new operation is successful, the CRYPT_EAL_MacCtx pointer is returned.
2. If the final operation fails, CRYPT_EAL_ERR_STATE is returned.
3. If the final operation fails, CRYPT_EAL_ERR_STATE is returned.
4. If the update fails, YPT_EAL_ERR_STATE is returned.
5. If the init operation is successful, CRYPT_SUCCESS is returned.
6. If the final operation is successful, CRYPT_SUCCESS is returned.
7. If the init operation is successful, CRYPT_SUCCESS is returned.
8. If the update is successful, CRYPT_SUCCESS is returned.
9. If the final operation is successful, CRYPT_SUCCESS is returned.
10.
11. If the final operation fails, CRYPT_EAL_ERR_STATE is returned.
12. If the init operation is successful, CRYPT_SUCCESS is returned.
13. The reinit operation is successful and CRYPT_SUCCESS is returned.
14. If the final operation is successful, CRYPT_SUCCESS is returned.
15. If the final operation fails, RYPT_EAL_ERR_STATE is returned.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SIPHASH_API_TC007(int algId, Hex *key1, Hex *key2, Hex *data2)
{
TestMemInit();
uint32_t macLen = TestGetMacLen(algId);
uint8_t mac[macLen];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data2->x, data2->len) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(key1->len == SIPHASH_KEY_SIZE);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key1->x, key1->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_TRUE(key2->len == SIPHASH_KEY_SIZE);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key2->x, key2->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data2->x, data2->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
CRYPT_EAL_MacDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key2->x, key2->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_EAL_ERR_STATE);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_SIPHASH_API_TC008
* @spec -
* @title Impact of input parameters on the getMacLen interface: valid and invalid input parameters
* @precon nan
* @brief 1. Invoke the new interface. Expected result 1 is obtained.
2. Invoke the init interface. Expected result 2 is obtained.
3. Invoke the getLen interface and set the input parameter to NULL. Expected result 3 is obtained.
4. Invoke the getLen interface and set normal input parameters. Expected result 4 is obtained.
* @expect 1. If the new operation is successful, the CRYPT_EAL_MacCtx pointer is returned.
2. If the init operation is successful, CRYPT_SUCCESS is returned.
3. If the operation fails, 0 is returned.
4. If the operation is successful, the MAC length corresponding to the context is returned.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SIPHASH_API_TC008(int algId)
{
TestMemInit();
uint8_t key[SIPHASH_KEY_SIZE];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, SIPHASH_KEY_SIZE) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(NULL) == 0);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == TestGetMacLen(algId));
uint32_t result = 0;
ASSERT_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_GET_MACLEN, &result, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(result == TestGetMacLen(algId));
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_SIPHASH_API_TC009
* @spec -
* @title Impact of the CTX state on the getMacLen interface_Impact of the CTX state on the interface
* @precon nan
* @brief 1. Invoke the new interface. Expected result 1 is obtained.
2. Invoke the getLen interface. Expected result 2 is obtained.
3. Invoke the init interface. Expected result 3 is obtained.
4. Invoke the getLen interface. Expected result 4 is obtained.
5. Invoke the update interface. Expected result 5 is obtained.
6. Invoke the getLen interface. Expected result 6 is obtained.
7. Invoke the final interface. Expected result 7 is obtained.
8. Invoke the getLen interface. Expected result 8 is obtained.
9. Invoke the deinit interface. Expected result 9 is obtained.
10. Invoke the getLen interface. Expected result 10 is obtained.
11. Invoke the reinit interface. Expected result 11 is obtained.
12. Invoke the getLen interface. Expected result 12 is obtained.
* @expect 1. If the new operation is successful, the CRYPT_EAL_MacCtx pointer is returned.
2. If the operation is successful, the MAC length corresponding to the context is returned.
3. If the init operation is successful, CRYPT_SUCCESS is returned.
4. If the operation is successful, the MAC length corresponding to the context is returned.
5. The update is successful and CRYPT_SUCCESS is returned.
6. If the operation is successful, the MAC length corresponding to the context is returned.
7. If the final operation is successful, CRYPT_SUCCESS is returned.
8. If the operation is successful, the MAC address length corresponding to the context is returned.
9.
10. If the operation is successful, the MAC address length corresponding to the context is returned.
11. If reinit fails, CRYPT_EAL_ERR_STATE is returned.
12. If the operation is successful, the MAC length corresponding to the context is returned.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SIPHASH_API_TC009(int algId)
{
TestMemInit();
uint8_t key[SIPHASH_KEY_SIZE];
uint32_t macLen = TestGetMacLen(algId);
uint8_t mac[macLen];
uint8_t data[] = "5f81bd275320d97416e5e50d5d185d5542a157778b2d05521f27805b925e4f187d06829a2efd407ba11691";
uint32_t dataLen = sizeof(data);
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == TestGetMacLen(algId));
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, SIPHASH_KEY_SIZE) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == TestGetMacLen(algId));
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == TestGetMacLen(algId));
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == TestGetMacLen(algId));
CRYPT_EAL_MacDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == TestGetMacLen(algId));
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_GetMacLen(ctx) == TestGetMacLen(algId));
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_SIPHASH_API_TC010
* @spec -
* @title Deinit Interface Test_Deinit Interface Test
* @precon nan
* @brief 1. Invoke the new interface. Expected result 1 is obtained.
2. Invoke the init interface. Expected result 2 is obtained.
3. Invoke the deinit interface. Expected result 3 is obtained.
4. Invoke the deinit interface repeatedly. Expected result 4 is obtained.
5. Invoke the init interface. Expected result 5 is obtained.
* @expect 1. If the new operation is successful, the CRYPT_EAL_MacCtx pointer is returned.
2. If the init operation is successful, CRYPT_SUCCESS is returned.
3.
4.
5. If the init operation is successful, CRYPT_SUCCESS is returned.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SIPHASH_API_TC010(int algId)
{
TestMemInit();
uint8_t key[SIPHASH_KEY_SIZE];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, SIPHASH_KEY_SIZE) == CRYPT_SUCCESS);
CRYPT_EAL_MacDeinit(ctx);
CRYPT_EAL_MacDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, SIPHASH_KEY_SIZE) == CRYPT_SUCCESS);
CRYPT_EAL_MacDeinit(NULL);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_SIPHASH_API_TC011
* @spec -
* @title Impact of Input Parameters on the Reinit Interface (Valid and Invalid Input Parameters)
* @precon nan
* @brief 1. Invoke the new interface. Expected result 1 is obtained.
2. Invoke the init interface. Expected result 2 is obtained.
3. Invoke the reinit interface. The value of ctx is NULL. Expected result 3 is obtained.
4. Invoke the reinit interface. The value of ctx is not NUL. Expected result 4 is obtained.
* @expect 1. If the new operation is successful, the CRYPT_EAL_MacCtx pointer is returned.
2. If the init operation is successful, CRYPT_SUCCESS is returned.
3. If the init operation fails, CRYPT_NULL_INPUT is returned.
4. The reinit operation is successful and CRYPT_SUCCESS is returned.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SIPHASH_API_TC011(int algId)
{
TestMemInit();
uint8_t key[SIPHASH_KEY_SIZE];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, SIPHASH_KEY_SIZE) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(NULL) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPT_EAL_SIPHASH_API_TC012
* @spec -
* @title Impact of CTX status transition on the reinit interface_different CTX status
* @precon nan
* @brief 1. Invoke the new interface. Expected result 1 is obtained.
2. Invoke the reinit interface. Expected result 2 is obtained.
3. Invoke the reinit interface repeatedly. Expected result 3 is obtained.
4. Invoke the init interface. Expected result 4 is obtained.
5. Invoke the reinit interface. Expected result 5 is obtained.
6. Invoke the reinit interface repeatedly. Expected result 6 is obtained.
7. Invoke the update interface. Expected result 7 is obtained.
8. Invoke the reinit interface. Expected result 8 is obtained.
9. Invoke the final interface. Expected result 9 is obtained.
10. Invoke the reinit interface. Expected result 10 is obtained.
11. Invoke the deinit interface. Expected result 11 is obtained.
12. Invoke the reinit interface. Expected result 12 is obtained.
* @expect 1. If the new operation is successful, the CRYPT_EAL_MacCtx pointer is returned.
2. If the reinit operation fails, CRYPT_EAL_ERR_STATE is returned.
3. If the reinit operation fails, CRYPT_EAL_ERR_STATE is returned.
4. If the init operation is successful, CRYPT_SUCCESS is returned.
5. The reinit operation is successful, and CRYPT_SUCCESS is returned.
6. The reinit operation is successful and CRYPT_SUCCESS is returned.
7. The update is successful and CRYPT_SUCCESS is returned.
8. The reinit operation is successful and CRYPT_SUCCESS is returned.
9. If the final operation is successful, CRYPT_SUCCESS is returned.
10. The reinit operation is successful, and CRYPT_SUCCESS is returned.
11.
12. If reinit fails, CRYPT_EAL_ERR_STATE is returned.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SIPHASH_API_TC012(int algId)
{
TestMemInit();
uint8_t key[SIPHASH_KEY_SIZE];
uint32_t macLen = TestGetMacLen(algId);
uint8_t mac[macLen];
uint8_t data[] = "9c520b111bb008086c5815f450a6b7b6daec0925c4b0c8cf99f9f9ddb6198000a379fcb62527d7c361ccbda2597deecdd"
"055850abc6a17251c08577b";
uint32_t dataLen = sizeof(data);
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_EAL_ERR_STATE);
ASSERT_TRUE(CRYPT_EAL_MacInit(ctx, key, SIPHASH_KEY_SIZE) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacUpdate(ctx, data, dataLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_SUCCESS);
CRYPT_EAL_MacDeinit(ctx);
ASSERT_TRUE(CRYPT_EAL_MacReinit(ctx) == CRYPT_EAL_ERR_STATE);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SIPHASH_FUN_TC005
* @title Impact of calculating the siphash MAC address when the plaintext data is all 0, all f, and null
* @precon nan
* @brief
* 1. Invoke the new interface. The expected result is successful.
* 2. Invoke the init interface. The expected result is successful.
* 3. Invoke the update interface. The expected result is successful.
* 4. Invoke the final interface. The expected result is successful.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SIPHASH_FUN_TC005(int algId, Hex *key, Hex *data)
{
TestMemInit();
uint32_t macLen = TestGetMacLen(algId);
uint8_t mac[macLen];
CRYPT_EAL_MacCtx *ctx = CRYPT_EAL_MacNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(key->len == SIPHASH_KEY_SIZE);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key->x, key->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, data->x, data->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, mac, &macLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SIPHASH_SAMEADDR_FUNC_TC001
* @title SIPHASH in/out test
* @precon nan
* @brief
* 1. Use the EAL-layer interface to perform SIPHASH calculation. All input and output addresses are the same.
* Expected result 1 is obtained.
* @expect
* 1. The calculation is successful, and the result is consistent with the MAC vector.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SIPHASH_SAMEADDR_FUNC_TC001(int algId, Hex *key, Hex *data, Hex *mac)
{
TestMacSameAddr(algId, key, data, mac);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SIPHASH_ADDR_NOT_ALIGN_FUNC_TC001
* @title SIPHASH non-address alignment test
* @precon nan
* @brief
* 1. Use the EAL layer interface to perform SIPHASH calculation. All buffer addresses are not aligned.
* Expected result 1 is obtained.
* @expect
* 1. The calculation is successful, and the result is consistent with the MAC vector.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SIPHASH_ADDR_NOT_ALIGN_FUNC_TC001(int algId, Hex *key, Hex *data, Hex *mac)
{
TestMacAddrNotAlign(algId, key, data, mac);
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/siphash/test_suite_sdv_eal_mac_siphash.c | C | unknown | 30,976 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "securec.h"
#include "bsl_err.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "crypt_algid.h"
#include "crypt_eal_pkey.h"
#include "crypt_util_rand.h"
#include "crypt_bn.h"
#include "eal_pkey_local.h"
#include "stub_replace.h"
#include "test.h"
/* END_HEADER */
uint32_t g_stubRandCounter = 0;
uint8_t **g_stubRand = NULL;
uint32_t *g_stubRandLen = NULL;
void RandInjectionInit()
{
g_stubRandCounter = 0;
g_stubRand = NULL;
g_stubRandLen = NULL;
}
void RandInjectionSet(uint8_t **rand, uint32_t *len)
{
g_stubRand = rand;
g_stubRandLen = len;
}
int32_t RandInjection(uint8_t *rand, uint32_t randLen)
{
(void)memcpy_s(rand, randLen, g_stubRand[g_stubRandCounter], randLen);
g_stubRandCounter++;
return CRYPT_SUCCESS;
}
int32_t RandInjectionEx(void *libCtx, uint8_t *rand, uint32_t randLen)
{
(void)libCtx;
return RandInjection(rand, randLen);
}
/* BEGIN_CASE */
void SDV_CRYPTO_SLH_DSA_API_NEW_TC001(void)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = NULL;
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SLH_DSA);
ASSERT_TRUE(pkey != NULL);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_SLH_DSA_API_CTRL_TC001(void)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = NULL;
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SLH_DSA);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_CTX_INFO, NULL, 0) == CRYPT_INVALID_ARG);
uint8_t context[128] = {0};
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_CTX_INFO, context, sizeof(context)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_PREHASH_FLAG, NULL, 0) == CRYPT_INVALID_ARG);
int32_t preHash = 1;
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_PREHASH_FLAG, &preHash, sizeof(preHash)) ==
CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_SLH_DSA_GENKEY_TC001(int isProvider)
{
TestMemInit();
TestRandInit();
CRYPT_EAL_PkeyCtx *pkey = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
if (isProvider == 1) {
pkey = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_SLH_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
} else
#endif
{
(void)isProvider;
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SLH_DSA);
}
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_PARA_BY_ID, NULL, 0) == CRYPT_INVALID_ARG);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SLHDSA_ERR_INVALID_ALGID);
CRYPT_PKEY_ParaId algId = CRYPT_SLH_DSA_SHA2_128S;
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_PARA_BY_ID, (void *)&algId, sizeof(algId)) ==
CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
TestRandDeInit();
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_SLH_DSA_GETSET_KEY_TC001(void)
{
TestMemInit();
TestRandInit();
CRYPT_EAL_PkeyCtx *pkey = NULL;
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SLH_DSA);
ASSERT_TRUE(pkey != NULL);
int32_t algId = CRYPT_SLH_DSA_SHA2_128S;
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, algId), CRYPT_SUCCESS);
CRYPT_EAL_PkeyPub pub;
uint8_t pubSeed[32] = {0};
uint8_t pubRoot[32] = {0};
(void)memset_s(&pub, sizeof(CRYPT_EAL_PkeyPub), 0, sizeof(CRYPT_EAL_PkeyPub));
pub.id = CRYPT_PKEY_SLH_DSA;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pub), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_NULL_INPUT);
pub.key.slhDsaPub.seed = pubSeed;
pub.key.slhDsaPub.root = pubRoot;
pub.key.slhDsaPub.len = sizeof(pubSeed);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pub), CRYPT_SLHDSA_ERR_INVALID_KEYLEN);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_SLHDSA_ERR_INVALID_KEYLEN);
CRYPT_EAL_PkeyPrv prv;
uint8_t prvSeed[32] = {0};
uint8_t prvPrf[32] = {0};
(void)memset_s(&prv, sizeof(CRYPT_EAL_PkeyPrv), 0, sizeof(CRYPT_EAL_PkeyPrv));
prv.id = CRYPT_PKEY_SLH_DSA;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prv), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_NULL_INPUT);
prv.key.slhDsaPrv.seed = prvSeed;
prv.key.slhDsaPrv.prf = prvPrf;
prv.key.slhDsaPrv.pub.seed = pubSeed;
prv.key.slhDsaPrv.pub.root = pubRoot;
prv.key.slhDsaPrv.pub.len = sizeof(pubSeed);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prv), CRYPT_SLHDSA_ERR_INVALID_KEYLEN);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_SLHDSA_ERR_INVALID_KEYLEN);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
TestRandDeInit();
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_SLH_DSA_GETSET_KEY_TC002(void)
{
TestMemInit();
TestRandInit();
CRYPT_EAL_PkeyCtx *pkey = NULL;
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SLH_DSA);
ASSERT_TRUE(pkey != NULL);
int32_t algId = CRYPT_SLH_DSA_SHA2_128S;
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, algId), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS);
CRYPT_EAL_PkeyPub pub;
uint8_t pubSeed[32] = {0};
uint8_t pubRoot[32] = {0};
(void)memset_s(&pub, sizeof(CRYPT_EAL_PkeyPub), 0, sizeof(CRYPT_EAL_PkeyPub));
pub.id = CRYPT_PKEY_SLH_DSA;
pub.key.slhDsaPub.seed = pubSeed;
pub.key.slhDsaPub.root = pubRoot;
pub.key.slhDsaPub.len = 16;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &pub), CRYPT_SUCCESS);
CRYPT_EAL_PkeyPrv prv;
uint8_t prvSeed[32] = {0};
uint8_t prvPrf[32] = {0};
(void)memset_s(&prv, sizeof(CRYPT_EAL_PkeyPrv), 0, sizeof(CRYPT_EAL_PkeyPrv));
prv.id = CRYPT_PKEY_SLH_DSA;
prv.key.slhDsaPrv.seed = prvSeed;
prv.key.slhDsaPrv.prf = prvPrf;
prv.key.slhDsaPrv.pub.seed = pubSeed;
prv.key.slhDsaPrv.pub.root = pubRoot;
prv.key.slhDsaPrv.pub.len = 16;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prv), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
TestRandDeInit();
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_SLH_DSA_GENKEY_KAT_TC001(int id, Hex *key, Hex *root)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = NULL;
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SLH_DSA);
ASSERT_TRUE(pkey != NULL);
int32_t algId = id;
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, algId), CRYPT_SUCCESS);
uint32_t keyLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GET_SLH_DSA_KEY_LEN, (void *)&keyLen, sizeof(keyLen)), CRYPT_SUCCESS);
RandInjectionInit();
uint8_t *stubRand[3] = {key->x, key->x + keyLen, key->x + keyLen * 2};
uint32_t stubRandLen[3] = {keyLen, keyLen, keyLen};
RandInjectionSet(stubRand, stubRandLen);
CRYPT_RandRegist(RandInjection);
CRYPT_RandRegistEx(RandInjectionEx);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS);
uint8_t pubSeed[32] = {0};
uint8_t pubRoot[32] = {0};
CRYPT_EAL_PkeyPub pubOut;
(void)memset_s(&pubOut, sizeof(CRYPT_EAL_PkeyPub), 0, sizeof(CRYPT_EAL_PkeyPub));
pubOut.id = CRYPT_PKEY_SLH_DSA;
pubOut.key.slhDsaPub.seed = pubSeed;
pubOut.key.slhDsaPub.root = pubRoot;
pubOut.key.slhDsaPub.len = keyLen;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pubOut), CRYPT_SUCCESS);
ASSERT_EQ(memcmp(pubOut.key.slhDsaPub.seed, root->x, keyLen), 0);
ASSERT_EQ(memcmp(pubOut.key.slhDsaPub.root, root->x + keyLen, keyLen), 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
return;
}
/* END_CASE */
// determinstic and no pre-hashed signature generation
/* BEGIN_CASE */
void SDV_CRYPTO_SLH_DSA_SIGN_KAT_TC001(int id, Hex *key, Hex *addrand, Hex *msg, Hex *context, Hex *sig)
{
(void)key;
(void)addrand;
(void)msg;
(void)context;
(void)sig;
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = NULL;
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SLH_DSA);
ASSERT_TRUE(pkey != NULL);
int32_t algId = id;
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, algId), CRYPT_SUCCESS);
uint32_t keyLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GET_SLH_DSA_KEY_LEN, (void *)&keyLen, sizeof(keyLen)), CRYPT_SUCCESS);
if (addrand->len == 0) {
int32_t isDeterministic = 1;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_DETERMINISTIC_FLAG, (void *)&isDeterministic,
sizeof(isDeterministic)),
CRYPT_SUCCESS);
} else {
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_SLH_DSA_ADDRAND, (void *)addrand->x, addrand->len),
CRYPT_SUCCESS);
}
CRYPT_EAL_PkeyPrv prv;
(void)memset_s(&prv, sizeof(CRYPT_EAL_PkeyPrv), 0, sizeof(CRYPT_EAL_PkeyPrv));
prv.id = CRYPT_PKEY_SLH_DSA;
prv.key.slhDsaPrv.seed = key->x;
prv.key.slhDsaPrv.prf = key->x + keyLen;
prv.key.slhDsaPrv.pub.seed = key->x + keyLen * 2;
prv.key.slhDsaPrv.pub.root = key->x + keyLen * 3;
prv.key.slhDsaPrv.pub.len = keyLen;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_SUCCESS);
if (context->len != 0) {
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_CTX_INFO, context->x, context->len), CRYPT_SUCCESS);
}
uint8_t sigOut[50000] = {0};
uint32_t sigOutLen = sizeof(sigOut);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SHA256, msg->x, msg->len, sigOut, &sigOutLen), CRYPT_SUCCESS);
ASSERT_TRUE(sigOutLen == sig->len);
ASSERT_TRUE(memcmp(sigOut, sig->x, sigOutLen) == 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
return;
}
/* END_CASE */
// sign pre-hashed msg
/* BEGIN_CASE */
void SDV_CRYPTO_SLH_DSA_SIGN_KAT_TC002(int id, Hex *key, Hex *addrand, Hex *msg, Hex *context, int preHashId, Hex *sig)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = NULL;
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SLH_DSA);
ASSERT_TRUE(pkey != NULL);
int32_t algId = id;
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, algId), CRYPT_SUCCESS);
uint32_t keyLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GET_SLH_DSA_KEY_LEN, (void *)&keyLen, sizeof(keyLen)), CRYPT_SUCCESS);
if (addrand->len == 0) {
int32_t isDeterministic = 1;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_DETERMINISTIC_FLAG, (void *)&isDeterministic,
sizeof(isDeterministic)),
CRYPT_SUCCESS);
} else {
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_SLH_DSA_ADDRAND, (void *)addrand->x, addrand->len),
CRYPT_SUCCESS);
}
int32_t prehash = 1;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_PREHASH_FLAG, (void *)&prehash, sizeof(prehash)),
CRYPT_SUCCESS);
CRYPT_EAL_PkeyPrv prv;
(void)memset_s(&prv, sizeof(CRYPT_EAL_PkeyPrv), 0, sizeof(CRYPT_EAL_PkeyPrv));
prv.id = CRYPT_PKEY_SLH_DSA;
prv.key.slhDsaPrv.seed = key->x;
prv.key.slhDsaPrv.prf = key->x + keyLen;
prv.key.slhDsaPrv.pub.seed = key->x + keyLen * 2;
prv.key.slhDsaPrv.pub.root = key->x + keyLen * 3;
prv.key.slhDsaPrv.pub.len = keyLen;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_SUCCESS);
if (context->len != 0) {
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_CTX_INFO, context->x, context->len), CRYPT_SUCCESS);
}
uint8_t sigOut[50000] = {0};
uint32_t sigOutLen = sizeof(sigOut);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkey, preHashId, msg->x, msg->len, sigOut, &sigOutLen), CRYPT_SUCCESS);
ASSERT_TRUE(sigOutLen == sig->len);
ASSERT_TRUE(memcmp(sigOut, sig->x, sigOutLen) == 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
return;
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_SLH_DSA_CHECK_KEYPAIR_TC001
* @spec -
* @title Key generation and check key pair
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_SLH_DSA_CHECK_KEYPAIR_TC001(int algId)
{
#if !defined(HITLS_CRYPTO_SLH_DSA_CHECK)
(void)algId;
SKIP_TEST();
#else
TestMemInit();
TestRandInit();
CRYPT_EAL_PkeyCtx *pkey = NULL;
CRYPT_EAL_PkeyCtx *pubKey = NULL;
CRYPT_EAL_PkeyCtx *prvKey = NULL;
uint32_t keyLen = 0;
#ifdef HITLS_CRYPTO_PROVIDER
pkey = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_SLH_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
pubKey = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_SLH_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
prvKey = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_SLH_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
#else
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SLH_DSA);
pubKey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SLH_DSA);
prvKey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SLH_DSA);
#endif
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(pubKey != NULL);
ASSERT_TRUE(prvKey != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, algId), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pubKey, algId), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(prvKey, algId), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GET_SLH_DSA_KEY_LEN, (void *)&keyLen, sizeof(keyLen)), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(pkey) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pkey, pkey), CRYPT_SUCCESS);
CRYPT_EAL_PkeyPub pub;
uint8_t pubSeed[32] = {0};
uint8_t pubRoot[32] = {0};
pub.id = CRYPT_PKEY_SLH_DSA;
pub.key.slhDsaPub.seed = pubSeed;
pub.key.slhDsaPub.root = pubRoot;
pub.key.slhDsaPub.len = keyLen;
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubKey, &pub), CRYPT_SUCCESS);
CRYPT_EAL_PkeyPrv prv;
uint8_t prvSeed[32] = {0};
uint8_t prvPrf[32] = {0};
(void)memset_s(&prv, sizeof(CRYPT_EAL_PkeyPrv), 0, sizeof(CRYPT_EAL_PkeyPrv));
prv.id = CRYPT_PKEY_SLH_DSA;
prv.key.slhDsaPrv.seed = prvSeed;
prv.key.slhDsaPrv.prf = prvPrf;
prv.key.slhDsaPrv.pub.seed = pubSeed;
prv.key.slhDsaPrv.pub.root = pubRoot;
prv.key.slhDsaPrv.pub.len = keyLen;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &prv), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvKey, &prv), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(prvKey, prvKey), CRYPT_SLHDSA_ERR_NO_PUBKEY);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubKey, pubKey), CRYPT_SLHDSA_ERR_NO_PRVKEY);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubKey, prvKey), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(pubKey);
CRYPT_EAL_PkeyFreeCtx(prvKey);
TestRandDeInit();
return;
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_SLH_DSA_CHECK_KEYPAIR_TC002
* @spec -
* @title Key generation and check key pair
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_SLH_DSA_CHECK_KEYPAIR_TC002(void)
{
#if !defined(HITLS_CRYPTO_SLH_DSA_CHECK)
SKIP_TEST();
#else
TestMemInit();
TestRandInit();
int32_t algId1 = CRYPT_SLH_DSA_SHA2_128S;
int32_t algId2 = CRYPT_SLH_DSA_SHAKE_192S;
CRYPT_EAL_PkeyCtx *ctx1 = NULL;
CRYPT_EAL_PkeyCtx *ctx2 = NULL;
CRYPT_EAL_PkeyCtx *ctx3 = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx1 = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_SLH_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
ctx2 = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_SLH_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
ctx3 = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_SLH_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
#else
ctx1 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SLH_DSA);
ctx2 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SLH_DSA);
ctx3 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SLH_DSA);
#endif
ASSERT_TRUE(ctx1 != NULL);
ASSERT_TRUE(ctx2 != NULL);
ASSERT_TRUE(ctx3 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(NULL, NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx2), CRYPT_SLHDSA_ERR_INVALID_ALGID); // different key-info
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx1, algId1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx2, algId1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx3, algId2), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx2), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx2, ctx2), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(ctx1, ctx2), CRYPT_SLHDSA_PAIRWISE_CHECK_FAIL);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
CRYPT_EAL_PkeyFreeCtx(ctx3);
TestRandDeInit();
return;
#endif
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_SLH_DSA_CHECK_PRVKEY_TC001
* @spec -
* @title Key generation and check prv key
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_SLH_DSA_CHECK_PRVKEY_TC001(int type)
{
#if !defined(HITLS_CRYPTO_SLH_DSA_CHECK)
(void)type;
SKIP_TEST();
#else
TestMemInit();
TestRandInit();
CRYPT_EAL_PkeyCtx *ctx = NULL;
CRYPT_EAL_PkeyCtx *prvCtx = NULL;
CRYPT_EAL_PkeyPrv prv = { 0 };
uint32_t keyLen = 0;
#ifdef HITLS_CRYPTO_PROVIDER
ctx = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_SLH_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
prvCtx = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_SLH_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
#else
ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SLH_DSA);
prvCtx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SLH_DSA);
#endif
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(prvCtx != NULL);
uint32_t val = (uint32_t)type;
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(ctx, val), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(prvCtx), CRYPT_SLHDSA_ERR_INVALID_ALGID);
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(prvCtx, val), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GET_SLH_DSA_KEY_LEN, &keyLen, sizeof(keyLen)), CRYPT_SUCCESS);
uint8_t prvSeed[32] = {0};
uint8_t prvPrf[32] = {0};
uint8_t pubSeed[32] = {0};
uint8_t pubRoot[32] = {0};
(void)memset_s(&prv, sizeof(CRYPT_EAL_PkeyPrv), 0, sizeof(CRYPT_EAL_PkeyPrv));
prv.id = CRYPT_PKEY_SLH_DSA;
prv.key.slhDsaPrv.seed = prvSeed;
prv.key.slhDsaPrv.prf = prvPrf;
prv.key.slhDsaPrv.pub.seed = pubSeed;
prv.key.slhDsaPrv.pub.root = pubRoot;
prv.key.slhDsaPrv.pub.len = keyLen;
ASSERT_EQ(CRYPT_EAL_PkeyGen(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(ctx, &prv), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(prvCtx), CRYPT_SLHDSA_ERR_NO_PRVKEY); // not set prv key.
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prv), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(prvCtx), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
TestRandDeInit();
return;
#endif
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/slh_dsa/test_suite_sdv_eal_slh_dsa.c | C | unknown | 19,436 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "securec.h"
#include "bsl_err.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "crypt_util_rand.h"
#include "crypt_bn.h"
#include "eal_pkey_local.h"
#include "stub_replace.h"
#include "test.h"
/* END_HEADER */
/* BEGIN_CASE */
void SDV_CRYPTO_SLH_DSA_VERIFY_KAT_TC001(int id, Hex *key, Hex *addrand, Hex *msg, Hex *context, Hex *sig, int result)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = NULL;
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SLH_DSA);
ASSERT_TRUE(pkey != NULL);
int32_t algId = id;
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, algId), CRYPT_SUCCESS);
uint32_t keyLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GET_SLH_DSA_KEY_LEN, (void *)&keyLen, sizeof(keyLen)), CRYPT_SUCCESS);
if (addrand->len == 0) {
int32_t isDeterministic = 1;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_DETERMINISTIC_FLAG, (void *)&isDeterministic,
sizeof(isDeterministic)),
CRYPT_SUCCESS);
} else {
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_SLH_DSA_ADDRAND, (void *)addrand->x, addrand->len),
CRYPT_SUCCESS);
}
CRYPT_EAL_PkeyPrv prv;
(void)memset_s(&prv, sizeof(CRYPT_EAL_PkeyPrv), 0, sizeof(CRYPT_EAL_PkeyPrv));
prv.id = CRYPT_PKEY_SLH_DSA;
prv.key.slhDsaPrv.seed = key->x;
prv.key.slhDsaPrv.prf = key->x + keyLen;
prv.key.slhDsaPrv.pub.seed = key->x + keyLen * 2;
prv.key.slhDsaPrv.pub.root = key->x + keyLen * 3;
prv.key.slhDsaPrv.pub.len = keyLen;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_SUCCESS);
if (context->len != 0) {
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_CTX_INFO, context->x, context->len), CRYPT_SUCCESS);
}
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SHA256, msg->x, msg->len, sig->x, sig->len), result);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_SLH_DSA_VERIFY_PREHASHED_KAT_TC001(int id, Hex *key, Hex *addrand, Hex *msg, Hex *context, int hashId, Hex *sig, int result)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *pkey = NULL;
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SLH_DSA);
ASSERT_TRUE(pkey != NULL);
int32_t algId = id;
ASSERT_EQ(CRYPT_EAL_PkeySetParaById(pkey, algId), CRYPT_SUCCESS);
uint32_t keyLen = 0;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GET_SLH_DSA_KEY_LEN, (void *)&keyLen, sizeof(keyLen)), CRYPT_SUCCESS);
if (addrand->len == 0) {
int32_t isDeterministic = 1;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_DETERMINISTIC_FLAG, (void *)&isDeterministic,
sizeof(isDeterministic)),
CRYPT_SUCCESS);
} else {
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_SLH_DSA_ADDRAND, (void *)addrand->x, addrand->len),
CRYPT_SUCCESS);
}
int32_t prehash = 1;
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_PREHASH_FLAG, (void *)&prehash, sizeof(prehash)),
CRYPT_SUCCESS);
CRYPT_EAL_PkeyPrv prv;
(void)memset_s(&prv, sizeof(CRYPT_EAL_PkeyPrv), 0, sizeof(CRYPT_EAL_PkeyPrv));
prv.id = CRYPT_PKEY_SLH_DSA;
prv.key.slhDsaPrv.seed = key->x;
prv.key.slhDsaPrv.prf = key->x + keyLen;
prv.key.slhDsaPrv.pub.seed = key->x + keyLen * 2;
prv.key.slhDsaPrv.pub.root = key->x + keyLen * 3;
prv.key.slhDsaPrv.pub.len = keyLen;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(pkey, &prv), CRYPT_SUCCESS);
if (context->len != 0) {
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_CTX_INFO, context->x, context->len), CRYPT_SUCCESS);
}
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkey, hashId, msg->x, msg->len, sig->x, sig->len), result);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
return;
}
/* END_CASE */ | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/slh_dsa/test_suite_sdv_eal_slh_dsa1.c | C | unknown | 4,459 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "crypt_bn.h"
#include "bsl_sal.h"
#include "crypt_algid.h"
#include "crypt_types.h"
#include "crypt_eal_pkey.h"
#include "crypt_errno.h"
#include "stub_replace.h"
#include "crypt_eal_rand.h"
#include "securec.h"
#include "crypt_util_rand.h"
#include "crypt_encode_internal.h"
#include "crypt_dsa.h"
#define ERR_BAD_RAND 1
#define RAND_BUF_LEN 2048
#define UINT8_MAX_NUM 255
uint8_t g_RandOutput[RAND_BUF_LEN];
uint32_t g_RandBufLen = 0;
int32_t RandFunc(uint8_t *randNum, uint32_t randLen)
{
for (uint32_t i = 0; i < randLen; i++) {
randNum[i] = (uint8_t)(rand() % UINT8_MAX_NUM);
}
return 0;
}
int32_t RandFuncEx(void *libCtx, uint8_t *randNum, uint32_t randLen)
{
(void)libCtx;
for (uint32_t i = 0; i < randLen; i++) {
randNum[i] = (uint8_t)(rand() % UINT8_MAX_NUM);
}
return 0;
}
int32_t SetFakeRandOutput(uint8_t *in, uint32_t inLen)
{
g_RandBufLen = inLen;
return memcpy_s(g_RandOutput, sizeof(g_RandOutput), in, inLen);
}
int32_t FakeRandFunc(uint8_t *randNum, uint32_t randLen)
{
if (randLen > RAND_BUF_LEN) {
return ERR_BAD_RAND;
}
return memcpy_s(randNum, randLen, g_RandOutput, randLen);
}
int32_t FakeRandFuncEx(void *libCtx, uint8_t *randNum, uint32_t randLen)
{
(void)libCtx;
if (randLen > RAND_BUF_LEN) {
return ERR_BAD_RAND;
}
return memcpy_s(randNum, randLen, g_RandOutput, randLen);
}
int32_t STUB_RandRangeK(void *libCtx, BN_BigNum *r, const BN_BigNum *p)
{
(void)p;
(void)libCtx;
BN_Bin2Bn(r, g_RandOutput, g_RandBufLen);
return CRYPT_SUCCESS;
}
void SetSm2PubKey(CRYPT_EAL_PkeyPub *pub, uint8_t *key, uint32_t len)
{
pub->id = CRYPT_PKEY_SM2;
pub->key.eccPub.data = key;
pub->key.eccPub.len = len;
}
void SetSm2PrvKey(CRYPT_EAL_PkeyPrv *prv, uint8_t *key, uint32_t len)
{
prv->id = CRYPT_PKEY_SM2;
prv->key.eccPrv.data = key;
prv->key.eccPrv.len = len;
} | 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/sm2/test_suite_sdv_eal_sm2.base.c | C | unknown | 2,475 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* INCLUDE_BASE test_suite_sdv_eal_sm2 */
/* BEGIN_HEADER */
#include "crypt_local_types.h"
#include "crypt_sm2.h"
#include "crypt_encode_internal.h"
#define MAX_PLAIN_TEXT_LEN 2048
#define CIPHER_TEXT_EXTRA_LEN 97
#define CRYPT_EAL_PKEY_KEYMGMT_OPERATE 0
#define SM3_MD_SIZE 32
#define SM2_POINT_SINGLE_COORDINATE_LEN 32
#define SM2_POINT_COORDINATE_LEN 65
/* END_HEADER */
/**
* @test SDV_CRYPTO_SM2_ENC_API_TC001
* @title SM2 CRYPT_EAL_PkeyEncrypt: Test the validity of input parameters.
* @precon Vector: public key.
* @brief
* 1. Init the DRBG and create the context of the SM2 algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyEncrypt method, where all parameters are valid, expected result 2
* 3. Set public key, expected result 3
* 4. Call the CRYPT_EAL_PkeyEncrypt method:
* (1) data = NULL, dataLen != 0, expected result 4
* (2) data = NULL, dataLen = 0, expected result 5
* (3) output = NULL, outLen != 0, expected result 6
* (4) outLen = NULL, expected result 7
* (5) outLen is not enough(less than 32+97), expected result 8
* (6) all parameters are valid, expected result 9
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SM2_NO_PUBKEY
* 3. CRYPT_SUCCESS
* 4-7. CRYPT_NULL_INPUT
* 8. CRYPT_SM2_BUFF_LEN_NOT_ENOUGH
* 9. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_ENC_API_TC001(Hex *pubKey, int isProvider)
{
uint8_t plainText[32];
uint8_t cipherText[141]; // 32 + 97 + 12
uint32_t outLen = sizeof(cipherText);
CRYPT_EAL_PkeyPub pub = {0};
SetSm2PubKey(&pub, pubKey->x, pubKey->len);
TestMemInit();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(ctx, plainText, sizeof(plainText), cipherText, &outLen) == CRYPT_SM2_NO_PUBKEY);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(ctx, NULL, sizeof(plainText), cipherText, &outLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(ctx, NULL, 0, cipherText, &outLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(ctx, plainText, sizeof(plainText), NULL, &outLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(ctx, plainText, sizeof(plainText), cipherText, NULL) == CRYPT_NULL_INPUT);
outLen = sizeof(cipherText) - 12;
ASSERT_TRUE(
CRYPT_EAL_PkeyEncrypt(ctx, plainText, sizeof(plainText), cipherText, &outLen) == CRYPT_SM2_BUFF_LEN_NOT_ENOUGH);
outLen = sizeof(cipherText);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(ctx, plainText, sizeof(plainText), cipherText, &outLen) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_ENC_API_TC002
* @title SM2: CRYPT_EAL_PkeyEncrypt test: Random number error.
* @precon Vertor: public key.
* @brief
* 1. Create the context of the SM2 algorithm, expected result 1.
* 2. Set public key, expected result 2.
* 3. Call the CRYPT_EAL_PkeyEncrypt method, where all parameters are valid, expected result 3.
* 4. Register wrong rand method: FakeRandFunc(The random number it generated is 0), expected result 4.
* 5. Call the CRYPT_EAL_PkeyEncrypt method, where all parameters are valid, expected result 5.
* 6. Register correct rand method and Call the CRYPT_EAL_PkeyEncrypt method to signature, expected result 6.
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_NO_REGIST_RAND
* 4. CRYPT_SUCCESS
* 5. CRYPT_SM2_ERR_TRY_CNT.
* 6. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_ENC_API_TC002(Hex *pubKey, int isProvider)
{
uint8_t plainText[32];
uint8_t cipherText[141]; // 32 + 97 + 12
uint32_t outLen = sizeof(cipherText);
uint8_t zero[100] = {0};
CRYPT_EAL_PkeyPub pub = {0};
SetSm2PubKey(&pub, pubKey->x, pubKey->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(ctx, plainText, sizeof(plainText), cipherText, &outLen) == CRYPT_NO_REGIST_RAND);
CRYPT_RandRegist(FakeRandFunc);
CRYPT_RandRegistEx(FakeRandFuncEx);
ASSERT_TRUE(SetFakeRandOutput(zero, sizeof(zero)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(ctx, plainText, sizeof(plainText), cipherText, &outLen) == CRYPT_SM2_ERR_TRY_CNT);
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(ctx, plainText, sizeof(plainText), cipherText, &outLen) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_DEC_API_TC001
* @title SM2 CRYPT_EAL_PkeyDecrypt: Test the validity of input parameters.
* @precon Vector: private key, ciphertext.
* @brief
* 1. Create the context of the SM2 algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyDecrypt method, where all parameters are valid, expected result 2
* 3. Set private key, expected result 3
* 4. Call the CRYPT_EAL_PkeyDecrypt method:
* (1) data = NULL, dataLen != 0, expected result 4
* (2) output = NULL, outLen != 0, expected result 5
* (3) outLen = NULL, expected result 6
* (4) data = NULL, dataLen = 0, expected result 7
* (5) the length of ciphertext is too long, expected result 8
* (6) all parameters are valid, expected result 9
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SM2_NO_PRVKEY
* 3. CRYPT_SUCCESS
* 4-7. CRYPT_NULL_INPUT
* 8. CRYPT_SM2_BUFF_LEN_NOT_ENOUGH
* 9. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_DEC_API_TC001(Hex *prvKey, Hex *cipherText, int isProvider)
{
uint8_t plainText[MAX_PLAIN_TEXT_LEN];
uint32_t outLen = cipherText->len;
CRYPT_EAL_PkeyPrv prv = {0};
SetSm2PrvKey(&prv, prvKey->x, prvKey->len);
TestRandInit();
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(ctx, cipherText->x, cipherText->len, plainText, &outLen) == CRYPT_SM2_NO_PRVKEY);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(ctx, NULL, cipherText->len, plainText, &outLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(ctx, cipherText->x, cipherText->len, NULL, &outLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(ctx, cipherText->x, cipherText->len, plainText, NULL) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(ctx, NULL, 0, plainText, &outLen) == CRYPT_NULL_INPUT);
outLen = 1;
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(ctx, cipherText->x, cipherText->len, plainText, &outLen) ==
CRYPT_SM2_BUFF_LEN_NOT_ENOUGH);
outLen = cipherText->len;
ASSERT_EQ(CRYPT_EAL_PkeyDecrypt(ctx, cipherText->x, cipherText->len, plainText, &outLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_CTRL_API_TC001
* @title SM2 CRYPT_EAL_PkeyCtrl test.
* @precon nan
* @brief
* 1. Create the context of the SM2 algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyCtrl to set sm2 hash method, expected result 2
* 2. Call the CRYPT_EAL_PkeyCtrl, opt is CRYPT_CTRL_UP_REFERENCES, len is 0, expected result 3
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_ECC_PKEY_ERR_UNSUPPORTED_CTRL_OPTION
* 3. CRYPT_NULL_INPUT
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_CTRL_API_TC001(int isProvider)
{
uint32_t ref = 1;
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
EAL_MdMethod hashMethod = {0};
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &hashMethod, sizeof(EAL_MdMethod)) ==
CRYPT_ECC_PKEY_ERR_UNSUPPORTED_CTRL_OPTION);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_UP_REFERENCES, &ref, 0), CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_ENC_FUNC_TC001
* @title SM2: public key encryption.
* @precon Vectors: public key, plaintext, generate random number k, ciphertext.
* @brief
* 1. Create the context of the SM2 algorithm, expected result 1
* 2. Set public key, expected result 2
* 3. Take over random numbers, mock BN_RandRange to generate k
* 4. Call the CRYPT_EAL_PkeyEncrypt to encrypt plaintext, expected result 3
* 5. Compare the encryption result with the ciphertext vector, expected result 4
* @expect
* 1. Success, and context is not NULL.
* 2-3. CRYPT_SUCCESS
* 4. Both are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_ENC_FUNC_TC001(Hex *pubKey, Hex *plain, Hex *k, Hex *cipher, int isProvider)
{
FuncStubInfo tmpRpInfo;
uint8_t cipherText[MAX_PLAIN_TEXT_LEN + CIPHER_TEXT_EXTRA_LEN] = {0};
uint8_t decodeText[MAX_PLAIN_TEXT_LEN + CIPHER_TEXT_EXTRA_LEN] = {0};
uint32_t decodeLen = sizeof(decodeText);
uint32_t outLen = sizeof(cipherText);
CRYPT_EAL_PkeyPub pub = {0};
SetSm2PubKey(&pub, pubKey->x, pubKey->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx, &pub), CRYPT_SUCCESS);
STUB_Init();
ASSERT_TRUE(SetFakeRandOutput(k->x, k->len) == CRYPT_SUCCESS);
STUB_Replace(&tmpRpInfo, BN_RandRangeEx, STUB_RandRangeK);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(ctx, plain->x, plain->len, cipherText, &outLen) == CRYPT_SUCCESS);
CRYPT_SM2_EncryptData encData = {
.x = decodeText + 1,
.xLen = SM2_POINT_SINGLE_COORDINATE_LEN,
.y = decodeText + SM2_POINT_SINGLE_COORDINATE_LEN + 1,
.yLen = SM2_POINT_SINGLE_COORDINATE_LEN,
.hash = decodeText + SM2_POINT_COORDINATE_LEN,
.hashLen = SM3_MD_SIZE,
.cipher = decodeText + SM2_POINT_COORDINATE_LEN + SM3_MD_SIZE,
.cipherLen = decodeLen - SM2_POINT_COORDINATE_LEN - SM3_MD_SIZE - 1
};
ASSERT_TRUE(CRYPT_EAL_DecodeSm2EncryptData(cipherText, outLen, &encData) == CRYPT_SUCCESS);
decodeText[0] = 0x04;
ASSERT_EQ(encData.xLen + encData.yLen + encData.hashLen + encData.cipherLen + 1, cipher->len);
ASSERT_TRUE(memcmp(decodeText, cipher->x, cipher->len) == 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
STUB_Reset(&tmpRpInfo);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_DEC_FUNC_TC001
* @title SM2: private key decryption.
* @precon Vectors: private key, plaintext, ciphertext.
* @brief
* 1. Create the context of the SM2 algorithm, expected result 1
* 2. Set private key, expected result 2
* 3. Call the CRYPT_EAL_PkeyDecrypt to decrypt ciphertext, expected result 3
* 4. Compare the decryption result with the ciphertext vector, expected result 4
* @expect
* 1. Success, and context is not NULL.
* 2-3. CRYPT_SUCCESS
* 4. Both are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_DEC_FUNC_TC001(Hex *prvKey, Hex *plain, Hex *cipher, int isProvider)
{
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
uint8_t plainText[MAX_PLAIN_TEXT_LEN] = {0};
uint32_t outLen = sizeof(plainText);
uint8_t encodeText[MAX_PLAIN_TEXT_LEN + 20] = {0};
uint32_t encodeLen = MAX_PLAIN_TEXT_LEN + 20;
CRYPT_EAL_PkeyPrv prv = {0};
SetSm2PrvKey(&prv, prvKey->x, prvKey->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx, &prv) == CRYPT_SUCCESS);
CRYPT_SM2_EncryptData encData = {
.x = cipher->x + 1,
.xLen = SM2_POINT_SINGLE_COORDINATE_LEN,
.y = cipher->x + SM2_POINT_SINGLE_COORDINATE_LEN + 1,
.yLen = SM2_POINT_SINGLE_COORDINATE_LEN,
.hash = cipher->x + SM2_POINT_COORDINATE_LEN,
.hashLen = SM3_MD_SIZE,
.cipher = cipher->x + SM2_POINT_COORDINATE_LEN + SM3_MD_SIZE,
.cipherLen = cipher->len - SM2_POINT_COORDINATE_LEN - SM3_MD_SIZE
};
ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&encData, encodeText, &encodeLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyDecrypt(ctx, encodeText, encodeLen, plainText, &outLen), CRYPT_SUCCESS);
ASSERT_TRUE(outLen == plain->len);
ASSERT_TRUE(memcmp(plainText, plain->x, plain->len) == 0);
EXIT:
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_DECOCDE_Sm2CipherText
* @title SM2: decode
* @brief test SM2 ciphertext decoding
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_DECOCDE_Sm2CipherText(Hex *cipher)
{
ECC_Para *para = NULL;
ECC_Point *c1 = NULL;
uint8_t *decode = BSL_SAL_Calloc(1u, cipher->len);
ASSERT_TRUE(decode != NULL);
// Add uncompressed point identifier
decode[0] = 0x04;
CRYPT_SM2_EncryptData encData = {
.x = decode + 1, // Reserve one byte for '04'
.xLen = SM2_POINT_SINGLE_COORDINATE_LEN,
.y = decode + SM2_POINT_SINGLE_COORDINATE_LEN + 1,
.yLen = SM2_POINT_SINGLE_COORDINATE_LEN,
.hash = decode + SM2_POINT_COORDINATE_LEN,
.hashLen = SM3_MD_SIZE,
.cipher = decode + SM2_POINT_COORDINATE_LEN + SM3_MD_SIZE,
.cipherLen = cipher->len - SM2_POINT_COORDINATE_LEN - SM3_MD_SIZE
};
int32_t ret = CRYPT_EAL_DecodeSm2EncryptData(cipher->x, cipher->len, &encData);
ASSERT_EQ(ret, CRYPT_SUCCESS);
para = ECC_NewPara(CRYPT_ECC_SM2);
ASSERT_TRUE(para != NULL);
c1 = ECC_NewPoint(para);
ASSERT_TRUE(c1 != NULL);
ASSERT_EQ(ECC_DecodePoint(para, c1, decode, SM2_POINT_COORDINATE_LEN), CRYPT_SUCCESS);
EXIT:
BSL_SAL_Free(decode);
ECC_FreePoint(c1);
ECC_FreePara(para);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_DEC_FUNC_TC002
* @title SM2: Private key decryption failure scenario.
* @precon Vectors: private key, ciphertext.
* @brief
* 1. Create the context of the SM2 algorithm, expected result 1
* 2. Set private key, expected result 2
* 3. Call the CRYPT_EAL_PkeyDecrypt to decrypt ciphertext, expected result 3
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. Failure.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_DEC_FUNC_TC002(Hex *prvKey, Hex *cipher, int isProvider)
{
TestMemInit();
uint8_t plainText[MAX_PLAIN_TEXT_LEN];
uint32_t outLen = sizeof(plainText);
CRYPT_EAL_PkeyPrv prv = {0};
SetSm2PrvKey(&prv, prvKey->x, prvKey->len);
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx, &prv) == CRYPT_SUCCESS);
/* Different error codes are returned for different phases. */
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(ctx, cipher->x, cipher->len, plainText, &outLen) != CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_GEN_CRYPT_FUNC_TC001
* @title SM2: Generate key pair, encryption, decryption.
* @precon Vector: plaintext.
* @brief
* 1. Create the context of the SM2 algorithm, expected result 1
* 2. Initialize the DRBG.
* 3. Call the CRYPT_EAL_PkeyGen to generate a key pair, expected result 2
* 4. Call the CRYPT_EAL_PkeyEncrypt to encrypt plaintext, expected result 3
* 5. Call the CRYPT_EAL_PkeyDecrypt to decrypt ciphertext, expected result 4
* 6. Compare the decryption result with the plaintext vector, expected result 5
* @expect
* 1. Success, and context is not NULL.
* 2-4. CRYPT_SUCCESS
* 5. Both are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_GEN_CRYPT_FUNC_TC001(Hex *msg, int isProvider)
{
uint8_t cipherText[MAX_PLAIN_TEXT_LEN + CIPHER_TEXT_EXTRA_LEN];
uint8_t plainText[MAX_PLAIN_TEXT_LEN];
uint32_t ctLen = sizeof(cipherText);
uint32_t ptLen = sizeof(plainText);
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(ctx, msg->x, msg->len, cipherText, &ctLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(ctx, cipherText, ctLen, plainText, &ptLen) == CRYPT_SUCCESS);
ASSERT_TRUE(ptLen == msg->len);
ASSERT_TRUE(memcmp(plainText, msg->x, msg->len) == 0);
EXIT:
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_GEN_CRYPT_FUNC_TC002
* @title SM2: The input and output parameters address are the same.
* @precon Vector: plaintext.
* @brief
* 1. Create the context of the SM2 algorithm, expected result 1
* 2. Initialize the DRBG.
* 3. Call the CRYPT_EAL_PkeyGen to generate a key pair, expected result 2
* 4. Call the CRYPT_EAL_PkeyEncrypt, and the input and output parameters address are the same, expected result 3
* 5. Call the CRYPT_EAL_PkeyDecrypt, and the input and output parameters address are the same, expected result 4
* 6. Compare the decryption result with the plaintext vector, expected result 5
* @expect
* 1. Success, and context is not NULL.
* 2-4. CRYPT_SUCCESS
* 5. Both are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_GEN_CRYPT_FUNC_TC002(Hex *msg, int isProvider)
{
uint8_t buf[MAX_PLAIN_TEXT_LEN + CIPHER_TEXT_EXTRA_LEN];
uint32_t ctLen = sizeof(buf);
uint32_t ptLen = sizeof(buf);
ASSERT_TRUE(memcpy_s(buf, ptLen, msg->x, msg->len) == CRYPT_SUCCESS);
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyEncrypt(ctx, buf, msg->len, buf, &ctLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyDecrypt(ctx, buf, ctLen, buf, &ptLen) == CRYPT_SUCCESS);
ASSERT_TRUE(ptLen == msg->len);
ASSERT_TRUE(memcmp(buf, msg->x, msg->len) == 0);
EXIT:
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_CMP_FUNC_TC001
* @title SM2: The input and output parameters address are the same.
* @precon Vector: private key and public key.
* @brief
* 1. Create the contexts(ctx1, ctx2) of the SM2 algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 2
* 3. Set public key for ctx1, expected result 3
* 4. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 4
* 5. Set public key for ctx2, expected result 5
* 6. Call the CRYPT_EAL_PkeyCmp to compare ctx1 and ctx2, expected result 6
* @expect
* 1. Success, and contexts are not NULL.
* 2. CRYPT_ECC_KEY_PUBKEY_NOT_EQUAL
* 3. CRYPT_SUCCESS
* 4. CRYPT_ECC_KEY_PUBKEY_NOT_EQUAL
* 5-6. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_CMP_FUNC_TC001(Hex *pubKey, int isProvider)
{
CRYPT_EAL_PkeyPub pub = {0};
SetSm2PubKey(&pub, pubKey->x, pubKey->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *ctx2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_CIPHER_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx1 != NULL && ctx2 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_ECC_KEY_PUBKEY_NOT_EQUAL);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx1, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_ECC_KEY_PUBKEY_NOT_EQUAL);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(ctx2, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCmp(ctx1, ctx2), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_ENC_DECODE_FUNC_TC001
* @title SM2: for testing sm2 ciphertext decode.
* @precon Vector: SM2 ciphertext.
* @brief
* 1. Call the CRYPT_EAL_DecodeSm2EncryptData to decode the SM2 ciphertext
* @expect
* 1. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_ENC_DECODE_FUNC_TC001(Hex *cipher)
{
uint8_t decode[MAX_PLAIN_TEXT_LEN] = {0};
uint32_t decodelen = MAX_PLAIN_TEXT_LEN;
CRYPT_SM2_EncryptData encData = {
.x = decode,
.xLen = SM2_POINT_SINGLE_COORDINATE_LEN,
.y = decode + SM2_POINT_SINGLE_COORDINATE_LEN,
.yLen = SM2_POINT_SINGLE_COORDINATE_LEN,
.hash = decode + SM2_POINT_COORDINATE_LEN,
.hashLen = SM3_MD_SIZE,
.cipher = decode + SM2_POINT_COORDINATE_LEN + SM3_MD_SIZE,
.cipherLen = decodelen - SM2_POINT_COORDINATE_LEN - SM3_MD_SIZE
};
ASSERT_EQ(CRYPT_EAL_DecodeSm2EncryptData(cipher->x, cipher->len, &encData), CRYPT_SUCCESS);
EXIT:
return;
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/sm2/test_suite_sdv_eal_sm2_crypt.c | C | unknown | 22,857 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* INCLUDE_BASE test_suite_sdv_eal_sm2 */
/* BEGIN_HEADER */
#include "eal_pkey_local.h"
/* END_HEADER */
#define CRYPT_EAL_PKEY_KEYMGMT_OPERATE 0
/**
* @test SDV_CRYPTO_SM2_EXCHANGE_API_TC001
* @title SM2: CRYPT_EAL_PkeyComputeShareKey Test: R is not set.
* @precon Test Vectors for SM2: public key, private key
* @brief
* 1. Init the Drbg and create two contexts(ctx1, ctx2) of the SM2 algorithm, expected result 1.
* 2. ctx1: set userId, server, private key and generate r, expected result 2.
* 3. ctx2: set userId and public key, expected result 3.
* 4. Call the CRYPT_EAL_PkeyComputeShareKey method, expected result 4.
* @expect
* 1. Success, and two contexts are not NULL.
* 2-3. CRYPT_SUCCESS
* 4. CRYPT_SM2_R_NOT_SET
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_EXCHANGE_API_TC001(Hex *prvKey, Hex *pubKey, int isProvider)
{
uint8_t userId[10] = {0};
uint8_t localR[65];
int32_t server = 1;
uint8_t out[64];
uint32_t outLen = sizeof(out);
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
TestMemInit();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
CRYPT_EAL_PkeyCtx *ctx1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *ctx2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx1 != NULL);
ASSERT_TRUE(ctx2 != NULL);
SetSm2PrvKey(&prv, prvKey->x, prvKey->len);
SetSm2PubKey(&pub, pubKey->x, pubKey->len);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_SERVER, &server, sizeof(int32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_GENE_SM2_R, localR, sizeof(localR)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx1, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx2, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(ctx1, ctx2, out, &outLen) == CRYPT_SM2_R_NOT_SET);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_EXCHANGE_API_TC002
* @title SM2: CRYPT_EAL_PkeyComputeShareKey Test: R is not generate.
* @precon Test Vectors for SM2: public key, private key, R.
* @brief
* 1. Init the Drbg and create two contexts(ctx1, ctx2) of the SM2 algorithm, expected result 1.
* 2. ctx1: set userId, server and private key, expected result 2.
* 3. ctx2: set userId, R and public key, expected result 3.
* 4. Call the CRYPT_EAL_PkeyComputeShareKey method, expected result 4.
* @expect
* 1. Success, and two contexts are not NULL.
* 2-3. CRYPT_SUCCESS
* 4. CRYPT_SM2_R_NOT_SET
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_EXCHANGE_API_TC002(Hex *prvKey, Hex *pubKey, Hex *R, int isProvider)
{
TestMemInit();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
uint8_t userId[10] = {0};
int32_t server = 1;
uint8_t out[64];
uint32_t outLen = sizeof(out);
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
CRYPT_EAL_PkeyCtx *ctx1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *ctx2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx1 != NULL);
ASSERT_TRUE(ctx2 != NULL);
SetSm2PrvKey(&prv, prvKey->x, prvKey->len);
SetSm2PubKey(&pub, pubKey->x, pubKey->len);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_SERVER, &server, sizeof(int32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx1, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_R, R->x, R->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx2, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(ctx1, ctx2, out, &outLen) == CRYPT_SM2_R_NOT_SET);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_EXCHANGE_API_TC003
* @title SM2: CRYPT_EAL_PkeyComputeShareKey Test: UserId is not set at the local end.
* @precon Test Vectors for SM2: public key, private key, R.
* @brief
* 1. Init the Drbg and create two contexts(ctx1, ctx2) of the SM2 algorithm, expected result 1.
* 2. ctx1: set server, private key and generate r, expected result 2.
* 3. ctx2: set userId, R and public key, expected result 3.
* @expect
* 1. Success, and two contexts are not NULL.
* 2-3. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_EXCHANGE_API_TC003(Hex *prvKey, Hex *pubKey, Hex *R, int isProvider)
{
uint8_t userId[10] = {0};
int32_t server = 1;
uint8_t localR[65];
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
TestMemInit();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
CRYPT_EAL_PkeyCtx *ctx1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *ctx2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx1 != NULL);
ASSERT_TRUE(ctx2 != NULL);
SetSm2PrvKey(&prv, prvKey->x, prvKey->len);
SetSm2PubKey(&pub, pubKey->x, pubKey->len);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_SERVER, &server, sizeof(int32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_GENE_SM2_R, localR, sizeof(localR)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx1, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_R, R->x, R->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx2, &pub) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_EXCHANGE_API_TC004
* @title SM2: CRYPT_EAL_PkeyComputeShareKey Test: UserId is not set at the peer end.
* @precon Test Vectors for SM2: public key, private key, R.
* @brief
* 1. Init the Drbg and create two contexts(ctx1, ctx2) of the SM2 algorithm, expected result 1.
* 2. ctx1: set userId, server, private key and generate r, expected result 2.
* 3. ctx2: set R and public key, expected result 3.
* @expect
* 1. Success, and two contexts are not NULL.
* 2-3. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_EXCHANGE_API_TC004(Hex *prvKey, Hex *pubKey, Hex *R, int isProvider)
{
TestMemInit();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
uint8_t userId[10] = {0};
int32_t server = 1;
uint8_t localR[65];
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
CRYPT_EAL_PkeyCtx *ctx1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *ctx2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx1 != NULL);
ASSERT_TRUE(ctx2 != NULL);
SetSm2PrvKey(&prv, prvKey->x, prvKey->len);
SetSm2PubKey(&pub, pubKey->x, pubKey->len);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_SERVER, &server, sizeof(int32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_GENE_SM2_R, localR, sizeof(localR)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx1, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_R, R->x, R->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx2, &pub) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_EXCHANGE_API_TC005
* @title SM2: CRYPT_EAL_PkeyComputeShareKey Test: UserId is not set at the peer end.
* @precon Test Vectors for SM2: public key, private key, R.
* @brief
* 1. Init the Drbg and create two contexts(ctx1, ctx2) of the SM2 algorithm, expected result 1.
* 2. ctx1: set userId, server, private key and generate r, expected result 2.
* 3. ctx2: set R, server and public key, expected result 3.
* 4. Call the CRYPT_EAL_PkeyComputeShareKey method, expected result 4.
* 5. Set client and generate R for ctx1, set client for ctx2, expected result 5.
* 6. Call the CRYPT_EAL_PkeyComputeShareKey method, expected result 6.
* @expect
* 1. Success, and two contexts are not NULL.
* 2-6. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_EXCHANGE_API_TC005(Hex *prvKey, Hex *pubKey, Hex *R, int isProvider)
{
uint8_t userId[10] = {0};
int32_t server = 1;
uint8_t out[64];
uint8_t localR[65];
uint32_t outLen = sizeof(out);
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
TestMemInit();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
CRYPT_EAL_PkeyCtx *ctx1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *ctx2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx1 != NULL);
ASSERT_TRUE(ctx2 != NULL);
SetSm2PrvKey(&prv, prvKey->x, prvKey->len);
SetSm2PubKey(&pub, pubKey->x, pubKey->len);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_SERVER, &server, sizeof(int32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_GENE_SM2_R, localR, sizeof(localR)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx1, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_SERVER, &server, sizeof(int32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_R, R->x, R->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx2, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(ctx1, ctx2, out, &outLen) == CRYPT_SUCCESS);
server = 0;
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_SERVER, &server, sizeof(int32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_GENE_SM2_R, localR, sizeof(localR)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_SERVER, &server, sizeof(int32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(ctx1, ctx2, out, &outLen) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_EXCHANGE_API_TC006
* @title SM2: CRYPT_EAL_PkeyComputeShareKey Test: Test the validity of input parameters.
* @precon Test Vectors for SM2: public key, private key, R.
* @brief
* 1. Init the Drbg and create two contexts(ctx1, ctx2) of the SM2 algorithm, expected result 1.
* 2. ctx1: set userId, server, private key and generate r, expected result 2.
* 3. ctx2: set userId, R and public key, expected result 3.
* 4. Call the CRYPT_EAL_PkeyComputeShareKey method:
* (1) ctx1 = NULL, expected result 4.
* (2) ctx2 = NULL, expected result 5.
* (3) out = NULL, expected result 6.
* (4) outLen = NULL, expected result 7.
* (5) outLen = 0, expected result 8.
* @expect
* 1. Success, and two contexts are not NULL.
* 2-3. CRYPT_SUCCESS
* 4. CRYPT_NULL_INPUT
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_EXCHANGE_API_TC006(Hex *prvKey, Hex *pubKey, Hex *R, int isProvider)
{
uint8_t userId[10] = {0};
int32_t server = 1;
uint8_t out[64];
uint8_t localR[65];
uint32_t outLen = sizeof(out);
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
TestMemInit();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
CRYPT_EAL_PkeyCtx *ctx1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *ctx2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx1 != NULL);
ASSERT_TRUE(ctx2 != NULL);
SetSm2PrvKey(&prv, prvKey->x, prvKey->len);
SetSm2PubKey(&pub, pubKey->x, pubKey->len);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_SERVER, &server, sizeof(int32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_GENE_SM2_R, localR, sizeof(localR)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx1, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_R, R->x, R->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx2, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(NULL, ctx2, out, &outLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(ctx1, NULL, out, &outLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(ctx1, ctx2, NULL, &outLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(ctx1, ctx2, out, NULL) == CRYPT_NULL_INPUT);
outLen = 0;
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(ctx1, ctx2, out, &outLen) == CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_EXCHANGE_API_TC007
* @title SM2: CRYPT_EAL_PkeyComputeShareKey Test: Test the validity of input parameters.
* @precon Test Vectors for SM2: public key, private key, R.
* @brief
* 1. Init the Drbg and create two contexts(ctx1, ctx2) of the SM2 algorithm, expected result 1.
* 2. ctx1: set userId, server, private key and generate r, expected result 2.
* 3. ctx2: set userId, R and private key, expected result 3.
* 4. Call the CRYPT_EAL_PkeyComputeShareKey method, expected result 4.
* 5. Set public key for ctx1 and ctx2, expected result 5.
* 6. Generate R for ctx1, expected result 6.
* 7. Call the CRYPT_EAL_PkeyComputeShareKey method, expected result 7.
* @expect
* 1. Success, and two contexts are not NULL.
* 2-3. CRYPT_SUCCESS
* 4. CRYPT_SM2_ERR_EMPTY_KEY
* 5-7. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_EXCHANGE_API_TC007(Hex *prvKey, Hex *pubKey, Hex *R, int isProvider)
{
TestMemInit();
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
uint8_t userId[10] = {0};
int32_t server = 1;
uint8_t out[64];
uint8_t localR[65];
uint32_t outLen = sizeof(out);
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
CRYPT_EAL_PkeyCtx *ctx1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *ctx2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx1 != NULL);
ASSERT_TRUE(ctx2 != NULL);
SetSm2PrvKey(&prv, prvKey->x, prvKey->len);
SetSm2PubKey(&pub, pubKey->x, pubKey->len);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_SERVER, &server, sizeof(int32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_GENE_SM2_R, localR, sizeof(localR)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx1, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_R, R->x, R->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx2, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(ctx1, ctx2, out, &outLen) == CRYPT_SM2_ERR_EMPTY_KEY);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx1, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx2, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_GENE_SM2_R, localR, sizeof(localR)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(ctx1, ctx2, out, &outLen) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_CTRL_API_TC001
* @title SM2 CRYPT_EAL_PkeyCtrl: Test generate R and get R.
* @precon nan
* @brief
* 1. Create the context of the SM2 algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyCtrl, and all parameters are valid, expected result 2
* 3. Set the error random number method so that it returns zero, expected result 3
* 4. Call the CRYPT_EAL_PkeyCtrl, and all parameters are valid, expected result 4
* 5. Set the correct random number method.
* 6. Call the CRYPT_EAL_PkeyCtrl, opt = CRYPT_CTRL_GENE_SM2_R:
* (1) val = null, and other parameters are valid, expected result 5
* (2) val = null, len = 0, and other parameters are valid, expected result 6
* (3) val != null, len is not enough, and other parameters are valid, expected result 7
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_NO_REGIST_RAND
* 3. CRYPT_SUCCESS
* 4. CRYPT_SM2_ERR_TRY_CNT
* 5-6. CRYPT_NULL_INPUT
* 7. CRYPT_ECC_BUFF_LEN_NOT_ENOUGH
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_CTRL_API_TC001(int isProvider)
{
uint8_t localR[65];
uint8_t zero[RAND_BUF_LEN] = {0};
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GENE_SM2_R, localR, sizeof(localR)) == CRYPT_NO_REGIST_RAND);
CRYPT_RandRegist(FakeRandFunc);
CRYPT_RandRegistEx(FakeRandFuncEx);
ASSERT_TRUE(SetFakeRandOutput(zero, sizeof(zero)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GENE_SM2_R, localR, sizeof(localR)) == CRYPT_SM2_ERR_TRY_CNT);
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GENE_SM2_R, NULL, sizeof(localR)) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GENE_SM2_R, NULL, 0) == CRYPT_NULL_INPUT);
ASSERT_TRUE(
CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_GENE_SM2_R, localR, sizeof(localR) - 1) == CRYPT_ECC_BUFF_LEN_NOT_ENOUGH);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_CTRL_API_TC002
* @title SM2 CRYPT_EAL_PkeyCtrl: Test Set R.
* @precon vector: valid R.
* @brief
* 1. Create the context of the SM2 algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyCtrl, opt = CRYPT_CTRL_SET_SM2_R:
* (1) val = null, and other parameters are valid, expected result 2
* (2) val = null, len = 0, and other parameters are valid, expected result 3
* (3) val != null, len = R->len - 1, and other parameters are valid, expected result 4
* (4) val != null, len = R->len + 1, and other parameters are valid, expected result 5
* (5) val is 0 and the length is 65 bytes, and other parameters are valid, expected result 6
* (6) and other parameters are valid, expected result 7
* @expect
* 1. Success, and context is not NULL.
* 2-3. CRYPT_NULL_INPUT
* 4-6. CRYPT_ECC_ERR_POINT_CODE
* 7. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_CTRL_API_TC002(Hex *R, int isProvider)
{
uint8_t zero[65] = {0};
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_R, NULL, R->len) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_R, NULL, 0) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_R, R->x, R->len - 1) == CRYPT_ECC_ERR_POINT_CODE);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_R, R->x, R->len + 1) == CRYPT_ECC_ERR_POINT_CODE);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_R, zero, sizeof(zero)) == CRYPT_ECC_ERR_POINT_CODE);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_R, R->x, R->len) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_CTRL_API_TC003
* @title SM2 CRYPT_EAL_PkeyCtrl: Test set sm2 server/client.
* @precon nan
* @brief
* 1. Create the context of the SM2 algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyCtrl, opt = CRYPT_CTRL_SET_SM2_SERVER:
* (1) val = null, and other parameters are valid, expected result 2
* (2) val = null, len = 0, and other parameters are valid, expected result 3
* (3) val(type is uint32_t, value is 2), len is 4, and other parameters are valid, expected result 4
* (4) val(type is uint32_t, value is 0xffffffff), len is 4, and other parameters are valid, expected result 5
* (5) val(type is uint8_t, value is 0), len is 1, and other parameters are valid, expected result 6
* @expect
* 1. Success, and context is not NULL.
* 2-3. CRYPT_NULL_INPUT
* 4-5. CRYPT_SM2_INVALID_SERVER_TYPE
* 6. CRYPT_SM2_ERR_CTRL_LEN
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_CTRL_API_TC003(int isProvider)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
uint32_t server = 1;
uint8_t badServer = 1;
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_SERVER, NULL, sizeof(uint32_t)) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_SERVER, NULL, 0) == CRYPT_NULL_INPUT);
server = 2;
ASSERT_TRUE(
CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_SERVER, &server, sizeof(uint32_t)) == CRYPT_SM2_INVALID_SERVER_TYPE);
server = 0xffffffff;
ASSERT_TRUE(
CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_SERVER, &server, sizeof(uint32_t)) == CRYPT_SM2_INVALID_SERVER_TYPE);
ASSERT_TRUE(
CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_SERVER, &badServer, sizeof(uint8_t)) == CRYPT_SM2_ERR_CTRL_LEN);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_EXCHANGE_FUNC_TC001
* @title SM2 EAL key exchange.
* @precon Vectors:
* server: The value 1 indicates the initiator, and the value 0 indicates the responder.
* User 1: private key, generate random number r, userId1
* User 2: public key, R, userId2
* @brief
* 1. Create two contexts(ctx1, ctx2) of the SM2 algorithm, expected result 1
* 2. Set userId1 and server for ctx1, expected result 2
* 3. Mock BN_RandRange to generate r, expected result 3
* 4. ctx1 generate r, expected result 4
* 5. Set userId2 and R for ctx2, expected result 5
* 6. Set private key for ctx1, expected result 6
* 7. Set public key for ctx2, expected result 7
* 8. Compute the shared key, expected result 8
* 9. Compare the output shared secret and shared secret vector, expected result 9
* 10. Duplicate ctx1 and ctx2, expected result 10
* 11. dupCtx1 generate r, expected result 11
* 12. Set R for dupCtx2, expected result 12
* 13. Compute share secret with duplicated contexts, expected result 13
* 14. Compare the output shared secret and shared secret vector, expected result 14
* @expect
* 1. Success, and two contexts are not NULL.
* 2-8. CRYPT_SUCCESS
* 9. The two shared secrets are the same.
* 10. Success, and two contexts are not NULL.
* 11-13. Success, and two contexts are not NULL.
* 14. The two shared secrets are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_EXCHANGE_FUNC_TC001(
Hex *prvKey, Hex *pubKey, Hex *r, Hex *R, Hex *shareKey, Hex *userId1, Hex *userId2, int server, int isProvider)
{
uint8_t out[500];
uint8_t localR[65];
uint32_t outLen = shareKey->len;
FuncStubInfo tmpRpInfo;
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
CRYPT_EAL_PkeyCtx *dupCtx1 = NULL;
CRYPT_EAL_PkeyCtx *dupCtx2 = NULL;
SetSm2PrvKey(&prv, prvKey->x, prvKey->len);
SetSm2PubKey(&pub, pubKey->x, pubKey->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *ctx2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx2 != NULL);
ASSERT_TRUE(ctx1 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_USER_ID, userId1->x, userId1->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_SERVER, &server, sizeof(int32_t)) == CRYPT_SUCCESS);
STUB_Init();
STUB_Replace(&tmpRpInfo, BN_RandRangeEx, STUB_RandRangeK);
ASSERT_TRUE(SetFakeRandOutput(r->x, r->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_GENE_SM2_R, localR, sizeof(localR)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_USER_ID, userId2->x, userId2->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_R, R->x, R->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx1, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx2, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(ctx1, ctx2, out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(outLen == shareKey->len);
ASSERT_TRUE(memcmp(out, shareKey->x, shareKey->len) == 0);
dupCtx1 = CRYPT_EAL_PkeyDupCtx(ctx1);
dupCtx2 = CRYPT_EAL_PkeyDupCtx(ctx2);
ASSERT_TRUE(dupCtx1 != NULL && dupCtx2 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(dupCtx1, CRYPT_CTRL_GENE_SM2_R, localR, sizeof(localR)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(dupCtx2, CRYPT_CTRL_SET_SM2_R, R->x, R->len) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(dupCtx1, dupCtx2, out, &outLen), CRYPT_SUCCESS);
EXIT:
STUB_Reset(&tmpRpInfo);
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
CRYPT_EAL_PkeyFreeCtx(dupCtx1);
CRYPT_EAL_PkeyFreeCtx(dupCtx2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_EXCHANGE_FUNC_TC002
* @title SM2 EAL key exchange.
* @precon Vectors:
* server: The value 1 indicates the initiator, and the value 0 indicates the responder.
* User 1: public key and private key, generate random number r, userId1
* User 2: public key and private key, R, userId2
* @brief
* 1. Create two contexts(ctx1, ctx2) of the SM2 algorithm, expected result 1
* 2. Set userId1 and server for ctx1, expected result 2
* 3. Mock BN_RandRange to generate r, expected result 3
* 4. ctx1 generate r, expected result 4
* 5. Set userId2 and R for ctx2, expected result 5
* 6. Set public key and private key for ctx1, expected result 6
* 7. Set public key and private key for ctx2, expected result 7
* 8. Compute the shared key, expected result 8
* 9. Compare the output shared secret and shared secret vector, expected result 9
* @expect
* 1. Success, and two contexts are not NULL.
* 2-8. CRYPT_SUCCESS
* 9. The two shared secrets are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_EXCHANGE_FUNC_TC002(Hex *prvKey1, Hex *pubKey2, Hex *prvKey2, Hex *pubKey1, Hex *r, Hex *R,
Hex *shareKey, Hex *userId1, Hex *userId2, int server, int isProvider)
{
uint8_t out[500];
uint8_t localR[65];
uint8_t badId[10] = {0};
uint32_t outLen = shareKey->len;
FuncStubInfo tmpRpInfo;
CRYPT_EAL_PkeyPrv prv1 = {0};
CRYPT_EAL_PkeyPub pub2 = {0};
CRYPT_EAL_PkeyPrv prv2 = {0};
CRYPT_EAL_PkeyPub pub1 = {0};
SetSm2PrvKey(&prv1, prvKey1->x, prvKey1->len);
SetSm2PubKey(&pub2, pubKey2->x, pubKey2->len);
SetSm2PrvKey(&prv2, prvKey2->x, prvKey2->len);
SetSm2PubKey(&pub1, pubKey1->x, pubKey1->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *ctx2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx1 != NULL);
ASSERT_TRUE(ctx2 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_USER_ID, badId, sizeof(badId)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_USER_ID, userId1->x, userId1->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_SERVER, &server, sizeof(int32_t)) == CRYPT_SUCCESS);
STUB_Init();
STUB_Replace(&tmpRpInfo, BN_RandRangeEx, STUB_RandRangeK);
ASSERT_TRUE(SetFakeRandOutput(r->x, r->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_GENE_SM2_R, localR, sizeof(localR)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_USER_ID, badId, sizeof(badId)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_USER_ID, userId2->x, userId2->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_R, R->x, R->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx1, &pub1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx2, &prv2) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx1, &prv1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx2, &pub2) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(ctx1, ctx2, out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(outLen == shareKey->len);
ASSERT_TRUE(memcmp(out, shareKey->x, shareKey->len) == 0);
EXIT:
STUB_Reset(&tmpRpInfo);
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_EXCHANGE_FUNC_TC003
* @title SM2: Generate a key pair for key exchange.
* @precon nan
* @brief
* 1. Create four contexts(selfCtx1, peerCtx1, selfCtx2, peerCtx2) of the SM2 algorithm, expected result 1
* 2. Init the DRBG, expected result 2.
* 3. Set pkg for selfCtx1 and selfCtx2, expected result 3
* 4. Call the CRYPT_EAL_PkeyGen to generate a key pair for selfCtx1, expected result 4
* 5. Call the CRYPT_EAL_PkeyGen to generate a key pair for selfCtx2, expected result 5
* 6. Get the public key from selfCtx2 and set it to peerCtx2, expected result 6
* 7. Get the public key from selfCtx1 and set it to peerCtx1, expected result 7
* 8. Set userId and server for selfCtx1 and selfCtx2, expected result 8
* 9. selfCtx1 and selfCtx2 genenrate r, expected result 9
* 10. Set userId and r for peerCtx1 and peerCtx2, expected result 10
* 11. Compute the shared key from the privite value in selfCtx1 and the public vlaue in peerCtx1, expected result 11
* 12. Compute the shared key from the privite value in selfCtx2 and the public vlaue in peerCtx2, expected result 12
* 13. Compare the shared keys computed in the preceding two steps, expected result 13
* @expect
* 1. Success, and contexts are not NULL.
* 2. Success.
* 3-12. CRYPT_SUCCESS.
* 13. The two shared keys are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_EXCHANGE_FUNC_TC003(int pkg, int isProvider)
{
uint8_t userId1[10];
uint8_t userId2[10];
uint8_t out1[500];
uint8_t out2[500];
uint8_t localR1[65];
uint8_t localR2[65];
uint32_t outLen = sizeof(out1);
int32_t server = 1;
int32_t client = 0;
(void)memset_s(userId1, sizeof(userId1), 'A', sizeof(userId1));
(void)memset_s(userId2, sizeof(userId2), 'B', sizeof(userId2));
uint8_t pubKey1[65];
uint8_t pubKey2[65];
CRYPT_EAL_PkeyPub pub1, pub2;
SetSm2PubKey(&pub1, pubKey1, sizeof(pubKey1));
SetSm2PubKey(&pub2, pubKey2, sizeof(pubKey2));
TestMemInit();
CRYPT_EAL_PkeyCtx *selfCtx1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *selfCtx2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *peerCtx1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *peerCtx2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(peerCtx1 != NULL);
ASSERT_TRUE(selfCtx2 != NULL);
ASSERT_TRUE(selfCtx1 != NULL);
ASSERT_TRUE(peerCtx2 != NULL);
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(selfCtx1, CRYPT_CTRL_SET_SM2_PKG, &pkg, sizeof(pkg)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(selfCtx2, CRYPT_CTRL_SET_SM2_PKG, &pkg, sizeof(pkg)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(selfCtx1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(selfCtx2) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(selfCtx1, &pub1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(selfCtx2, &pub2) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(peerCtx1, &pub2) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(peerCtx2, &pub1) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(selfCtx1, CRYPT_CTRL_SET_SM2_USER_ID, userId1, sizeof(userId1)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(selfCtx1, CRYPT_CTRL_SET_SM2_SERVER, &server, sizeof(int32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(selfCtx1, CRYPT_CTRL_GENE_SM2_R, localR1, sizeof(localR1)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(selfCtx2, CRYPT_CTRL_SET_SM2_USER_ID, userId2, sizeof(userId2)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(selfCtx2, CRYPT_CTRL_SET_SM2_SERVER, &client, sizeof(int32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(selfCtx2, CRYPT_CTRL_GENE_SM2_R, localR2, sizeof(localR2)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(peerCtx1, CRYPT_CTRL_SET_SM2_R, localR2, sizeof(localR2)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(peerCtx1, CRYPT_CTRL_SET_SM2_USER_ID, userId2, sizeof(userId2)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(peerCtx2, CRYPT_CTRL_SET_SM2_R, localR1, sizeof(localR1)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(peerCtx2, CRYPT_CTRL_SET_SM2_USER_ID, userId1, sizeof(userId1)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(selfCtx1, peerCtx1, out1, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(selfCtx2, peerCtx2, out2, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(out1, out2, outLen) == 0);
EXIT:
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
CRYPT_EAL_PkeyFreeCtx(selfCtx1);
CRYPT_EAL_PkeyFreeCtx(selfCtx2);
CRYPT_EAL_PkeyFreeCtx(peerCtx1);
CRYPT_EAL_PkeyFreeCtx(peerCtx2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_EXCHANGE_FUNC_TC004
* @title SM2 EAL key exchange: Default identity (server).
* @precon Vectors:
* User 1: private key, generate random number r, userId1
* User 2: public key, R, userId2
* @brief
* 1. Create two contexts(ctx1, ctx2) of the SM2 algorithm, expected result 1
* 2. Set userId1 for ctx1, expected result 2
* 3. Mock BN_RandRange to generate r, expected result 3
* 4. ctx1 generate r, expected result 4
* 5. Set userId2 and R for ctx2, expected result 5
* 6. Set private key for ctx1, expected result 6
* 7. Set public key for ctx2, expected result 7
* 8. Compute the shared key, expected result 8
* 9. Compare the output shared secret and shared secret vector, expected result 9
* 10. Copy ctx1 and ctx2, expected result 10
* 11. cpyCtx1 generate r, expected result 11
* 12. Set R for cpyCtx2, expected result 12
* 13. Compute share secret with duplicated contexts, expected result 13
* 14. Compare the output shared secret and shared secret vector, expected result 14
* @expect
* 1. Success, and two contexts are not NULL.
* 2-8. CRYPT_SUCCESS
* 9. The two shared secrets are the same.
* 10. Success, and two contexts are not NULL.
* 11-13. Success, and two contexts are not NULL.
* 14. The two shared secrets are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_EXCHANGE_FUNC_TC004(
Hex *prvKey, Hex *pubKey, Hex *r, Hex *R, Hex *shareKey, Hex *userId1, Hex *userId2, int isProvider)
{
uint8_t out[500];
uint8_t localR[65];
uint32_t outLen = shareKey->len;
FuncStubInfo tmpRpInfo;
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
CRYPT_EAL_PkeyCtx *cpyCtx1 = NULL;
CRYPT_EAL_PkeyCtx *cpyCtx2 = NULL;
SetSm2PrvKey(&prv, prvKey->x, prvKey->len);
SetSm2PubKey(&pub, pubKey->x, pubKey->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *ctx2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx1 != NULL && ctx2 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_USER_ID, userId1->x, userId1->len) == CRYPT_SUCCESS);
STUB_Init();
STUB_Replace(&tmpRpInfo, BN_RandRangeEx, STUB_RandRangeK);
ASSERT_TRUE(SetFakeRandOutput(r->x, r->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_GENE_SM2_R, localR, sizeof(localR)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_USER_ID, userId2->x, userId2->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_R, R->x, R->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx1, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx2, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(ctx1, ctx2, out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(outLen == shareKey->len);
ASSERT_TRUE(memcmp(out, shareKey->x, shareKey->len) == 0);
cpyCtx1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
cpyCtx2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(cpyCtx1 != NULL && cpyCtx2 != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCopyCtx(cpyCtx1, ctx1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(cpyCtx1, CRYPT_CTRL_GENE_SM2_R, localR, sizeof(localR)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCopyCtx(cpyCtx2, ctx2), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(cpyCtx2, CRYPT_CTRL_SET_SM2_R, R->x, R->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyComputeShareKey(cpyCtx1, cpyCtx2, out, &outLen), CRYPT_SUCCESS);
ASSERT_TRUE(outLen == shareKey->len);
ASSERT_TRUE(memcmp(out, shareKey->x, shareKey->len) == 0);
EXIT:
STUB_Reset(&tmpRpInfo);
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
CRYPT_EAL_PkeyFreeCtx(cpyCtx1);
CRYPT_EAL_PkeyFreeCtx(cpyCtx2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_EXCHANGE_CHECK_TC001
* @title SM2 EAL key exchange check.
* @precon Vectors:
* server: The value 1 indicates the initiator, and the value 0 indicates the responder.
* User 1: private key, generate random number r, userId1, optional term S
* User 2: public key , R, userId2, optional term S
* @brief
* 1. Create two contexts(ctx1, ctx2) of the SM2 algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyCtrl method, opt = CRYPT_CTRL_SM2_DO_CHECK, expected result 2
* 3. Set userId1 and server for ctx1, expected result 3
* 4. Mock BN_RandRange to generate r, expected result 4
* 5. ctx1 generate r, expected result 5
* 6. Set userId2 and R for ctx2, expected result 6
* 7. Set private key for ctx1, expected result 7
* 8. Set public key key for ctx2, expected resul 8
* 9. Compute the shared key, expected result 9
* 10. Compare the output shared secret and shared secret vector, expected result 10
* 11. Call the CRYPT_EAL_PkeyCtrl method:
* (1) opt = CRYPT_CTRL_SM2_DO_CHECK val len not equal to SM3_MD_SIZE, expected result 11
* (2) opt = CRYPT_CTRL_GET_SM2_SEND_CHECK, val len not equal to SM3_MD_SIZE, expected result 12
* (3) opt = CRYPT_CTRL_GET_SM2_SEND_CHECK, and Other parameters are valid, expected result 13
* 12. Compare the output of step 11.(3) and selfS vector, expected result 14
* 13. Call the CRYPT_EAL_PkeyCtrl method, opt = CRYPT_CTRL_SM2_DO_CHECK, expected result 15
* @expect
* 1. Success, and two contexts are not NULL.
* 2. CRYPT_SM2_ERR_S_NOT_SET
* 3-9. CRYPT_SUCCESS
* 10. The two shared secrets are the same.
* 11. CRYPT_SM2_ERR_DATA_LEN
* 12. CRYPT_SM2_BUFF_LEN_NOT_ENOUGH
* 13. CRYPT_SUCCESS
* 14. Both are the same.
* 15. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_EXCHANGE_CHECK_TC001(Hex *prvKey, Hex *pubKey, Hex *r, Hex *R, Hex *shareKey, Hex *userId1,
Hex *userId2, int server, Hex *peerS, Hex *selfS, int isProvider)
{
uint8_t out[500];
uint8_t localR[65];
uint32_t outLen = shareKey->len;
FuncStubInfo tmpRpInfo;
uint8_t val[selfS->len];
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
SetSm2PrvKey(&prv, prvKey->x, prvKey->len);
SetSm2PubKey(&pub, pubKey->x, pubKey->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx1 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *ctx2 = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_EXCH_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx2 != NULL);
ASSERT_TRUE(ctx1 != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SM2_DO_CHECK, peerS->x, peerS->len) == CRYPT_SM2_ERR_S_NOT_SET);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_USER_ID, userId1->x, userId1->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_SM2_SERVER, &server, sizeof(int32_t)) == CRYPT_SUCCESS);
STUB_Init();
STUB_Replace(&tmpRpInfo, BN_RandRangeEx, STUB_RandRangeK);
ASSERT_TRUE(SetFakeRandOutput(r->x, r->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_GENE_SM2_R, localR, sizeof(localR)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_USER_ID, userId2->x, userId2->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_SM2_R, R->x, R->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx1, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx2, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyComputeShareKey(ctx1, ctx2, out, &outLen) == CRYPT_SUCCESS);
ASSERT_TRUE(outLen == shareKey->len);
ASSERT_TRUE(memcmp(out, shareKey->x, shareKey->len) == 0);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SM2_DO_CHECK, peerS->x, peerS->len - 1) == CRYPT_SM2_ERR_DATA_LEN);
ASSERT_TRUE(
CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_GET_SM2_SEND_CHECK, val, selfS->len - 1) == CRYPT_SM2_BUFF_LEN_NOT_ENOUGH);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_GET_SM2_SEND_CHECK, val, selfS->len) == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(val, selfS->x, selfS->len) == 0);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SM2_DO_CHECK, peerS->x, peerS->len) == CRYPT_SUCCESS);
EXIT:
STUB_Reset(&tmpRpInfo);
CRYPT_EAL_PkeyFreeCtx(ctx1);
CRYPT_EAL_PkeyFreeCtx(ctx2);
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/sm2/test_suite_sdv_eal_sm2_exchange.c | C | unknown | 46,796 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* INCLUDE_BASE test_suite_sdv_eal_sm2 */
/* BEGIN_HEADER */
#include "crypt_eal_pkey.h"
#include "eal_pkey_local.h"
#include "crypt_sm2.h"
#include "sm2_local.h"
#define SM2_SIGN_MAX_LEN 74
#define SM2_PRVKEY_MAX_LEN 32
#define SM2_PUBKEY_LEN 65
#define CRYPT_EAL_PKEY_KEYMGMT_OPERATE 0
/* END_HEADER */
/**
* @test SDV_CRYPTO_SM2_GET_PUB_API_TC001
* @title SM2 CRYPT_EAL_PkeyGetPub: Test the validity of parameters.
* @precon Prepare valid public key.
* @brief
* 1. Create the context of the sm2 algorithm, expected result 1
* 2. Set the valid public key, expected result 2
* 3. Call the CRYPT_EAL_PkeyGetPub method to set public key:
* (1) pub.data = NULL, expected result 3
* (2) pub.len is invalid (pubKey.len - 1), expected result 4
* (3) all parameters are valid, expected result 5
* (4) pub.len = prvKey.len + 1, expected result 6
* 4. Compare the getted key and vector, expected result 7
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_NULL_INPUT
* 4. CRYPT_ECC_BUFF_LEN_NOT_ENOUGH
* 5. CRYPT_SUCCESS
* 6. CRYPT_SUCCESS
* 7. Both are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_GET_PUB_API_TC001(Hex *pubKey, int isProvider)
{
TestMemInit();
uint8_t buf[SM2_PUBKEY_LEN];
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
CRYPT_EAL_PkeyPub pub, pubOut;
SetSm2PubKey(&pub, pubKey->x, pubKey->len);
SetSm2PubKey(&pubOut, NULL, sizeof(buf));
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE_AND_LOG("NULL pubKey buffer", CRYPT_EAL_PkeyGetPub(ctx, &pubOut) == CRYPT_NULL_INPUT);
pubOut.key.eccPub.data = buf;
pubOut.key.eccPub.len = sizeof(buf) - 1;
ASSERT_TRUE_AND_LOG("64 len pubKey buffer", CRYPT_EAL_PkeyGetPub(ctx, &pubOut) == CRYPT_ECC_BUFF_LEN_NOT_ENOUGH);
pubOut.key.eccPub.data = buf;
pubOut.key.eccPub.len = sizeof(buf);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(ctx, &pubOut) == CRYPT_SUCCESS);
pubOut.key.eccPub.data = buf;
pubOut.key.eccPub.len = sizeof(buf) + 1;
ASSERT_TRUE(CRYPT_EAL_PkeyGetPub(ctx, &pubOut) == CRYPT_SUCCESS);
ASSERT_TRUE(pubOut.key.eccPub.len == SM2_PUBKEY_LEN);
ASSERT_TRUE(memcmp(buf, pubKey->x, pubKey->len) == 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_GET_PRV_API_TC001
* @title SM2 CRYPT_EAL_PkeyGetPrv: Test the validity of parameters.
* @precon Prepare valid private key.
* @brief
* 1. Create the context of the sm2 algorithm, expected result 1
* 2. Set the valid private key, expected result 2
* 3. Call the CRYPT_EAL_PkeyGetPrv method to set private key:
* (1) prv.data = NULL, expected result 3
* (2) prv.len is invalid (prvKey.len - 1), expected result 4
* (3) all parameters are valid, expected result 5
* (4) prv.len = prvKey.len + 1, expected result 6
* 4. Compare the getted key and vector, expected result 7
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_NULL_INPUT
* 4. CRYPT_BN_BUFF_LEN_NOT_ENOUGH
* 5. CRYPT_SUCCESS
* 6. CRYPT_SUCCESS
* 7. Both are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_GET_PRV_API_TC001(Hex *prvKey, int isProvider)
{
TestMemInit();
uint8_t buf[SM2_PRVKEY_MAX_LEN];
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
CRYPT_EAL_PkeyPrv prv, prvOut;
SetSm2PrvKey(&prv, prvKey->x, prvKey->len);
SetSm2PrvKey(&prvOut, NULL, prvKey->len);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(ctx, &prvOut) == CRYPT_NULL_INPUT);
prvOut.key.eccPrv.data = buf;
prvOut.key.eccPrv.len = prvKey->len - 1;
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(ctx, &prvOut) == CRYPT_BN_BUFF_LEN_NOT_ENOUGH);
prvOut.key.eccPrv.data = buf;
prvOut.key.eccPrv.len = prvKey->len;
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(ctx, &prvOut) == CRYPT_SUCCESS);
prvOut.key.eccPrv.data = buf;
prvOut.key.eccPrv.len = prvKey->len + 1;
ASSERT_TRUE(CRYPT_EAL_PkeyGetPrv(ctx, &prvOut) == CRYPT_SUCCESS);
ASSERT_TRUE(prvOut.key.eccPrv.len == prvKey->len);
ASSERT_TRUE(memcmp(buf, prvKey->x, prvKey->len) == 0);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_SET_PUB_API_TC001
* @title SM2 CRYPT_EAL_PkeySetPub: Test the validity of parameters.
* @precon Prepare valid public key.
* @brief
* 1. Create the context of the sm2 algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeySetPrv method to set private key:
* (1) pub.len is invalid (pubKey.len - 1), expected result 2
* (2) pub.len is invalid (pubKey.len + 1), expected result 3
* (3) public key is all 0x00, expected result 4
* (4) ctx.id != pub.id, expected result 5
* @expect
* 1. Success, and the context is not NULL.
* 2-4. CRYPT_ECC_ERR_POINT_CODE
* 5. CRYPT_EAL_ERR_ALGID
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_SET_PUB_API_TC001(Hex *pubKey, int isProvider)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
CRYPT_EAL_PkeyPub pub = {0};
uint8_t zero[SM2_PUBKEY_LEN] = {0};
SetSm2PubKey(&pub, pubKey->x, pubKey->len - 1);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx, &pub) == CRYPT_ECC_ERR_POINT_CODE);
pub.key.eccPub.len = pubKey->len + 1;
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx, &pub) == CRYPT_ECC_ERR_POINT_CODE);
pub.key.eccPub.len = pubKey->len;
pub.key.eccPub.data = zero;
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx, &pub) == CRYPT_ECC_ERR_POINT_CODE);
pub.id = CRYPT_PKEY_ED25519;
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx, &pub) == CRYPT_EAL_ERR_ALGID);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_SET_PRV_API_TC001
* @title SM2 CRYPT_EAL_PkeySetPrv: Test the validity of parameters.
* @precon Prepare valid private key.
* @brief
* 1. Create the context of the sm2 algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeySetPrv method to set private key:
* (1) prv.len is invalid (prvKey.len + 1), expected result 2
* (2) private key is all 0x00, expected result 2
* (3) private key is all 0xFF, expected result 2
* (4) value of private key == order(curve_sm2) - 1, expected result 2
* (5) ctx id is wrong, expected result 3
* @expect
* 1. Success, and the context is not NULL.
* 2. CRYPT_ECC_PKEY_ERR_INVALID_PRIVATE_KEY
* 3. CRYPT_EAL_ERR_ALGID
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_SET_PRV_API_TC001(Hex *prvKey, int isProvider)
{
uint8_t zero[SM2_PRVKEY_MAX_LEN] = {0};
uint8_t fullF[SM2_PRVKEY_MAX_LEN];
uint8_t prvKeyCopy[SM2_PRVKEY_MAX_LEN + 1] = {0};
CRYPT_EAL_PkeyPrv prv = {0};
(void)memset_s(fullF, sizeof(fullF), 0xff, sizeof(fullF));
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(memcpy_s(prvKeyCopy, SM2_PRVKEY_MAX_LEN + 1, prvKey->x, prvKey->len) == CRYPT_SUCCESS);
SetSm2PrvKey(&prv, prvKeyCopy, prvKey->len + 1);
ASSERT_TRUE_AND_LOG("invalid prv len", CRYPT_EAL_PkeySetPrv(ctx, &prv) == CRYPT_ECC_PKEY_ERR_INVALID_PRIVATE_KEY);
prv.key.eccPrv.len = prvKey->len;
prv.key.eccPrv.data = zero;
ASSERT_TRUE_AND_LOG("zero data key", CRYPT_EAL_PkeySetPrv(ctx, &prv) == CRYPT_ECC_PKEY_ERR_INVALID_PRIVATE_KEY);
prv.key.eccPrv.data = fullF;
ASSERT_TRUE_AND_LOG("full 1 key", CRYPT_EAL_PkeySetPrv(ctx, &prv) == CRYPT_ECC_PKEY_ERR_INVALID_PRIVATE_KEY);
prv.id = CRYPT_PKEY_SM2;
prv.key.eccPrv.data = prvKey->x;
prv.key.eccPrv.len = prvKey->len;
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx, &prv) == CRYPT_ECC_PKEY_ERR_INVALID_PRIVATE_KEY);
prv.id = CRYPT_PKEY_ED25519;
prv.key.eccPrv.data = prvKey->x;
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx, &prv) == CRYPT_EAL_ERR_ALGID);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_GET_SIGN_LEN_API_TC001
* @title SM2: CRYPT_EAL_PkeyGetSignLen test.
* @precon nan
* @brief
* 1. Create the context of the sm2 algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeyGetSignLen method, where pkey is NULL, expected result 2.
* 3. Call the CRYPT_EAL_PkeyGetSignLen method, where pkey is valid, expected result 3.
* @expect
* 1. Success, and context is not NULL.
* 2. Reutrn 0.
* 3. Return SM2_SIGN_MAX_LEN(72)
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_GET_SIGN_LEN_API_TC001(int isProvider)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyGetSignLen(NULL) == 0);
ASSERT_EQ(CRYPT_EAL_PkeyGetSignLen(ctx), SM2_SIGN_MAX_LEN);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_GET_KEY_LEN_API_TC001
* @title SM2: CRYPT_EAL_PkeyGetKeyLen test.
* @precon nan
* @brief
* 1. Create the context of the sm2 algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeyGetKeyLen method, where pkey is NULL, expected result 2.
* 3. Call the CRYPT_EAL_PkeyGetKeyLen method, where pkey is valid, expected result 3.
* @expect
* 1. Success, and context is not NULL.
* 2. Reutrn 0.
* 3. Return SM2_PUBKEY_LEN(65)
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_GET_KEY_LEN_API_TC001(int isProvider)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyGetKeyLen(NULL) == 0);
ASSERT_TRUE(CRYPT_EAL_PkeyGetKeyLen(ctx) == SM2_PUBKEY_LEN);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_GEN_API_TC001
* @title SM2: CRYPT_EAL_PkeyGen test.
* @precon nan
* @brief
* 1. Create the context(pkey) of the sm2 algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeyGen method, expected result 2
* 3. Register wrong rand method: FakeRandFunc(The random number it generated is 0), expected result 3
* 4. Call the CRYPT_EAL_PkeyGen method, expected result 4
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_NO_REGIST_RAND
* 3. CRYPT_ECC_PKEY_ERR_TRY_CNT
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_GEN_API_TC001(int isProvider)
{
TestMemInit();
uint8_t zero[RAND_BUF_LEN] = {0};
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(ctx) == CRYPT_NO_REGIST_RAND);
ASSERT_TRUE(SetFakeRandOutput(zero, sizeof(zero)) == CRYPT_SUCCESS);
CRYPT_RandRegist(FakeRandFunc);
CRYPT_RandRegistEx(FakeRandFuncEx);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(ctx) == CRYPT_ECC_PKEY_ERR_TRY_CNT);
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(ctx) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_SIGN_API_TC001
* @title SM2: CRYPT_EAL_PkeySign test.
* @precon Vertor: private key.
* @brief
* 1. Init the DRBG.
* 2. Create the context of the SM2 algorithm, expected result 1.
* 3. Call the CRYPT_EAL_PkeyCtrl method to set userId, expected result 2.
* 4. Call the CRYPT_EAL_PkeySign method, where all parameters are valid, expected result 3.
* 5. Free the context and create a new context of the SM2 algorithm, expected result 4.
* 6. Call the CRYPT_EAL_PkeySetPrv method to set private key, expected result 5.
* 7. Call the CRYPT_EAL_PkeyCtrl method to set userId, expected result 6.
* 8. Call the CRYPT_EAL_PkeySign method, where other parameters are valid, but:
* (1) signLen is not enough, expected result 7
* (2) sign = NULL, signLen != 0, expected result 8
* (3) msg = NULL, msgLen != 0, expected result 9
* (4) msg = NULL, msgLen = 0, expected result 10
* (5) mdId != CRYPT_MD_SM3, msg = NULL, msgLen = 0, expected result 11
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_SM2_NO_PRVKEY
* 4. Success, and context is not NULL.
* 5. CRYPT_SUCCESS
* 6. CRYPT_SUCCESS
* 7. CRYPT_SM2_BUFF_LEN_NOT_ENOUGH
* 8-9. CRYPT_NULL_INPUT
* 10. CRYPT_SUCCESS
* 11. CRYPT_EAL_ERR_ALGID
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_SIGN_API_TC001(Hex *prvKey, int isProvider)
{
uint8_t userId[SM2_PRVKEY_MAX_LEN] = {0}; // legal id
uint8_t msg[SM2_PRVKEY_MAX_LEN] = {0};
uint8_t signBuf[SM2_SIGN_MAX_LEN];
uint32_t signLen = sizeof(signBuf);
CRYPT_EAL_PkeyPrv prv = {0};
SetSm2PrvKey(&prv, prvKey->x, prvKey->len);
TestMemInit();
CRYPT_RandRegist(RandFunc);
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, &signLen) == CRYPT_SM2_NO_PRVKEY);
CRYPT_EAL_PkeyFreeCtx(ctx);
ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SM2);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
signLen -= 1;
ASSERT_TRUE(
CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, &signLen) == CRYPT_SM2_BUFF_LEN_NOT_ENOUGH);
signLen = sizeof(signBuf);
ASSERT_TRUE(CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SM3, msg, sizeof(msg), NULL, &signLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SM3, NULL, sizeof(msg), signBuf, &signLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SM3, NULL, 0, signBuf, &signLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SHA256, NULL, 0, signBuf, &signLen) == CRYPT_EAL_ERR_ALGID);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_SIGN_DATA_API_TC001
* @title SM2: CRYPT_EAL_PkeySignData test.
* @precon Vertor: private key.
* @brief
* 1. Create the context of the SM2 algorithm, expected result 1.
* 2. Set userId and private key, expected result 2.
* 3. Call the CRYPT_EAL_PkeySignData method, where all parameters are valid, expected result 3.
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_EAL_ALG_NOT_SUPPORT
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_SIGN_DATA_API_TC001(Hex *prvKey, int isProvider)
{
uint8_t userId[SM2_PRVKEY_MAX_LEN] = {0}; // legal id
uint8_t msg[SM2_PRVKEY_MAX_LEN] = {0};
uint8_t signBuf[SM2_SIGN_MAX_LEN];
uint32_t signLen = sizeof(signBuf);
CRYPT_EAL_PkeyPrv prv = {0};
SetSm2PrvKey(&prv, prvKey->x, prvKey->len);
TestMemInit();
CRYPT_RandRegist(RandFunc);
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySignData(ctx, msg, sizeof(msg), signBuf, &signLen) == CRYPT_EAL_ALG_NOT_SUPPORT);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_SIGN_API_TC002
* @title SM2: CRYPT_EAL_PkeySign test: Random number error.
* @precon Vertor: private key.
* @brief
* 1. Create the context of the SM2 algorithm, expected result 1.
* 2. Set userId and private key, expected result 2.
* 3. Call the CRYPT_EAL_PkeySign method, where all parameters are valid, expected result 3.
* 4. Register wrong rand method: FakeRandFunc(The random number it generated is 0), expected result 4.
* 5. Call the CRYPT_EAL_PkeySign method, where all parameters are valid, expected result 5.
* 6. Register correct rand method and Call the CRYPT_EAL_PkeySign method to signature, expected result 6.
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_NO_REGIST_RAND
* 4. CRYPT_SUCCESS
* 5. CRYPT_SM2_ERR_TRY_CNT or CRYPT_ECC_POINT_BLIND_WITH_ZERO
* 6. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_SIGN_API_TC002(Hex *prvKey, int isProvider)
{
uint8_t zero[RAND_BUF_LEN] = {0};
uint8_t userId[SM2_PRVKEY_MAX_LEN] = {0}; // legal id
uint8_t signBuf[SM2_SIGN_MAX_LEN];
uint32_t signLen = sizeof(signBuf);
CRYPT_EAL_PkeyPrv prv = {0};
SetSm2PrvKey(&prv, prvKey->x, prvKey->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SM3, NULL, 0, signBuf, &signLen) == CRYPT_NO_REGIST_RAND);
ASSERT_TRUE(SetFakeRandOutput(zero, sizeof(zero)) == CRYPT_SUCCESS);
CRYPT_RandRegist(FakeRandFunc);
CRYPT_RandRegistEx(FakeRandFuncEx);
int32_t ret = CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SM3, NULL, 0, signBuf, &signLen);
/* When assembly is enabled, the error code is CRYPT_SM2_ERR_TRY_CNT. Otherwise, the error code is
* CRYPT_ECC_POINT_BLIND_WITH_ZERO. */
ASSERT_TRUE(ret == CRYPT_SM2_ERR_TRY_CNT || ret == CRYPT_ECC_POINT_BLIND_WITH_ZERO);
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
ASSERT_TRUE(CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SM3, NULL, 0, signBuf, &signLen) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_VERIFY_API_TC001
* @title SM2: CRYPT_EAL_PkeyVerify test.
* @precon Vectors: public key, userId, msg, signature.
* @brief
* 1. Create the context of the SM2 algorithm, expected result 1.
* 2. Call the CRYPT_EAL_PkeyCtrl method to set userId, expected result 2.
* 3. Call the CRYPT_EAL_PkeyVerify method, where all parameters are valid, expected result 3.
* 4. Free the context and create a new context of the SM2 algorithm, expected result 4.
* 5. Set public key, expected result 5.
* 6. Set userId, expected result 6.
* 7. Call the CRYPT_EAL_PkeyVerify method:
* (1) signLen is invalid: sign->len - 1 or sign->len + 1, expected result 7
* (3) msg = NULL, msgLen != 0, expected result 8
* (2) sign = NULL, signLen != 0, expected result 9
* (4) all parameters are valid, expected result 10
* (5) mdId != CRYPT_MD_SM3, expected result 11
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_SUCCESS
* 3. CRYPT_SM2_NO_PUBKEY
* 4. Success, and context is not NULL.
* 5. CRYPT_SUCCESS
* 6. CRYPT_SUCCESS
* 7. CRYPT_DSA_DECODE_FAIL
* 8-9. CRYPT_NULL_INPUT
* 10. CRYPT_SUCCESS
* 11. CRYPT_EAL_ERR_ALGID
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_VERIFY_API_TC001(Hex *pubKey, Hex *userId, Hex *msg, Hex *sign, int isProvider)
{
CRYPT_EAL_PkeyPub pub = {0};
uint8_t bigSign[SM2_SIGN_MAX_LEN + 1] = {0};
SetSm2PubKey(&pub, pubKey->x, pubKey->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId->x, userId->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SM3, msg->x, msg->len, sign->x, sign->len) == CRYPT_SM2_NO_PUBKEY);
CRYPT_EAL_PkeyFreeCtx(ctx);
ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SM2);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(memcpy_s(bigSign, SM2_SIGN_MAX_LEN + 1, sign->x, sign->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId->x, userId->len) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SM3, msg->x, msg->len, sign->x, sign->len - 1),
BSL_ASN1_ERR_DECODE_LEN);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SM3, msg->x, msg->len, bigSign, SM2_SIGN_MAX_LEN + 1),
CRYPT_DECODE_ASN1_BUFF_FAILED);
ASSERT_TRUE(CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SM3, NULL, msg->len, sign->x, sign->len) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SM3, msg->x, msg->len, NULL, sign->len) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SM3, msg->x, msg->len, sign->x, sign->len) == CRYPT_SUCCESS);
ASSERT_TRUE(
CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SHA256, msg->x, msg->len, sign->x, sign->len) == CRYPT_EAL_ERR_ALGID);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_CTRL_API_TC001
* @title SM2 CRYPT_EAL_PkeyCtrl: Test set user id.
* @precon vector: valid R.
* @brief
* 1. Create the context of the SM2 algorithm, expected result 1
* 2. Call the CRYPT_EAL_PkeyCtrl, opt = CRYPT_CTRL_SET_SM2_USER_ID:
* (1) userId = null, idLen = 8191, and other parameters are valid, expected result 2
* (2) userId = null, idLen = 0, and other parameters are valid, expected result 3
* (3) userId != null, idLen = 8192, and other parameters are valid, expected result 4
* (4) userId != null, idLen = 8191, and other parameters are valid, expected result 5
* (5) userId != null, idLen = 1, and other parameters are valid, expected result 6
* @expect
* 1. Success, and context is not NULL.
* 2. CRYPT_NULL_INPUT
* 3-4. CRYPT_ECC_PKEY_ERR_CTRL_LEN
* 5-6. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_CTRL_API_TC001(int isProvider)
{
uint8_t userId[8192] = {0}; // max id len 8191, plus one for test
uint32_t idLen = sizeof(userId) - 1;
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, NULL, idLen) == CRYPT_NULL_INPUT);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId, 0) == CRYPT_ECC_PKEY_ERR_CTRL_LEN);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId, idLen + 1) == CRYPT_ECC_PKEY_ERR_CTRL_LEN);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId, idLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId, 1) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_SIGN_FUNC_TC001
* @title ED25519 signature test: set the key or duplicate the context, and sign.
* @precon private key, userId, random number k, msg, signature.
* @brief
* 1. Create the context(ctx) of the sm2 algorithm, expected result 1
* 2. Set the userId and private key for ctx, expected result 2
* 3. Mock BN_RandRange to generate k, expected result 3
* 4. Call the CRYPT_EAL_PkeySign method to compute signature, expected result 4
* 5. Compare the signgures of HiTLS and vector, expected result 5
* 6. Call the CRYPT_EAL_PkeyDupCtx method to dup sm2 context, expected result 6
* 7. Call the CRYPT_EAL_PkeySign method to compute signature, expected result 7
* 8. Compare the signgures of HiTLS and vector, expected result 8
* @expect
* 1. Success, and context is not NULL.
* 2-4. CRYPT_SUCCESS
* 5. Both are the same.
* 6. Success, and context is not NULL.
* 7. CRYPT_SUCCESS
* 8. Both are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_SIGN_FUNC_TC001(Hex *prvKey, Hex *userId, Hex *k, Hex *msg, Hex *sign, int isProvider)
{
uint8_t signBuf[100];
uint32_t signLen = sizeof(signBuf);
FuncStubInfo tmpRpInfo = {0};
CRYPT_EAL_PkeyCtx *dupCtx = NULL;
CRYPT_EAL_PkeyPrv prv = {0};
SetSm2PrvKey(&prv, prvKey->x, prvKey->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId->x, userId->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(SetFakeRandOutput(k->x, k->len) == CRYPT_SUCCESS);
STUB_Init();
STUB_Replace(&tmpRpInfo, BN_RandRangeEx, STUB_RandRangeK);
ASSERT_TRUE(CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SM3, msg->x, msg->len, signBuf, &signLen) == CRYPT_SUCCESS);
ASSERT_TRUE(signLen == sign->len);
ASSERT_TRUE(memcmp(signBuf, sign->x, sign->len) == 0);
dupCtx = CRYPT_EAL_PkeyDupCtx(ctx);
ASSERT_TRUE(dupCtx != NULL);
signLen = sizeof(signBuf);
ASSERT_EQ(CRYPT_EAL_PkeySign(dupCtx, CRYPT_MD_SM3, msg->x, msg->len, signBuf, &signLen), CRYPT_SUCCESS);
ASSERT_EQ(signLen, sign->len);
ASSERT_TRUE(memcmp(signBuf, sign->x, sign->len) == 0);
EXIT:
STUB_Reset(&tmpRpInfo);
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_EAL_PkeyFreeCtx(dupCtx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_SIGN_FUNC_TC002
* @title SM2 EAL layer signature function test.
* @precon prvKeyTmp, private key, userId, random number k, msg, signature.
* @brief
* 1. Create the context(ctx) of the sm2 algorithm, expected result 1
* 2. Repeatedly set the userId and private key of ctx, expected result 2
* 3. Mock BN_RandRange to generate k, expected result 3
* 4. Call the CRYPT_EAL_PkeySign method to compute signature, expected result 4
* 5. Compare the signgures of HiTLS and vector, expected result 5
* @expect
* 1. Success, and context is not NULL.
* 2-4. CRYPT_SUCCESS
* 5. Both are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_SIGN_FUNC_TC002(
Hex *prvKeyTmp, Hex *prvKey, Hex *userId, Hex *k, Hex *msg, Hex *sign, int isProvider)
{
uint8_t signBuf[100];
uint8_t userIdBuf[100] = {0};
uint32_t signLen = sizeof(signBuf);
FuncStubInfo tmpRpInfo = {0};
CRYPT_EAL_PkeyPrv prv = {0};
SetSm2PrvKey(&prv, prvKeyTmp->x, prvKeyTmp->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userIdBuf, sizeof(userIdBuf)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId->x, userId->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx, &prv) == CRYPT_SUCCESS);
prv.key.eccPrv.data = prvKey->x;
prv.key.eccPrv.len = prvKey->len;
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(SetFakeRandOutput(k->x, k->len) == CRYPT_SUCCESS);
STUB_Init();
STUB_Replace(&tmpRpInfo, BN_RandRangeEx, STUB_RandRangeK);
ASSERT_TRUE(CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SM3, msg->x, msg->len, signBuf, &signLen) == CRYPT_SUCCESS);
ASSERT_TRUE(signLen == sign->len);
ASSERT_TRUE(memcmp(signBuf, sign->x, sign->len) == 0);
EXIT:
STUB_Reset(&tmpRpInfo);
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_VERIFY_FUNC_TC001
* @title SM2 verify test: set public key or duplicate the context, and verify.
* @precon public key, userId, msg, signature.
* @brief
* 1. Create the context(ctx) of the sm2 algorithm, expected result 1
* 2. Set the userId and public key of ctx, expected result 2
* 3. Call the CRYPT_EAL_PkeyVerify method to verify, expected result 3
* 4. Call the CRYPT_EAL_PkeyDupCtx method to dup sm2 context, expected result 4
* 5. Call the CRYPT_EAL_PkeyVerify method to verify, expected result 5
* @expect
* 1. Success, and context is not NULL.
* 2-3. CRYPT_SUCCESS
* 4. Success, and context is not NULL.
* 5. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_VERIFY_FUNC_TC001(Hex *pubKey, Hex *userId, Hex *msg, Hex *sign, int isProvider)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
CRYPT_EAL_PkeyPub pub = {0};
SetSm2PubKey(&pub, pubKey->x, pubKey->len);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId->x, userId->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SM3, msg->x, msg->len, sign->x, sign->len) == CRYPT_SUCCESS);
CRYPT_EAL_PkeyCtx *dupCtx = CRYPT_EAL_PkeyDupCtx(ctx);
ASSERT_TRUE(dupCtx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyVerify(dupCtx, CRYPT_MD_SM3, msg->x, msg->len, sign->x, sign->len) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_EAL_PkeyFreeCtx(dupCtx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_VERIFY_FUNC_TC002
* @title SM2 verify test: Repeatedly set public key, and verify.
* @precon public key, userId, msg, signature.
* @brief
* 1. Create the context(ctx) of the sm2 algorithm, expected result 1
* 2. Repeatedly set the userId and public key of ctx, expected result 2
* 3. Call the CRYPT_EAL_PkeyVerify method to verify, expected result 3
* @expect
* 1. Success, and context is not NULL.
* 2-3. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_VERIFY_FUNC_TC002(
Hex *pubKeyTmp, Hex *pubKey, Hex *userId, Hex *msg, Hex *sign, int isProvider)
{
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
CRYPT_EAL_PkeyPub pub = {0};
SetSm2PubKey(&pub, pubKeyTmp->x, pubKeyTmp->len);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId->x, userId->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx, &pub) == CRYPT_SUCCESS);
pub.key.eccPub.data = pubKey->x;
pub.key.eccPub.len = pubKey->len;
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SM3, msg->x, msg->len, sign->x, sign->len) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_SIGN_VERIFY_FUNC_TC001
* @title SM2: Generate a key pair for signature and verify.
* @precon nan
* @brief
* 1. Create the context(ctx) of the sm2 algorithm, expected result 1
* 2. Initialize the DRBG, expected result 2
* 3. Call the CRYPT_EAL_PkeyGen to generate a key pair, expected result 3
* 4. Set the userId for ctx, expected result 4
* 5. Call the CRYPT_EAL_PkeySign method to compute signature, expected result 5
* 6. Call the CRYPT_EAL_PkeyVerify method to verify signature, expected result 6
* 7. Call the CRYPT_EAL_PkeyDupCtx method to dup sm2 context, expected result 7
* 8. Call the CRYPT_EAL_PkeySign method to compute signature, expected result 8
* 9. Call the CRYPT_EAL_PkeyVerify method to verify signature, expected result 9
* 10. Call the CRYPT_EAL_PkeyCpyCtx method to dup sm2 context, expected result 10
* 11. Call the CRYPT_EAL_PkeySign method to compute signature, expected result 11
* 12. Call the CRYPT_EAL_PkeyVerify method to verify signature, expected result 12
* @expect
* 1. Success, and context is not NULL.
* 2-6. CRYPT_SUCCESS
* 7. Success, and context is not NULL.
* 8-12. CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_SIGN_VERIFY_FUNC_TC001(int isProvider)
{
uint8_t userId[SM2_PRVKEY_MAX_LEN] = {0}; // legal id
uint8_t signBuf[SM2_SIGN_MAX_LEN];
uint8_t msg[SM2_PRVKEY_MAX_LEN] = {0};
uint32_t signLen = sizeof(signBuf);
CRYPT_EAL_PkeyCtx *dupCtx = NULL;
CRYPT_EAL_PkeyCtx *cpyCtx = NULL;
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
ASSERT_TRUE(CRYPT_EAL_PkeyGen(ctx) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, &signLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, signLen) == CRYPT_SUCCESS);
dupCtx = CRYPT_EAL_PkeyDupCtx(ctx);
ASSERT_TRUE(dupCtx != NULL);
ASSERT_EQ(dupCtx->references.count, 1);
signLen = sizeof(signBuf);
ASSERT_EQ(CRYPT_EAL_PkeySign(dupCtx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, &signLen), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyVerify(dupCtx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, signLen) == CRYPT_SUCCESS);
cpyCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(cpyCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeyCopyCtx(cpyCtx, ctx), CRYPT_SUCCESS);
signLen = sizeof(signBuf);
ASSERT_EQ(CRYPT_EAL_PkeySign(cpyCtx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, &signLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(cpyCtx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, signLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_EAL_PkeyFreeCtx(dupCtx);
CRYPT_EAL_PkeyFreeCtx(cpyCtx);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_VERIFY_FUNC_TC003
* @title SM2: Test verification failure scenario.
* @precon public key, userId, msg, signature, one of the vectors is wrong.
* @brief
* 1. Create the context(ctx) of the sm2 algorithm, expected result 1
* 2. Repeatedly set the userId and public key of ctx, expected result 2
* 3. Call the CRYPT_EAL_PkeyVerify method to verify, expected result 3
* @expect
* 1. Success, and context is not NULL.
* 2-3. Not CRYPT_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_VERIFY_FUNC_TC003(Hex *pubKey, Hex *userId, Hex *msg, Hex *sign, int isProvider)
{
CRYPT_EAL_PkeyPub pub = {0};
SetSm2PubKey(&pub, pubKey->x, pubKey->len);
TestMemInit();
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId->x, userId->len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx, &pub) == CRYPT_SUCCESS);
// Different errors will return different error codes.
ASSERT_TRUE(CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SM3, msg->x, msg->len, sign->x, sign->len) != CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_SIGN_VERIFY_FUNC_TC002
* @title SM2: The private/public key is not cleaned up when setting the public/private key.
* @precon public key, userId, msg, signature, one of the vectors is wrong.
* @brief
* 1. Create the context(ctx) of the sm2 algorithm, expected result 1
* 2. Repeatedly set the userId, public key and private key of ctx, expected result 2
* 3. Call the CRYPT_EAL_PkeySign method to signature, expected result 3
* 4. Call the CRYPT_EAL_PkeyVerify method to verify, expected result 4
* @expect
* 1. Success, and context is not NULL.
* 2-4. CRYPT_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_SIGN_VERIFY_FUNC_TC002(Hex *pubKey, Hex *prvKey, int isProvider)
{
TestMemInit();
uint8_t userId[SM2_PRVKEY_MAX_LEN] = {0}; // legal id
uint8_t signBuf[SM2_SIGN_MAX_LEN];
uint8_t msg[SM2_PRVKEY_MAX_LEN] = {0};
uint32_t signLen = sizeof(signBuf);
CRYPT_EAL_PkeyPub pub = {0};
CRYPT_EAL_PkeyPrv prv = {0};
SetSm2PubKey(&pub, pubKey->x, pubKey->len);
SetSm2PrvKey(&prv, prvKey->x, prvKey->len);
CRYPT_RandRegist(RandFunc);
CRYPT_RandRegistEx(RandFuncEx);
CRYPT_EAL_PkeyCtx *ctx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeySetPrv(ctx, &prv) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySetPub(ctx, &pub) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, &signLen) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, signLen) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_KEY_PAIR_CHECK_FUNC_TC001
* @title SM2: key pair check.
* @precon Registering memory-related functions.
* @brief
* 1. Create two contexts(pubCtx, prvCtx) of the sm2 algorithm, expected result 1
* 2. Set public key for pubCtx, expected result 2
* 3. Set private key for prvCtx, expected result 3
* 4. Set userId for pubCtx and prvCtx, expected result 4
* 5. Init the drbg, expected result 5
* 6. Check whether the public key matches the private key, expected result 6
* @expect
* 1. Success, and contexts are not NULL.
* 2-5. CRYPT_SUCCESS
* 6. Return CRYPT_SUCCESS when expect is 1, CRYPT_SM2_VERIFY_FAIL otherwise.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_KEY_PAIR_CHECK_FUNC_TC001(Hex *pubKey, Hex *prvKey, Hex *userId, int expect, int isProvider)
{
#if !defined(HITLS_CRYPTO_SM2_CHECK)
(void)pubKey;
(void)prvKey;
(void)userId;
(void)expect;
(void)isProvider;
SKIP_TEST();
#else
CRYPT_EAL_PkeyCtx *pubCtx = NULL;
CRYPT_EAL_PkeyCtx *prvCtx = NULL;
CRYPT_EAL_PkeyPub pub = {0};
CRYPT_EAL_PkeyPrv prv = {0};
int expectRet = expect == 1 ? CRYPT_SUCCESS : CRYPT_SM2_PAIRWISE_CHECK_FAIL;
SetSm2PubKey(&pub, pubKey->x, pubKey->len);
SetSm2PrvKey(&prv, prvKey->x, prvKey->len);
TestMemInit();
pubCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
prvCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pubCtx != NULL && prvCtx != NULL);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubCtx, &pub), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &prv), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pubCtx, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(prvCtx, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId)) == CRYPT_SUCCESS);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), expectRet);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pubCtx);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_GET_KEY_BITS_FUNC_TC001
* @title SM2: get key bits.
* @brief
* 1. Create a context of the SM2 algorithm, expected result 1
* 2. Get key bits, expected result 2
* @expect
* 1. Success, and context is not NULL.
* 2. Equal to keyBits.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_GET_KEY_BITS_FUNC_TC001(int id, int keyBits, int isProvider)
{
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, id,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE + CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(CRYPT_EAL_PkeyGetKeyBits(pkey) == (uint32_t)keyBits);
EXIT:
CRYPT_EAL_PkeyFreeCtx(pkey);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_CHECK_KEYPAIR_FUNC_TC001
* @title SM2 CRYPT_EAL_PkeyPairCheck test.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_CHECK_KEYPAIR_FUNC_TC001(int isProvider)
{
#if !defined(HITLS_CRYPTO_SM2_CHECK)
(void)isProvider;
SKIP_TEST();
#else
TestMemInit();
uint8_t wrong[100] = {1};
CRYPT_EAL_PkeyPub sm2PubKey = {0};
CRYPT_EAL_PkeyPrv sm2PrvKey = {0};
uint8_t pubKeyVector[100];
uint32_t pubKeyVectorLen = sizeof(pubKeyVector);
uint8_t prvKeyVector[100];
uint32_t prvKeyVectorLen = sizeof(prvKeyVector);
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *pubCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *prvCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(pubCtx != NULL);
ASSERT_TRUE(prvCtx != NULL);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
SetSm2PubKey(&sm2PubKey, pubKeyVector, pubKeyVectorLen);
SetSm2PrvKey(&sm2PrvKey, prvKeyVector, prvKeyVectorLen);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pkey, pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPub(pkey, &sm2PubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &sm2PrvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pubCtx, &sm2PubKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &sm2PrvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_SUCCESS);
sm2PrvKey.key.eccPrv.data = wrong;
ASSERT_EQ(CRYPT_EAL_PkeySetPrv(prvCtx, &sm2PrvKey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPairCheck(pubCtx, prvCtx), CRYPT_SM2_PAIRWISE_CHECK_FAIL);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(pubCtx);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM2_CHECK_PRVKEY_FUNC_TC001
* @title SM2 CRYPT_EAL_PkeyPrvCheck test.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM2_CHECK_PRVKEY_FUNC_TC001(int isProvider)
{
#if !defined(HITLS_CRYPTO_SM2_CHECK)
(void)isProvider;
SKIP_TEST();
#else
TestMemInit();
CRYPT_EAL_PkeyPrv sm2PrvKey = {0};
CRYPT_SM2_Ctx *ctx = NULL;
BN_BigNum *n = NULL;
BN_BigNum *prvKey = NULL;
uint8_t prvKeyVector[100];
uint32_t prvKeyVectorLen = sizeof(prvKeyVector);
CRYPT_EAL_PkeyCtx *pkey = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
CRYPT_EAL_PkeyCtx *prvCtx = TestPkeyNewCtx(NULL, CRYPT_PKEY_SM2,
CRYPT_EAL_PKEY_KEYMGMT_OPERATE, "provider=default", isProvider);
ASSERT_TRUE(pkey != NULL);
ASSERT_TRUE(prvCtx != NULL);
ASSERT_EQ(TestRandInit(), CRYPT_SUCCESS);
SetSm2PrvKey(&sm2PrvKey, prvKeyVector, prvKeyVectorLen);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_ECC_PKEY_ERR_EMPTY_KEY);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SUCCESS);
ctx = (CRYPT_SM2_Ctx *)pkey->key;
prvKey = ctx->pkey->prvkey;
n = ECC_GetParaN(ctx->pkey->para);
(void)BN_Copy(prvKey, n); // key = n
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SM2_INVALID_PRVKEY);
(void)BN_SubLimb(prvKey, prvKey, 1); // key = n - 1
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SM2_INVALID_PRVKEY);
(void)BN_SubLimb(prvKey, prvKey, 1); // key = n - 2
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SUCCESS);
(void)BN_Zeroize(prvKey); // key = 0
ASSERT_EQ(CRYPT_EAL_PkeyPrvCheck(pkey), CRYPT_SM2_INVALID_PRVKEY);
EXIT:
TestRandDeInit();
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
BN_Destroy(n);
#endif
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/sm2/test_suite_sdv_eal_sm2_sign.c | C | unknown | 45,949 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <pthread.h>
#include "crypt_eal_md.h"
#include "bsl_sal.h"
#include "eal_md_local.h"
#include "crypt_algid.h"
#include "crypt_errno.h"
#include "securec.h"
/* END_HEADER */
typedef struct {
uint8_t *data;
uint8_t *hash;
uint32_t dataLen;
uint32_t hashLen;
} ThreadParameter;
void MultiThreadTest(void *arg)
{
ThreadParameter *threadParameter = (ThreadParameter *)arg;
uint8_t out[32];
uint32_t outLen = sizeof(out);
CRYPT_EAL_MdCTX *ctx = NULL;
ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SM3);
ASSERT_TRUE(ctx != NULL);
for (uint32_t i = 0; i < 10; i++) {
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, threadParameter->data, threadParameter->dataLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("hash result cmp", out, outLen, threadParameter->hash, threadParameter->hashLen);
}
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/**
* @test SDV_CRYPT_EAL_SM3_API_TC001
* @title CRYPT_EAL_MdUpdate and CRYPT_EAL_MdFinal test
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdDeinit the null CTX, expected result 1.
* 2.Invoke the CRYPT_EAL_MdNewCtx to create a CTX, expected result 2.
* 3.Call CRYPT_EAL_MdUpdate and CRYPT_EAL_MdFinal before initialization, expected result 3 is obtained.
* 4.Initialize the CTX and transfer null pointers to CRYPT_EAL_MdUpdate and CRYPT_EAL_MdFinal. expected result 4.
* 5.Invoke CRYPT_EAL_MdUpdate and CRYPT_EAL_MdFinal normally, expected result 5.
* 6.Call CRYPT_EAL_MdDeinit the CTX, expected result 6.
* @expect
* 1.Return CRYPT_NULL_INPUT
* 2.Successful, ctx is returned.
* 3.Return CRYPT_EAL_ERR_STATE
* 4.Return CRYPT_NULL_INPUT
* 5.Return CRYPT_SUCCESS
* 6.Return CRYPT_SUCCESS
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SM3_API_TC001(void)
{
TestMemInit();
uint8_t input[100]; // Any length, for example, 100 bytes.
uint32_t inLen = sizeof(input);
uint8_t out[32]; // SM3 digest length is 32.
uint32_t outLen = sizeof(out);
uint32_t badOutLen = outLen - 1;
uint32_t longOutLen = outLen + 1;
ASSERT_EQ(CRYPT_EAL_MdGetDigestSize(CRYPT_MD_SM3), outLen);
CRYPT_EAL_MdCTX *ctx = NULL;
ASSERT_EQ(CRYPT_EAL_MdDeinit(ctx), CRYPT_NULL_INPUT);
ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SM3);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &outLen), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, input, inLen), CRYPT_EAL_ERR_STATE);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(NULL, input, inLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, NULL, inLen), CRYPT_NULL_INPUT);
// Hash counting can be performed on empty strings.
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, input, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, input, inLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, NULL, &outLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdFinal(NULL, out, &outLen), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, NULL), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &badOutLen), CRYPT_SM3_OUT_BUFF_LEN_NOT_ENOUGH);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, input, inLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &longOutLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdGetId(ctx), CRYPT_MD_SM3);
ASSERT_EQ(CRYPT_EAL_MdDeinit(ctx), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SM3_FUNC_TC001
* @title CRYPT_EAL_MdFinal test without update.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdNewCtx to create ctx, expected result 1.
* 2.Call CRYPT_EAL_MdFinal get results. expected result 2.
* 3.Compare with expected results. expected result 3.
* @expect
* 1.The ctx is created successful.
* 2.Successful.
* 2.Consistent with expected results.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SM3_FUNC_TC001(Hex *hash)
{
TestMemInit();
uint8_t out[32]; // SM3 digest length is 32.
uint32_t outLen = sizeof(out);
CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SM3);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(outLen, 32);
ASSERT_EQ(memcmp(out, hash->x, hash->len), 0);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SM3_FUNC_TC002
* @title Perform the vector test to check whether the calculation result is consistent with the standard output.
* @precon nan
* @brief
* 1.Calculate the hash of each group of data, expected result 1.
* 2.Compare the result to the expected value, expected result 2.
* 6.Call CRYPT_EAL_Md to calculate the hash value, expected result 3.
* @expect
* 1.Hash calculation succeeded.
* 2.The results are as expected.
* 3.Obtains the expected hash of data
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SM3_FUNC_TC002(Hex *data, Hex *hash)
{
TestMemInit();
uint8_t out[32]; // SM3 digest length is 32
uint32_t outLen = sizeof(out);
CRYPT_EAL_MdCTX *ctx = NULL;
ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SM3);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, data->x, data->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(outLen, 32);
ASSERT_EQ(memcmp(out, hash->x, hash->len), 0);
ASSERT_EQ(CRYPT_EAL_Md(CRYPT_MD_SM3, data->x, data->len, out, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(memcmp(out, hash->x, hash->len), 0);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_SM3_FUNC_TC003
* @title Hash calculation for multiple updates,comparison with standard results.
* @precon nan
* @brief
* 1.Call CRYPT_EAL_MdNewCtx to create a ctx and initialize, expected result 1.
* 2.Call CRYPT_EAL_MdUpdate to calculate the hash of a data segmentxpected result 2.
* 3.Call CRYPT_EAL_MdUpdate to calculate the next data segmentxpected result 3.
* 4.Call CRYPT_EAL_MdUpdate to calculate the next data segmentxpected result 4.
* 5.Call CRYPT_EAL_MdFinal get the result, expected result 5.
* @expect
* 1.Successful
* 2.Successful
* 3.Successful
* 4.Successful
* 5.The results are as expected.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SM3_FUNC_TC003(Hex *data1, Hex *data2, Hex *data3, Hex *hash)
{
TestMemInit();
uint8_t out[32]; // 32 is sm3 hash size
uint32_t outLen = sizeof(out);
CRYPT_EAL_MdCTX *ctx = NULL;
ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SM3);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, data1->x, data1->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, data2->x, data2->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, data3->x, data3->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, out, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(outLen, 32);
ASSERT_EQ(memcmp(out, hash->x, hash->len), 0);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_MD_SHA2_FUNC_TC001
* @title Split the data and update test.
* @precon nan
* @brief
* 1.Create two ctx and initialize them, expected result 1.
* 2.Use ctx1 to update data 100 times, expected result 2.
* 3.Use ctx2 to update all data at once, expected result 3.
* 4.Compare two outputs, expected result 4.
* @expect
* 1.Successful.
* 2.Successful.
* 3.Successful.
* 4.The results are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_SM3_FUNC_TC004(void)
{
TestMemInit();
CRYPT_EAL_MdCTX *ctx1 = NULL;
CRYPT_EAL_MdCTX *ctx2 = NULL;
ctx1 = CRYPT_EAL_MdNewCtx(CRYPT_MD_SM3);
ASSERT_TRUE(ctx1 != NULL);
ctx2 = CRYPT_EAL_MdNewCtx(CRYPT_MD_SM3);
ASSERT_TRUE(ctx2 != NULL);
// 100! = 5050
uint8_t input[5050];
uint32_t inLenTotal = 0;
uint32_t inLenBase;
uint8_t out1[100];
uint8_t out2[100];
uint32_t outLen = CRYPT_EAL_MdGetDigestSize(CRYPT_MD_SM3);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx2), CRYPT_SUCCESS);
for (inLenBase = 1; inLenBase <= 100; inLenBase++) {
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx1, input + inLenTotal, inLenBase), CRYPT_SUCCESS);
inLenTotal += inLenBase;
}
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx1, out1, &outLen), CRYPT_SUCCESS);
outLen = CRYPT_EAL_MdGetDigestSize(CRYPT_MD_SM3);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx2, input, inLenTotal), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx2, out2, &outLen), CRYPT_SUCCESS);
outLen = CRYPT_EAL_MdGetDigestSize(CRYPT_MD_SM3);
ASSERT_EQ(memcmp(out1, out2, outLen), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx1);
CRYPT_EAL_MdFreeCtx(ctx2);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM3_COPY_CTX_FUNC_TC001
* @title MD5 copy ctx function test.
* @precon nan
* @brief
* 1. Create the context ctx of md algorithm, expected result 1
* 2. Call to CRYPT_EAL_MdCopyCtx method to copy ctx, expected result 2
* 2. Call to CRYPT_EAL_MdCopyCtx method to copy a null ctx, expected result 3
* 3. Calculate the hash of msg, and compare the calculated result with hash vector, expected result 4
* 4. Call to CRYPT_EAL_MdDupCtx method to copy ctx, expected result 5
* 3. Calculate the hash of msg, and compare the calculated result with hash vector, expected result 6
* @expect
* 1. Success, the context is not null.
* 2. CRYPT_SUCCESS
* 3. CRYPT_NULL_INPUT
* 4. Success, the context is not null.
* 5. CRYPT_SUCCESS
* 6. Success, the hashs are the same.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM3_COPY_CTX_FUNC_TC001(int id, Hex *msg, Hex *hash)
{
TestMemInit();
CRYPT_EAL_MdCTX *cpyCtx = NULL;
CRYPT_EAL_MdCTX *dupCtx = NULL;
CRYPT_EAL_MdCTX *ctx = CRYPT_EAL_MdNewCtx(id);
ASSERT_TRUE(ctx != NULL);
uint8_t output[32]; // SM3 digest length is 32
uint32_t outLen = sizeof(output);
dupCtx=CRYPT_EAL_MdDupCtx(cpyCtx);
ASSERT_TRUE(dupCtx == NULL);
ASSERT_EQ(CRYPT_MD_MAX, CRYPT_EAL_MdGetId(dupCtx));
cpyCtx = CRYPT_EAL_MdNewCtx(id);
ASSERT_TRUE(cpyCtx != NULL);
ASSERT_TRUE(dupCtx == NULL);
ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, dupCtx), CRYPT_NULL_INPUT);
ASSERT_EQ(CRYPT_EAL_MdCopyCtx(cpyCtx, ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdInit(cpyCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(cpyCtx, msg->x, msg->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(cpyCtx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(id, cpyCtx->id);
ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
dupCtx=CRYPT_EAL_MdDupCtx(ctx);
ASSERT_TRUE(dupCtx != NULL);
ASSERT_EQ(CRYPT_EAL_MdInit(dupCtx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(dupCtx, msg->x, msg->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(dupCtx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(id, CRYPT_EAL_MdGetId(dupCtx));
ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
CRYPT_EAL_MdFreeCtx(cpyCtx);
CRYPT_EAL_MdFreeCtx(dupCtx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_SM3_DEFAULT_PROVIDER_FUNC_TC001
* @title Default provider testing
* @precon nan
* @brief
* Load the default provider and use the test vector to test its correctness
*/
/* BEGIN_CASE */
void SDV_CRYPTO_SM3_DEFAULT_PROVIDER_FUNC_TC001(int id, Hex *msg, Hex *hash)
{
TestMemInit();
CRYPT_EAL_MdCTX *ctx = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
ctx = CRYPT_EAL_ProviderMdNewCtx(NULL, id, "provider=default");
#else
ctx = CRYPT_EAL_MdNewCtx(id);
#endif
ASSERT_TRUE(ctx != NULL);
uint8_t output[32]; // SM3 digest length is 32
uint32_t outLen = sizeof(output);
ASSERT_EQ(CRYPT_EAL_MdInit(ctx), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdUpdate(ctx, msg->x, msg->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MdFinal(ctx, output, &outLen), CRYPT_SUCCESS);
ASSERT_EQ(memcmp(output, hash->x, hash->len), 0);
EXIT:
CRYPT_EAL_MdFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPT_EAL_MD_SM3_FUNC_TC001
* @title Test multi-thread hash calculation.
* @precon nan
* @brief
* 1.Create two threads and calculate the hash, expected result 1.
* 2.Compare the result to the expected value, expected result 2.
* @expect
* 1.Hash calculation succeeded.
* 2.The results are as expected.
*/
/* BEGIN_CASE */
void SDV_CRYPT_EAL_MD_SM3_FUNC_TC001(Hex *data, Hex *hash)
{
int ret;
TestMemInit();
const uint32_t threadNum = 2;
pthread_t thrd[2];
ThreadParameter arg[2] = {
{data->x, hash->x, data->len, hash->len},
{data->x, hash->x, data->len, hash->len}
};
for (uint32_t i = 0; i < threadNum; i++) {
ret = pthread_create(&thrd[i], NULL, (void *)MultiThreadTest, &arg[i]);
ASSERT_TRUE(ret == 0);
}
for (uint32_t i = 0; i < threadNum; i++) {
pthread_join(thrd[i], NULL);
}
EXIT:
return;
}
/* END_CASE */
| 2302_82127028/openHiTLS-examples_1508 | testcode/sdv/testcase/crypto/sm3/test_suite_sdv_eal_sm3.c | C | unknown | 13,952 |