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 |
|---|---|---|---|---|---|
# 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.
add_executable(process ${openHiTLS_SRC}/testcode/framework/process/process.c)
set_target_properties(process PROPERTIES
RUNTIME_OUTPUT_DIRECTORY "${openHiTLS_SRC}/testcode/output"
)
target_include_directories(process PRIVATE
${openHiTLS_SRC}/platform/Secure_C/include
${openHiTLS_SRC}/testcode/framework/tls/resource/include
${openHiTLS_SRC}/testcode/framework/tls/base/include
${openHiTLS_SRC}/testcode/framework/tls/process/include
${openHiTLS_SRC}/testcode/framework/tls/include
${openHiTLS_SRC}/testcode/framework/tls/transfer/include
${openHiTLS_SRC}/testcode/framework/tls/rpc/include
${openHiTLS_SRC}/include/bsl
${openHiTLS_SRC}/include/crypto
${openHiTLS_SRC}/bsl/sal/include
${openHiTLS_SRC}/bsl/hash/include
${openHiTLS_SRC}/bsl/uio/src
${openHiTLS_SRC}/bsl/uio/include
${openHiTLS_SRC}/include/tls
${openHiTLS_SRC}/include/crypto
${openHiTLS_SRC}/tls/include
${openHiTLS_SRC}/config/macro_config
)
target_link_directories(process
PRIVATE
${openHiTLS_SRC}/build
${openHiTLS_SRC}/testcode/output/lib
${openHiTLS_SRC}/platform/Secure_C/lib
)
set(PROCESS_LIBS tls_hlt tls_frame hitls_tls)
if(ENABLE_PKI AND ${BUILD_PKI} GREATER -1)
list(APPEND PROCESS_LIBS hitls_pki)
endif()
list(APPEND PROCESS_LIBS hitls_crypto hitls_bsl boundscheck pthread dl rec_wrapper)
target_link_libraries(process ${PROCESS_LIBS})
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/process/CMakeLists.txt | CMake | unknown | 1,991 |
/*
* 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 <signal.h>
#include <unistd.h>
#include <stdbool.h>
#include <semaphore.h>
#include "securec.h"
#include "channel_res.h"
#include "handle_cmd.h"
#include "tls_res.h"
#include "control_channel.h"
#include "logger.h"
#include "lock.h"
#include "rpc_func.h"
#include "hlt_type.h"
#include "hlt.h"
#include "process.h"
#define DOMAIN_PATH_LEN (128)
#define SUCCESS 0
#define ERROR (-1)
#define ASSERT_RETURN(condition, log) \
do { \
if (!(condition)) { \
LOG_ERROR(log); \
return ERROR; \
} \
} while (0)
int IsFeedbackResult(ControlChannelRes *channelInfo)
{
int i, ret;
ControlChannelBuf dataBuf = {0};
OsLock(channelInfo->sendBufferLock);
if (channelInfo->sendBufferNum == 0) {
OsUnLock(channelInfo->sendBufferLock);
return SUCCESS;
}
i = 0;
while (channelInfo->sendBufferNum > 0) {
ret = memcpy_s(dataBuf.data, CONTROL_CHANNEL_MAX_MSG_LEN,
channelInfo->sendBuffer[i], strlen((char*)(channelInfo->sendBuffer[i])));
if (ret != EOK) {
LOG_ERROR("MemCpy Error");
OsUnLock(channelInfo->sendBufferLock);
return ERROR;
}
dataBuf.dataLen = strlen((char*)channelInfo->sendBuffer[i]);
LOG_DEBUG("Remote Process Send Result %s", dataBuf.data);
ret = ControlChannelWrite(channelInfo->sockFd, channelInfo->peerDomainPath, &dataBuf);
if (ret != EOK) {
LOG_ERROR("ControlChannelWrite Error, Msg is %s, ret is %d\n", dataBuf.data, ret);
OsUnLock(channelInfo->sendBufferLock);
return ERROR;
}
LOG_DEBUG("Remote Process Send Result %s Success", dataBuf.data);
channelInfo->sendBufferNum--;
i++;
}
OsUnLock(channelInfo->sendBufferLock);
return SUCCESS;
}
void FreeThreadRes(pthread_t *threadList, int threadNum)
{
for (int i = 0; i < threadNum; i++) {
pthread_cancel(threadList[i]);
pthread_join(threadList[i], NULL);
}
return;
}
void ThreadExcuteCmd(void *param)
{
CmdData cmdData = {0};
if (memcpy_s(&cmdData, sizeof(cmdData), (CmdData *)param, sizeof(CmdData)) != EOK) {
free(param);
return;
}
free(param);
ControlChannelRes *channelInfo = GetControlChannelRes();
(int)ExecuteCmd(&cmdData);
PushResultToChannelSendBuffer(channelInfo, cmdData.result);
return;
}
int main(int argc, char **argv)
{
int ret, sctpFd;
ControlChannelRes* channelInfo = NULL;
ControlChannelBuf dataBuf;
CmdData exitCmdData = {0};
CmdData* cmdData = NULL;
Process* process = NULL;
pid_t ppid = atoi(argv[4]);
(void)ppid;
// Do not set the output buffer
setbuf(stdout, NULL);
LOG_DEBUG("argv value is %d", argc);
ret = InitProcess();
ASSERT_RETURN(ret == SUCCESS, "InitProcess Error");
process = GetProcess();
process->remoteFlag = 1; // Must be marked as a remote process
process->tlsType = atoi(argv[1]); // The first parameter indicates the Hitls function
ret = memcpy_s(process->srcDomainPath, DOMAIN_PATH_LEN, argv[2],
strlen(argv[2])); // The second parameter indicates the local IP address
ASSERT_RETURN(ret == SUCCESS, "memcpy process->srcDomainPath Error");
ret = memcpy_s(process->peerDomainPath, DOMAIN_PATH_LEN, argv[3],
strlen(argv[3])); // The third parameter indicates the address of the control process
ASSERT_RETURN(ret == SUCCESS, "memcpy process->srcDomainPath Error");
// Dependent library initialization
ret = HLT_LibraryInit(process->tlsType);
ASSERT_RETURN(ret == SUCCESS, "HLT_TlsRegCallback Error");
// Initialize the linked list for storing CTX and SSL
ret = InitTlsResList();
ASSERT_RETURN(ret == SUCCESS, "InitTlsResList Error");
// Initializes the global variable that stores the control channel information.
ret = InitControlChannelRes(process->srcDomainPath, strlen(process->srcDomainPath),
process->peerDomainPath, strlen(process->peerDomainPath));
ASSERT_RETURN(ret == SUCCESS, "ChannelInfoInit Error");
// Creating a Control Link UDP DOMAIN SOCKET
channelInfo = GetControlChannelRes();
ret = ControlChannelInit(channelInfo);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelInit Error");
// Print information
LOG_DEBUG("Create Remote Process Successful");
// The message is sent to the peer end, indicating that the process is started successfully
PushResultToChannelSendBuffer(channelInfo, "0|HEART");
while (1) {
if (kill(ppid, 0) != 0) {
LOG_DEBUG("\nthe parent process [%u] does not exist, I want to exist\n", ppid);
break;
}
// Waiting for the command from the peer end
ret = ControlChannelRead(channelInfo->sockFd, &dataBuf);
if (ret == 0) {
// Receives a message, parses the message, and performs related operations
LOG_DEBUG("Remote Process Rcv Cmd Is: %s", dataBuf.data);
cmdData = (CmdData*)malloc(sizeof(CmdData));
if (cmdData == NULL) {
LOG_ERROR("Malloc cmdData Error");
break;
}
ret = ParseCmdFromBuf(&dataBuf, cmdData);
if (ret != SUCCESS) {
LOG_ERROR("ParseCmdFromBuf Error ...");
free(cmdData);
break;
}
if (strncmp((char *)cmdData->funcId, "HLT_RpcProcessExit", strlen("HLT_RpcProcessExit")) == 0) {
// Indicates that the process needs to exit
sctpFd = atoi((char *)cmdData->paras[0]);
(void)sprintf_s((char *)exitCmdData.result, sizeof(exitCmdData.result), "%s|%s|%d",
cmdData->id, cmdData->funcId, sctpFd);
PushResultToChannelSendBuffer(channelInfo, exitCmdData.result);
free(cmdData);
break;
}
ThreadExcuteCmd(cmdData);
}
// Check whether feedback is required
ret = IsFeedbackResult(channelInfo);
if (ret != 0) {
break;
}
}
LOG_DEBUG("Process Return");
(void)IsFeedbackResult(channelInfo);
// Clearing Resources
FreeControlChannelRes();
FreeTlsResList();
FreeProcess();
if (sctpFd > 0) {
close(sctpFd);
}
return SUCCESS;
}
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/process/process.c | C | unknown | 7,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.
*/
#include <errno.h>
#include <limits.h>
#include <memory.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdbool.h>
#include <sys/mman.h>
#include "stub_replace.h"
#ifdef HITLS_BIG_ENDIAN
#include "crypt_utils.h"
#endif
/* The LSB of the function pointer indicates the thumb function. The LSB of the actual address needs to be cleared. */
#define REAL_ADDR(ptr) (void *)(((uintptr_t)(ptr)) & (~(uintptr_t)1))
/*
* Used to record the size of the system memory page.
*/
static long g_pageSize = -1;
/*
* Obtains the start address of the memory page where the specified function code is located.
* fn - Function Address (Function Pointer)
*/
static inline void *FuncPageGet(uintptr_t fn)
{
return (void *)(fn & (~(g_pageSize - 1)));
}
/*
* This file does not use the memcpy function of the system. In this way, the mempcy function of
* the system can be dynamically replaced by STUB_Replace.
*/
static int32_t StubCopy(void *dest, void *src, uint32_t size)
{
if ((src == NULL) || (dest == NULL)) {
return ERANGE;
}
uint8_t *localDst = (uint8_t *)(dest);
uint8_t *localSrc = (uint8_t *)(src);
for (uint32_t i = 0; i < size; i++) {
localDst[i] = localSrc[i];
}
return 0;
}
/*
* This file does not use the memset function of the system. In this way, the memset function of
* the system can be dynamically replaced by STUB_Replace.
*/
static void StubSet(void *dest, int val, uint32_t size)
{
if (dest == NULL) {
return;
}
uint8_t *localDst = (uint8_t *)(dest);
for (uint32_t i = 0; i < size; i++) {
localDst[i] = val;
}
}
#if defined(__arm__) || defined(__thumb__)
static int ReplaceT32(void *srcFn, const void *stubFn)
{
uint16_t instr1 = 0xF000;
uint16_t instr2;
uint32_t imm;
/*
* The difference between the jump instruction and srcFn is 4 bytes. The current address is obtained by
* subtracting 4 bytes from the PC.
*/
uint32_t addrDiff = REAL_ADDR(stubFn) - (REAL_ADDR(srcFn) + 4) - 4;
/*
* 32-bit test occurrence address: srcFn - stubFn, the scope is out of range,
* temporarily comment on the following scope judgment.
* if (abs((int32_t)addrDiff) >= 0x100000) { // Max jump range
* return -1;
* }
*/
if (((uintptr_t)stubFn) & 0x01) {
// Thumb instruction set BL corresponding machine code is [1 1 1 1 0 S imm10][1 1 J1 1 J2 imm11]
// Address offset calculation: I1: NOT(J1 EOR S); I2: NOT(J2 EOR S);
// imm32: SignExtend(S:I1:I2:imm10:imm11:'0', 32)
instr2 = 0xF800; // Corresponding bit of machine code J1 J2 take 1
if (stubFn < srcFn) {
instr1 = 0xF400; // The corresponding bit S of the machine code is 1.
}
imm = addrDiff >> 1; // The address is shifted right by one bit.
imm &= (1 << 21) - 1; // Lower 21 bits
instr1 |= (imm >> 11) & 0x3FF; // Move rightwards by 11 digits and take imm10.
instr2 |= (imm & 0x7FF);
} else {
// Thumb instruction set BLX corresponding machine code is [1 1 1 1 0 S imm10H][1 1 J1 0 J2 imm10L H]
// Address offset calculation: I1 = NOT(J1 EOR S); I2 = NOT(J2 EOR S)
// imm32 = SignExtend(S:I1:I2:imm10H:imm10L:'00', 32)
instr2 = 0xE800; // J1 and J2 corresponding to the machine code are set to 1.
if (stubFn < srcFn) {
instr1 = 0xF400; // The corresponding bit S of the machine code is 1.
}
imm = addrDiff >> 2; // Shift right by 2 bits
imm &= (1 << 20) - 1; // Take lower 20 bits
instr1 |= (imm >> 10) & 0x3FF; // Take 10 bits
instr2 |= (imm & 0x3FF) << 1; // Take lower 10 bits
}
uint8_t *text = (uint8_t*)REAL_ADDR(srcFn);
((uint16_t *)text)[0] = 0xb580;
((uint16_t *)text)[1] = 0xaf00;
((uint16_t *)text)[2] = instr1; // BL/BLX offset 2
((uint16_t *)text)[3] = instr2; // Offset 3
((uint16_t *)text)[4] = 0xaf00; // Offset 4
((uint16_t *)text)[5] = 0xbd80; // Offset 5
return 0;
}
static int ReplaceA32(void *srcFn, const void *stubFn)
{
uint32_t inst;
uint32_t addrDiff = REAL_ADDR(stubFn) - (srcFn + 4) - 8;
uint32_t imm24;
if (abs((int32_t)addrDiff) >= 0x1000000) { // Max jump range
return -1;
}
if (((uintptr_t)stubFn) & 0x01) {
// a32 instruction set BLX corresponding machine code is [1 1 1 1 1 0 1 H imm24]
// imm32 = SignExtend(imm24:H:'0', 32)
uint32_t h = (addrDiff & 0b10) >> 1; // bit[1] of the address difference
imm24 = (addrDiff >> 2); // Shift right by 2 bits
imm24 &= (1 << 24) - 1; // Take lower 24 bits
inst = 0xfa000000 | imm24 | (h << 24); // h is located in bit[24].
} else {
// a32 instruction set BL corresponding machine code is [(!= 1111) 1 0 1 1 imm24]
// imm32 = SignExtend(imm24:'00', 32)
imm24 = (addrDiff >> 2); // Shift right by 2 bits
imm24 &= (1 << 24) - 1; // Take lower 24 bits
inst = 0xeb000000 | imm24;
}
((uint32_t *)srcFn)[0] = 0xe92d4000;
((uint32_t *)srcFn)[1] = inst; // BL/BLX
((uint32_t *)srcFn)[2] = 0xe8bd8000; // Offset 2
return 0;
}
#endif
/*
* Replaces the specified function with the specified stub function.
* stubInfo - Record information about stub replacement, which is used for STUB_Reset restoration.
* srcFn - Functions in the source code
* stubFn - You need to replace the stub function that is inserted into the run.
* return - 0:Success, non-zero:Error code
*/
int STUB_Replace(FuncStubInfo *stubInfo, void *srcFn, const void *stubFn)
{
(void)stubFn;
#if defined(__arm__) || defined(__thumb__)
stubInfo->fn = REAL_ADDR(srcFn);
#else
stubInfo->fn = srcFn;
#endif
StubCopy(stubInfo->codeBuf, (char *)(stubInfo->fn), CODESIZE);
bool nextPage = false;
uintptr_t srcPoint = (uintptr_t)srcFn;
if ((g_pageSize - (srcPoint % g_pageSize)) < CODESIZE) {
nextPage = true;
}
/* To modify instruction content corresponding to the source function, add memory write permission first */
if (mprotect(FuncPageGet(srcPoint), g_pageSize, PROT_READ | PROT_WRITE | PROT_EXEC) < 0) {
perror("STUB_Replace: set error mprotect to w+r+x faild");
return -1;
}
if (nextPage) {
if (mprotect(FuncPageGet(srcPoint + CODESIZE), g_pageSize, PROT_READ | PROT_WRITE | PROT_EXEC) < 0) {
perror("STUB_Replace: set error mprotect to w+r+x faild");
return -1;
}
}
#if defined(__x86_64__)
/*
* Short jump mode: Change to jmp jump instruction, and set jump position (the offset of the current position).
* However, the offset cannot exceed 32 bits. There is a restriction on 64-bit systems.
* [*(unsigned char *)srcFn = (unsigned char)0xE9;] [*(unsigned int *)((unsigned char *)srcFn + 1) =
* (unsigned char *)stubFn - (unsigned char *)srcFn - CODESIZE;] Long jump mode:
* Directly use a 64-bit address to jump, the following method is used.
*/
unsigned char *tmpBuf = (unsigned char *)srcFn;
int idx = 0;
tmpBuf[idx++] = 0xFF; // 0xFF 0x25 Constructing a long jump instruction
tmpBuf[idx++] = 0x25; // 0xFF 0x25 Constructing a long jump instruction
tmpBuf[idx++] = 0x0;
tmpBuf[idx++] = 0x0;
tmpBuf[idx++] = 0x0;
tmpBuf[idx++] = 0x0;
tmpBuf[idx++] = (((uintptr_t)stubFn) & 0xff);
tmpBuf[idx++] = ((((uintptr_t)stubFn) >> 8) & 0xff); // Obtain the address by little-endian shift by 8 bits
tmpBuf[idx++] = ((((uintptr_t)stubFn) >> 16) & 0xff); // Obtain the address by little-endian shift by 16 bits
tmpBuf[idx++] = ((((uintptr_t)stubFn) >> 24) & 0xff); // Obtain the address by little-endian shift by 24 bits
tmpBuf[idx++] = ((((uintptr_t)stubFn) >> 32) & 0xff); // Obtain the address by little-endian shift by 32 bits
tmpBuf[idx++] = ((((uintptr_t)stubFn) >> 40) & 0xff); // Obtain the address by little-endian shift by 40 bits
tmpBuf[idx++] = ((((uintptr_t)stubFn) >> 48) & 0xff); // Obtain the address by little-endian shift by 48 bits
tmpBuf[idx++] = ((((uintptr_t)stubFn) >> 56) & 0xff); // Obtain the address by little-endian shift by 56 bits
#elif defined(__aarch64__) || defined(_M_ARM64)
/* ldr x9, PC+8
br x9
addr */
uint32_t ldrIns = 0x58000040 | 9; // 9 = 1001
uint32_t brIns = 0xd61f0120 | (9 << 5); // 9 << 5
#ifdef HITLS_BIG_ENDIAN
ldrIns = CRYPT_SWAP32(ldrIns);
brIns = CRYPT_SWAP32(brIns);
#endif
((uint32_t *)srcFn)[0] = ldrIns;
((uint32_t *)srcFn)[1] = brIns;
/* ldr x9, + 8 */
*(long long *)((char *)srcFn + 8) = (long long)stubFn;
#elif defined(__arm__) || defined(__thumb__)
if (((uintptr_t)srcFn) & 0x01) {
if (ReplaceT32(srcFn, stubFn) != 0) {
return -1;
}
} else {
if (ReplaceA32(srcFn, stubFn) != 0) {
return -1;
}
}
#elif defined(__i386__)
unsigned long tmpAdd = (unsigned long)stubFn - (unsigned long)(srcFn + 5);
unsigned char *tmpBuf = (unsigned char *)srcFn;
*(tmpBuf + 0) = 0xe9;
*(unsigned long *)(tmpBuf + 1) = tmpAdd;
#endif
/* Flush cached instructions into */
__builtin___clear_cache((char *)(stubInfo->fn), (char *)(stubInfo->fn) + CODESIZE);
/* The modification is complete. Remove the memory write permission. */
if (mprotect(FuncPageGet(srcPoint), g_pageSize, PROT_READ | PROT_EXEC) < 0) {
perror("STUB_Replace: set error mprotect to r+x failed");
return -1;
}
if (nextPage) {
if (mprotect(FuncPageGet(srcPoint + CODESIZE), g_pageSize, PROT_READ | PROT_EXEC) < 0) {
perror("STUB_Replace: set error mprotect to r+x failed");
return -1;
}
}
return 0;
}
/*
* Restore the source function and remove the instrumentation.
* stubInfo - Information logged when instrumentation
* return - 0:Success, non-zero:Error code
*/
int STUB_Reset(FuncStubInfo *stubInfo)
{
bool nextPage = false;
if (stubInfo->fn == NULL) {
return -1;
}
uintptr_t srcPoint = (uintptr_t)stubInfo->fn;
if ((g_pageSize - (srcPoint % g_pageSize)) < CODESIZE) {
nextPage = true;
}
/* To modify instruction content corresponding to the source function, add memory write permission first */
if (mprotect(FuncPageGet((uintptr_t)stubInfo->fn), g_pageSize, PROT_READ | PROT_WRITE | PROT_EXEC) < 0) {
perror("STUB_Reset: error mprotect to w+r+x faild");
return -1;
}
if (nextPage) {
if (mprotect(FuncPageGet(srcPoint + CODESIZE), g_pageSize, PROT_READ | PROT_WRITE | PROT_EXEC) < 0) {
perror("STUB_Replace: set error mprotect to w+r+x faild");
return -1;
}
}
/* Restore the recorded rewritten original function mov/push/mov a few instructions */
if (StubCopy(stubInfo->fn, stubInfo->codeBuf, CODESIZE) < 0) {
return -1;
}
/* Flush cached instructions into */
__builtin___clear_cache((char *)stubInfo->fn, (char *)stubInfo->fn + CODESIZE);
/* If recovered, disable the memory modification permission. */
if (mprotect(FuncPageGet((uintptr_t)stubInfo->fn), g_pageSize, PROT_READ | PROT_EXEC) < 0) {
perror("STUB_Reset: error mprotect to r+x failed");
return -1;
}
if (nextPage) {
if (mprotect(FuncPageGet(srcPoint + CODESIZE), g_pageSize, PROT_READ | PROT_EXEC) < 0) {
perror("STUB_Replace: set error mprotect to r+x failed");
return -1;
}
}
StubSet(stubInfo, 0, sizeof(FuncStubInfo));
return 0;
}
/*
* Initialize the dynamic stub change function and obtain the memory page size. Invoke the function once.
* return - 0:Success, non-zero:Error code
*/
int STUB_Init(void)
{
if (g_pageSize != -1) {
return 0;
}
g_pageSize = sysconf(_SC_PAGE_SIZE);
if (g_pageSize < 0) {
perror("STUB_Init: get system _SC_PAGE_SIZE configure failed");
return -1;
}
return 0;
}
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/stub/stub_replace.c | C | unknown | 12,791 |
/*
* 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.
*/
#ifndef STUB_REPALCE_H
#define STUB_REPALCE_H
#include <stdint.h>
#if defined(__x86_64__)
/*
* The first 14 bytes of the function entry are used to construct the jump instruction.
* Short jump instruction is 5 bytes, and Long jump instruction is 14 bytes.
*/
#define CODESIZE 14U
#elif defined(__aarch64__) || defined(_M_ARM64)
/* ARM64 needs 16 bytes to construct the jump instruction. */
#define CODESIZE 16U
#elif defined(__arm__)
/* ARM32 needs 12 bytes to construct the jump instruction. */
#define CODESIZE 12U
#endif
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
void *fn;
unsigned char codeBuf[CODESIZE];
} FuncStubInfo;
/*
* Initialize the dynamic stub change function. Invoke the function once.
* return - 0:Success, non-zero:Error code
*/
int STUB_Init(void);
/*
* Replaces the specified function with the specified stub function.
* stubInfo - Record information about stub replacement, which is used for STUB_Reset restoration.
* srcFn - Functions in the source code
* stubFn - Need to replace the stub function that is inserted into the run.
* return - 0:Success, non-zero:Error code
*/
int STUB_Replace(FuncStubInfo *stubInfo, void *srcFn, const void *stubFn);
/*
* Restore the source function and remove the instrumentation.
* stubInfo - Information logged when instrumentation
* return - 0:Success, non-zero:Error code
*/
int STUB_Reset(FuncStubInfo *stubInfo);
#ifdef __cplusplus
}
#endif
#endif // STUB_REPALCE_H | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/stub/stub_replace.h | C | unknown | 2,018 |
# 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.
SET(DT_LIBNAME "tls_frame")
SET(HLT_LIBNAME "tls_hlt")
SET(WRAPPER_LIBNAME "rec_wrapper")
add_library(TLS_TEST_INTF INTERFACE)
if(TLS_DEBUG)
add_compile_definitions(TLS_TEST_INTF INTERFACE TLS_DEBUG)
endif()
target_include_directories(TLS_TEST_INTF INTERFACE
${openHiTLS_SRC}/platform/Secure_C/include
${openHiTLS_SRC}/include
${openHiTLS_SRC}/include/tls
${openHiTLS_SRC}/include/bsl
${openHiTLS_SRC}/include/crypto
${openHiTLS_SRC}/include/pki
${openHiTLS_SRC}/config/macro_config
${openHiTLS_SRC}/bsl/list/include
${openHiTLS_SRC}/bsl/obj/include
${openHiTLS_SRC}/bsl/include
${openHiTLS_SRC}/bsl/sal/include
${openHiTLS_SRC}/bsl/log/include
${openHiTLS_SRC}/bsl/time/include
${openHiTLS_SRC}/bsl/async/include
${openHiTLS_SRC}/bsl/hash/include
${openHiTLS_SRC}/bsl/uio/include
${openHiTLS_SRC}/bsl/uio/src
${openHiTLS_SRC}/pki/x509_cert/include
${openHiTLS_SRC}/tls/cert/hitls_x509_adapt
${openHiTLS_SRC}/tls/include
${openHiTLS_SRC}/tls/cert/cert_self
${openHiTLS_SRC}/tls/cert/include
${openHiTLS_SRC}/tls/config/include
${openHiTLS_SRC}/tls/cm/include
${openHiTLS_SRC}/tls/record/include
${openHiTLS_SRC}/tls/record/src
${openHiTLS_SRC}/tls/handshake/cookie/include
${openHiTLS_SRC}/tls/handshake/common/include
${openHiTLS_SRC}/tls/crypt/include/
${openHiTLS_SRC}/tls/handshake/parse/include
${openHiTLS_SRC}/tls/handshake/pack/src
${openHiTLS_SRC}/tls/handshake/pack/include
${openHiTLS_SRC}/tls/ccs/include
${openHiTLS_SRC}/tls/alert/include
${openHiTLS_SRC}/tls/crypt/crypt_self
${openHiTLS_SRC}/testcode/framework/stub
${openHiTLS_SRC}/testcode/framework/tls/include
${openHiTLS_SRC}/testcode/framework/tls/io/include
${openHiTLS_SRC}/testcode/framework/tls/cert/include
${openHiTLS_SRC}/testcode/framework/tls/crypt/include
${openHiTLS_SRC}/testcode/framework/tls/msg/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/transfer/include
${openHiTLS_SRC}/testcode/framework/tls/frame/src
${openHiTLS_SRC}/testcode/framework/tls/io/src
${openHiTLS_SRC}/testcode/framework/tls/func_wrapper/include
${openHiTLS_SRC}/testcode/framework/tls/callback/include
${openHiTLS_SRC}/tls/feature/custom_extensions/include
)
aux_source_directory(${openHiTLS_SRC}/testcode/framework/tls/crypt/src CRYPT_SRC)
aux_source_directory(${openHiTLS_SRC}/testcode/framework/tls/io/src IO_SRC)
aux_source_directory(${openHiTLS_SRC}/testcode/framework/tls/frame/src FRAME_SRC)
aux_source_directory(${openHiTLS_SRC}/testcode/framework/tls/msg/src MSG_SRC)
aux_source_directory(${openHiTLS_SRC}/testcode/framework/tls/base/src BASE_SRC)
aux_source_directory(${openHiTLS_SRC}/testcode/framework/tls/resource/src RESOURCE_SRC)
aux_source_directory(${openHiTLS_SRC}/testcode/framework/tls/process/src PROCESS_SRC)
aux_source_directory(${openHiTLS_SRC}/testcode/framework/tls/rpc/src RPC_SRC)
aux_source_directory(${openHiTLS_SRC}/testcode/framework/tls/transfer/src TRANSFER_SRC)
aux_source_directory(${openHiTLS_SRC}/testcode/framework/tls/callback/src CALLBACK_SRC)
aux_source_directory(${openHiTLS_SRC}/testcode/framework/tls/func_wrapper/src WRAPPER_SRC)
SET(WRAPPER_SRC ${WRAPPER_SRC} ${openHiTLS_SRC}/testcode/framework/stub/stub_replace.c)
target_compile_options(TLS_TEST_INTF INTERFACE -g)
add_library(${HLT_LIBNAME}
STATIC
${BASE_SRC} ${RESOURCE_SRC} ${CALLBACK_SRC} ${PROCESS_SRC} ${RPC_SRC} ${TRANSFER_SRC})
target_link_libraries(${HLT_LIBNAME} PRIVATE TLS_TEST_INTF)
add_library(${DT_LIBNAME}
STATIC
${BASE_SRC} ${CALLBACK_SRC} ${CRYPT_SRC} ${IO_SRC} ${FRAME_SRC} ${MSG_SRC})
target_link_libraries(${DT_LIBNAME} PRIVATE TLS_TEST_INTF)
add_library(${WRAPPER_LIBNAME}
STATIC
${WRAPPER_SRC})
target_link_libraries(${WRAPPER_LIBNAME} PRIVATE TLS_TEST_INTF)
set_target_properties(${HLT_LIBNAME} ${DT_LIBNAME} ${WRAPPER_LIBNAME}
PROPERTIES
ARCHIVE_OUTPUT_DIRECTORY "${openHiTLS_SRC}/testcode/output/lib"
)
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/CMakeLists.txt | CMake | unknown | 4,778 |
/*
* 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.
*/
#ifndef __LOCK_H__
#define __LOCK_H__
#include <pthread.h>
typedef pthread_mutex_t Lock;
/**
* @brief Create a lock resource
*/
Lock *OsLockNew(void);
/**
* @brief Lock
*/
int OsLock(Lock *lock);
/**
* @brief Unlock
*/
int OsUnLock(Lock *lock);
/**
* @brief Release the lock resource
*/
void OsLockDestroy(Lock *lock);
#endif // __LOCK_H__ | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/base/include/lock.h | C | unknown | 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.
*/
#ifndef __LOGGER_H__
#define __LOGGER_H__
#include <stdio.h>
#include <stdint.h>
#include "securec.h"
#ifdef __cplusplus
extern "C" {
#endif
#define LOG_MAX_SIZE 1024
typedef enum {
ENUM_LOG_LEVEL_TRACE, /* Basic level */
ENUM_LOG_LEVEL_DEBUG, /* Debugging level */
ENUM_LOG_LEVEL_WARNING, /* Warning level */
ENUM_LOG_LEVEL_ERROR, /* Error level */
ENUM_LOG_LEVEL_FATAL /* Fatal level */
} LogLevel;
/**
* @ingroup log
* @brief Record error information based on the log level
*
* @par
* Record error information based on the log level
*
* @attention
*
* @param[in] level Log level
* @param[in] file File where the error information is stored
* @param[in] line Number of the line where the error information is stored
* @param[in] fmt Format character string for printing
*
* @retval 0 Success
* @retval others failure
*/
int LogWrite(LogLevel level, const char *file, int line, const char *fmt, ...);
#define LOG_DEBUG(...) LogWrite(ENUM_LOG_LEVEL_DEBUG, __FILE__, __LINE__, __VA_ARGS__)
#define LOG_ERROR(...) LogWrite(ENUM_LOG_LEVEL_ERROR, __FILE__, __LINE__, __VA_ARGS__)
#ifdef __cplusplus
}
#endif // __cplusplus
#endif // __LOGGER_H__
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/base/include/logger.h | C | unknown | 1,738 |
/*
* 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 <stdint.h>
#include "securec.h"
#include "logger.h"
#include "lock.h"
Lock *OsLockNew(void)
{
pthread_mutexattr_t attr;
Lock *lock;
if ((lock = (Lock *)malloc(sizeof(pthread_mutex_t))) == NULL) {
LOG_ERROR("OAL_Malloc error");
return NULL;
}
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
if (pthread_mutex_init(lock, &attr) != 0) {
LOG_ERROR("pthread_mutex_init error");
pthread_mutexattr_destroy(&attr);
free(lock);
return NULL;
}
pthread_mutexattr_destroy(&attr);
return lock;
}
int OsLock(Lock *lock)
{
if (pthread_mutex_lock(lock) != 0) {
LOG_ERROR("pthread_mutex_lock error");
return -1;
}
return 0;
}
int OsUnLock(Lock *lock)
{
if (pthread_mutex_unlock(lock) != 0) {
LOG_ERROR("pthread_mutex_unlock error");
return -1;
}
return 0;
}
void OsLockDestroy(Lock *lock)
{
if (lock == NULL) {
return;
}
pthread_mutex_destroy(lock);
free(lock);
}
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/base/src/lock.c | C | unknown | 1,635 |
/*
* 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 <unistd.h>
#include "logger.h"
LogLevel GetLogLevel(void)
{
#ifdef TLS_DEBUG
return ENUM_LOG_LEVEL_TRACE;
#else
return ENUM_LOG_LEVEL_FATAL;
#endif
}
static const char *ConvertLevel2Str(LogLevel level)
{
switch (level) {
case ENUM_LOG_LEVEL_TRACE:
return "TRACE";
case ENUM_LOG_LEVEL_DEBUG:
return "DEBUG";
case ENUM_LOG_LEVEL_WARNING:
return "WARNING";
case ENUM_LOG_LEVEL_ERROR:
return "ERROR";
case ENUM_LOG_LEVEL_FATAL:
return "FATAL";
default:
return "UNKNOWN";
}
}
int LogWrite(LogLevel level, const char *file, int line, const char *fmt, ...)
{
int len, ilen;
LogLevel curLevel;
va_list vargs;
int tmpLevel = level;
char logBuf[LOG_MAX_SIZE] = {0};
if ((tmpLevel < ENUM_LOG_LEVEL_TRACE) || (tmpLevel > ENUM_LOG_LEVEL_FATAL)) {
return 0;
}
// Print logs whose levels are higher than or equal to the current level.
curLevel = GetLogLevel();
if (level < curLevel) {
return 0;
}
// Process the log header
if (file == NULL || line == 0) {
len = snprintf_s(logBuf, LOG_MAX_SIZE, (size_t)(LOG_MAX_SIZE - 1), "[%d_TEST_%s]",
getpid(), ConvertLevel2Str((LogLevel)tmpLevel));
} else {
len = snprintf_s(logBuf, LOG_MAX_SIZE, (size_t)(LOG_MAX_SIZE - 1), "[%d_TEST_%s][%s:%d]",
getpid(), ConvertLevel2Str((LogLevel)tmpLevel), file, line);
}
if (len < 0 || len > LOG_MAX_SIZE - 1) {
return 0;
}
va_start(vargs, fmt);
ilen = vsnprintf_s(logBuf + len, (size_t)(LOG_MAX_SIZE - len), (size_t)(LOG_MAX_SIZE - len - 1), fmt, vargs);
if (ilen < 0 || ilen > LOG_MAX_SIZE - len - 1) {
// In the case of overflow truncation, the maximum value is used
len = LOG_MAX_SIZE;
logBuf[len - 1] = '\0';
goto EXIT;
}
len += ilen;
logBuf[len] = '\n';
logBuf[len + 1] = '\0';
EXIT:
va_end(vargs);
#ifdef TLS_DEBUG
printf("%s", logBuf);
#endif
return 0;
}
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/base/src/logger.c | C | unknown | 2,629 |
/*
* 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.
*/
#ifndef CERT_CALLBACK_H
#define CERT_CALLBACK_H
#include "hlt_type.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Certificate callback
*/
int32_t RegCertCallback(CertCallbackType type);
/**
* @brief Memory callback
*/
int32_t RegMemCallback(MemCallbackType type);
/**
* @brief Loading Certificates and Private Keys by hitls x509
*/
int32_t HiTLS_X509_LoadCertAndKey(HITLS_Config *tlsCfg, const char *caFile, const char *chainFile,
const char *eeFile, const char *signFile, const char *privateKeyFile, const char *signPrivateKeyFile);
void BinLogFixLenFunc(uint32_t logId, uint32_t logLevel, uint32_t 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 RegDefaultMemCallback(void);
#ifdef __cplusplus
}
#endif
#endif // CERT_CALLBACK_H | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/callback/include/cert_callback.h | C | unknown | 1,443 |
/*
* 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 <unistd.h>
#include <stdbool.h>
#include <stdio.h>
#include "hitls_build.h"
#include "crypt_eal_pkey.h"
#include "hlt_type.h"
#include "hitls_cert_type.h"
#include "hitls_cert.h"
#include "hitls_type.h"
#include "hitls_cert_reg.h"
#include "hitls_config.h"
#include "hitls_cert.h"
#include "hitls_cert_init.h"
#include "bsl_sal.h"
#include "bsl_log.h"
#include "bsl_err.h"
#include "logger.h"
#include "tls_config.h"
#include "tls.h"
#include "bsl_list.h"
#include "hitls_x509_adapt.h"
#include "hitls_cert_init.h"
#include "hitls_pki_x509.h"
#include "cert_method.h"
#define SUCCESS 0
#define ERROR (-1)
#define SINGLE_CERT_LEN (512)
#define CERT_FILE_LEN (4 * 1024)
int32_t RegCertCallback(CertCallbackType type)
{
switch (type) {
case CERT_CALLBACK_DEFAULT:
#ifndef HITLS_TLS_FEATURE_PROVIDER
HITLS_CertMethodInit();
#endif
break;
default:
return ERROR;
}
return SUCCESS;
}
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");
return;
}
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");
return;
}
void RegDefaultMemCallback(void)
{
BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_MALLOC, malloc);
BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_FREE, free);
BSL_ERR_Init();
BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_DEBUG);
#ifdef TLS_DEBUG
BSL_LOG_BinLogFuncs logFunc = { BinLogFixLenFunc, BinLogVarLenFunc };
BSL_LOG_RegBinLogFunc(&logFunc);
#endif
LOG_DEBUG("HiTLS RegDefaultMemCallback");
return;
}
int32_t RegMemCallback(MemCallbackType type)
{
switch (type) {
case MEM_CALLBACK_DEFAULT : RegDefaultMemCallback(); break;
default:
return ERROR;
}
return SUCCESS;
}
HITLS_CERT_X509 *HiTLS_X509_LoadCertFile(HITLS_Config *tlsCfg, const char *file)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
HITLS_Lib_Ctx *libCtx = LIBCTX_FROM_CONFIG(tlsCfg);
const char *attrName = ATTRIBUTE_FROM_CONFIG(tlsCfg);
return HITLS_CERT_ProviderCertParse(libCtx, attrName, (const uint8_t *)file, strlen(file) + 1,
TLS_PARSE_TYPE_FILE, "ASN1");
#else
return HITLS_X509_Adapt_CertParse(tlsCfg, (const uint8_t *)file, strlen(file) + 1, TLS_PARSE_TYPE_FILE,
TLS_PARSE_FORMAT_ASN1);
#endif
}
void *HiTLS_X509_LoadCertListToStore(HITLS_Config *tlsCfg, const char *fileList)
{
int32_t ret;
char certList[MAX_CERT_LEN] = {0};
char certPath[SINGLE_CERT_LEN] = {0};
ret = memcpy_s(certList, MAX_CERT_LEN, fileList, strlen(fileList));
if (ret != EOK) {
LOG_ERROR("memcpy_s Error");
return NULL;
}
void *store = SAL_CERT_StoreNew(tlsCfg->certMgrCtx);
if(store == NULL){
LOG_ERROR("SAL_CERT_StoreNew Error");
return NULL;
}
char *rest = NULL;
char *token = strtok_s(certList, ":", &rest);
do {
(void)memset_s(certPath, SINGLE_CERT_LEN, 0, SINGLE_CERT_LEN);
ret = sprintf_s(certPath, SINGLE_CERT_LEN, "%s%s", DEFAULT_CERT_PATH, token);
if (ret <= 0) {
LOG_ERROR("sprintf_s Error");
HITLS_X509_StoreCtxFree(store);
return NULL;
}
LOG_DEBUG("Load Cert Path is %s", certPath);
HITLS_CERT_X509 *cert = HiTLS_X509_LoadCertFile(tlsCfg, certPath);
if (cert == NULL) {
HITLS_X509_StoreCtxFree(store);
return NULL;
}
ret = HITLS_X509_Adapt_StoreCtrl(tlsCfg, store, CERT_STORE_CTRL_ADD_CERT_LIST, cert, NULL);
if (ret != SUCCESS) {
LOG_ERROR("X509_STORE_add_cert Error: path = %s.", certPath);
HITLS_X509_StoreCtxFree(store);
return NULL;
}
token = strtok_s(NULL, ":", &rest);
} while (token != NULL);
return store;
}
int32_t HITLS_X509_LoadEECertList(HITLS_Config *tlsCfg, const char *eeFileList, bool isEnc)
{
int32_t ret;
HITLS_CERT_X509 *cert = NULL;
char certList[MAX_CERT_LEN] = {0};
char certPath[SINGLE_CERT_LEN] = {0};
ret = memcpy_s(certList, MAX_CERT_LEN, eeFileList, strlen(eeFileList));
if (ret != EOK) {
LOG_ERROR("memcpy_s Error");
return ERROR;
}
char *rest = NULL;
char *token = strtok_s(certList, ":", &rest);
do {
(void)memset_s(certPath, SINGLE_CERT_LEN, 0, SINGLE_CERT_LEN);
ret = sprintf_s(certPath, SINGLE_CERT_LEN, "%s%s", DEFAULT_CERT_PATH, token);
if (ret <= 0) {
LOG_ERROR("sprintf_s Error");
return ERROR;
}
LOG_DEBUG("Load Cert Path is %s", certPath);
cert = HiTLS_X509_LoadCertFile(tlsCfg, certPath);
if (cert == NULL) {
LOG_ERROR("LoadCert Error: path = %s", certPath);
return ERROR;
}
if (isEnc == true) {
ret = HITLS_CFG_SetTlcpCertificate(tlsCfg, cert, 0, isEnc);
} else {
ret = HITLS_CFG_SetCertificate(tlsCfg, cert, 0);
}
if (ret != SUCCESS) {
LOG_ERROR("HITLS_CFG_SetCertificate Error: path = %s.", certPath);
HITLS_X509_Adapt_CertFree(cert);
return ERROR;
}
token = strtok_s(NULL, ":", &rest);
} while (token != NULL);
return SUCCESS;
}
int32_t HITLS_X509_LoadPrivateKeyList(HITLS_Config *tlsCfg, const char *keyFileList, bool isEnc)
{
int32_t ret;
HITLS_CERT_Key *key = NULL;
char fileList[MAX_CERT_LEN] = {0};
char filePath[SINGLE_CERT_LEN] = {0};
ret = memcpy_s(fileList, MAX_CERT_LEN, keyFileList, strlen(keyFileList));
if (ret != EOK) {
LOG_ERROR("memcpy_s Error");
return ERROR;
}
char *rest = NULL;
char *token = strtok_s(fileList, ":", &rest);
do {
(void)memset_s(filePath, SINGLE_CERT_LEN, 0, SINGLE_CERT_LEN);
ret = sprintf_s(filePath, SINGLE_CERT_LEN, "%s%s", DEFAULT_CERT_PATH, token);
if (ret <= 0) {
LOG_ERROR("sprintf_s Error");
return ERROR;
}
LOG_DEBUG("Load Cert Path is %s", filePath);
#ifdef HITLS_TLS_FEATURE_PROVIDER
key = HITLS_X509_Adapt_ProviderKeyParse(tlsCfg, (const uint8_t *)filePath, strlen(filePath),
TLS_PARSE_TYPE_FILE, "ASN1", NULL);
#else
key = HITLS_X509_Adapt_KeyParse(tlsCfg, (const uint8_t *)filePath, strlen(filePath),
TLS_PARSE_TYPE_FILE, TLS_PARSE_FORMAT_ASN1);
#endif
if (key == NULL) {
LOG_ERROR("LoadCert Error: path = %s.", filePath);
return ERROR;
}
if (isEnc == true) {
ret = HITLS_CFG_SetTlcpPrivateKey(tlsCfg, key, 0, isEnc);
} else {
ret = HITLS_CFG_SetPrivateKey(tlsCfg, key, 0);
}
if (ret != SUCCESS) {
LOG_ERROR("HITLS_CFG_SetPrivateKey Error: path = %s.", filePath);
CRYPT_EAL_PkeyFreeCtx(key);
return ERROR;
}
token = strtok_s(NULL, ":", &rest);
} while (token != NULL);
return SUCCESS;
}
void FRAME_HITLS_X509_FreeCert(HITLS_CERT_Store *caStore, HITLS_CERT_Store *chainStore)
{
if (caStore != NULL) {
HITLS_X509_StoreCtxFree(caStore);
}
if (chainStore != NULL) {
HITLS_X509_StoreCtxFree(chainStore);
}
return;
}
int32_t HiTLS_X509_LoadCertAndKey(HITLS_Config *tlsCfg, const char *caFile, const char *chainFile,
const char *eeFile, const char *signFile, const char *privateKeyFile, const char *signPrivateKeyFile)
{
int32_t ret;
if ((caFile != NULL) && (strncmp(caFile, "NULL", strlen(caFile)) != 0)) {
HITLS_CERT_Store *caStore = HiTLS_X509_LoadCertListToStore(tlsCfg, caFile);
if (caStore == NULL) {
return ERROR;
}
ret = HITLS_CFG_SetCertStore(tlsCfg, caStore, 0);
if (ret != SUCCESS) {
HITLS_X509_StoreCtxFree(caStore);
return ret;
}
}
if ((chainFile != NULL) && (strncmp(chainFile, "NULL", strlen(chainFile)) != 0)) {
HITLS_CERT_Store *chainStore = HiTLS_X509_LoadCertListToStore(tlsCfg, chainFile);
if (chainStore == NULL) {
return ERROR;
}
ret = HITLS_CFG_SetChainStore(tlsCfg, chainStore, 0);
if (ret != SUCCESS) {
HITLS_X509_StoreCtxFree(chainStore);
return ret;
}
}
bool hasTlcpSignCert = ((signFile != NULL) && (strncmp(signFile, "NULL", strlen(signFile)) != 0));
if (hasTlcpSignCert) {
ret = HITLS_X509_LoadEECertList(tlsCfg, signFile, false);
if (ret != SUCCESS) {
return ret;
}
}
if ((eeFile != NULL) && (strncmp(eeFile, "NULL", strlen(eeFile)) != 0)) {
ret = HITLS_X509_LoadEECertList(tlsCfg, eeFile, hasTlcpSignCert);
if (ret != SUCCESS) {
return ret;
}
}
if ((signPrivateKeyFile != NULL) && (strncmp(signPrivateKeyFile, "NULL", strlen(signPrivateKeyFile)) != 0)) {
ret = HITLS_X509_LoadPrivateKeyList(tlsCfg, signPrivateKeyFile, false);
if (ret != SUCCESS) {
return ret;
}
if ((privateKeyFile != NULL) && (strncmp(privateKeyFile, "NULL", strlen(eeFile)) != 0)) {
ret = HITLS_X509_LoadPrivateKeyList(tlsCfg, privateKeyFile, true);
if (ret != SUCCESS) {
return ret;
}
}
} else {
if ((privateKeyFile != NULL) && (strncmp(privateKeyFile, "NULL", strlen(eeFile)) != 0)) {
ret = HITLS_X509_LoadPrivateKeyList(tlsCfg, privateKeyFile, false);
if (ret != SUCCESS) {
return ret;
}
}
}
return SUCCESS;
} | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/callback/src/cert_callback.c | C | unknown | 10,467 |
/*
* 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.
*/
#ifndef STUB_CRYPT_H
#define STUB_CRYPT_H
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Stub the test framework
*/
void FRAME_RegCryptMethod(void);
void FRAME_DeRegCryptMethod(void);
#ifdef __cplusplus
}
#endif
#endif // STUB_CRYPT_H
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/crypt/include/stub_crypt.h | C | unknown | 788 |
/*
* 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 "hitls_build.h"
#include "securec.h"
#include "bsl_sal.h"
#include "hitls_crypt_reg.h"
#include "hitls_error.h"
#include "hs_common.h"
#include "config_type.h"
#include "stub_replace.h"
#include "crypt_default.h"
#ifdef HITLS_TLS_FEATURE_PROVIDER
#include "hitls_crypt.h"
#include "crypt_eal_rand.h"
#endif
#define MD5_DIGEST_LENGTH 16
#define SHA1_DIGEST_LENGTH 20
#define SHA256_DIGEST_LENGTH 32
#define SHA384_DIGEST_LENGTH 48
#define SHA512_DIGEST_LENGTH 64
#define SM3_DIGEST_LENGTH 32
#define AEAD_TAG_LENGTH 16
typedef struct {
HITLS_HashAlgo algo;
uint8_t *key;
uint32_t keyLen;
} FRAME_HmacCtx;
typedef struct {
HITLS_HashAlgo algo;
} FRAME_HashCtx;
typedef struct {
uint8_t *pubKey;
uint32_t pubKeyLen;
uint8_t *privateKey;
uint32_t privateKeyLen;
} FRAME_EcdhKey;
typedef struct {
uint8_t *p;
uint8_t *g;
uint16_t plen;
uint16_t glen;
uint8_t *pubKey;
uint32_t pubKeyLen;
uint8_t *privateKey;
uint32_t privateKeyLen;
} FRAME_DhKey;
/**
* @ingroup hitls_crypt_reg
* @brief Obtain the random number
*
* @param buf [OUT] random number
* @param len [IN] random number length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_RandBytesCallback(uint8_t *buf, uint32_t len)
{
if (memset_s(buf, len, 1, len) != EOK) {
return HITLS_MEMCPY_FAIL;
}
return HITLS_SUCCESS;
}
int32_t STUB_CRYPT_RandBytesCallbackLibCtx(void *libCtx, uint8_t *buf, uint32_t len)
{
(void)libCtx;
if (memset_s(buf, len, 1, len) != EOK) {
return HITLS_MEMCPY_FAIL;
}
return HITLS_SUCCESS;
}
/**
* @ingroup hitls_crypt_reg
* @brief Generate a key pair based on the elliptic curve parameters
*
* @param curveParams [IN] Elliptic curve parameters
*
* @return Key handle
*/
HITLS_CRYPT_Key *STUB_CRYPT_GenerateEcdhKeyPairCallback(const HITLS_ECParameters *curveParams)
{
uint32_t keyLen = 0u;
if (curveParams == NULL) {
return NULL;
}
FRAME_EcdhKey *ecdhKey = (FRAME_EcdhKey *)BSL_SAL_Calloc(1u, sizeof(FRAME_EcdhKey));
if (ecdhKey == NULL) {
return NULL;
}
const TLS_GroupInfo *groupInfo = NULL;
switch (curveParams->type) {
case HITLS_EC_CURVE_TYPE_NAMED_CURVE:
groupInfo = ConfigGetGroupInfo(NULL, curveParams->param.namedcurve);
if (groupInfo == NULL) {
BSL_SAL_FREE(ecdhKey);
return NULL;
}
keyLen = groupInfo->pubkeyLen;
break;
default:
break;
}
uint8_t *pubKey = (uint8_t *)BSL_SAL_Malloc(keyLen);
if (pubKey == NULL) {
BSL_SAL_FREE(ecdhKey);
return NULL;
}
memset_s(pubKey, keyLen, 1u, keyLen);
uint8_t *privateKey = (uint8_t *)BSL_SAL_Malloc(keyLen);
if (privateKey == NULL) {
BSL_SAL_FREE(pubKey);
BSL_SAL_FREE(ecdhKey);
return NULL;
}
memset_s(privateKey, keyLen, 2u, keyLen);
ecdhKey->pubKey = pubKey;
ecdhKey->pubKeyLen = keyLen;
ecdhKey->privateKey = privateKey;
ecdhKey->privateKeyLen = keyLen;
return ecdhKey;
}
HITLS_CRYPT_Key *STUB_CRYPT_GenerateEcdhKeyPairCallbackLibCtx(void *libCtx,
const char *attrName, const HITLS_Config *config, const HITLS_ECParameters *curveParams)
{
(void)libCtx;
(void)attrName;
(void)config;
return STUB_CRYPT_GenerateEcdhKeyPairCallback(curveParams);
}
/**
* @ingroup hitls_crypt_reg
* @brief Release the key
*
* @param key [IN] Key handle
*/
void STUB_CRYPT_FreeEcdhKeyCallback(HITLS_CRYPT_Key *key)
{
FRAME_EcdhKey *ecdhKey = (FRAME_EcdhKey *)key;
if (ecdhKey != NULL) {
BSL_SAL_FREE(ecdhKey->pubKey);
BSL_SAL_FREE(ecdhKey->privateKey);
BSL_SAL_FREE(ecdhKey);
}
return;
}
/**
* @ingroup hitls_crypt_reg
* @brief Extract the public key data
*
* @param key [IN] Key handle
* @param pubKeyBuf [OUT] Public key data
* @param bufLen [IN] buffer length
* @param pubKeyLen [OUT] Public key data length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_GetEcdhEncodedPubKeyCallback(HITLS_CRYPT_Key *key, uint8_t *pubKeyBuf, uint32_t bufLen,
uint32_t *pubKeyLen)
{
FRAME_EcdhKey *ecdhKey = (FRAME_EcdhKey *)key;
if ((ecdhKey == NULL) ||
(pubKeyBuf == NULL) ||
(pubKeyLen == NULL) ||
(bufLen < ecdhKey->pubKeyLen)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (memcpy_s(pubKeyBuf, bufLen, ecdhKey->pubKey, ecdhKey->pubKeyLen) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*pubKeyLen = ecdhKey->pubKeyLen;
return HITLS_SUCCESS;
}
/**
* @ingroup hitls_crypt_reg
* @brief Calculate the shared key based on the local key and peer public key
*
* @param key [IN] Key handle
* @param pubKeyBuf [IN] Public key data
* @param pubKeyLen [IN] Public key data length
* @param sharedSecret [OUT] Shared key
* @param sharedSecretLen [IN/OUT] IN: Maximum length of the key padding OUT: Key length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_CalcEcdhSharedSecretCallback(HITLS_CRYPT_Key *key, uint8_t *peerPubkey, uint32_t pubKeyLen,
uint8_t *sharedSecret, uint32_t *sharedSecretLen)
{
FRAME_EcdhKey *ecdhKey = (FRAME_EcdhKey *)key;
if ((ecdhKey == NULL) ||
(peerPubkey == NULL) ||
(sharedSecret == NULL) ||
(sharedSecretLen == NULL) ||
(ecdhKey->privateKeyLen > pubKeyLen) ||
(*sharedSecretLen < pubKeyLen)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (memset_s(sharedSecret, *sharedSecretLen, 3u, pubKeyLen) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*sharedSecretLen = pubKeyLen;
return HITLS_SUCCESS;
}
int32_t STUB_CRYPT_CalcEcdhSharedSecretCallbackLibCtx(void *libCtx, const char *attrName,
HITLS_CRYPT_Key *key, uint8_t *peerPubkey,
uint32_t pubKeyLen, uint8_t *sharedSecret, uint32_t *sharedSecretLen)
{
(void)libCtx;
(void)attrName;
return STUB_CRYPT_CalcEcdhSharedSecretCallback(key, peerPubkey, pubKeyLen, sharedSecret, sharedSecretLen);
}
void STUB_CRYPT_FreeDhKeyCallback(HITLS_CRYPT_Key *key)
{
FRAME_DhKey *dhKey = (FRAME_DhKey *)key;
if (dhKey != NULL) {
BSL_SAL_FREE(dhKey->p);
BSL_SAL_FREE(dhKey->g);
BSL_SAL_FREE(dhKey->privateKey);
BSL_SAL_FREE(dhKey->pubKey);
BSL_SAL_FREE(dhKey);
}
return;
}
HITLS_CRYPT_Key *STUB_CRYPT_GenerateDhKeyBySecbitsCallback(int32_t secbits)
{
uint16_t plen;
if (secbits >= 192) {
plen = 1024;
} else if (secbits >= 152) {
plen = 512;
} else if (secbits >= 128) {
plen = 384;
} else if (secbits >= 112) {
plen = 256;
} else {
plen = 128;
}
FRAME_DhKey *dhKey = (FRAME_DhKey *)BSL_SAL_Calloc(1u, sizeof(FRAME_DhKey));
if (dhKey == NULL) {
return NULL;
}
dhKey->p = BSL_SAL_Calloc(1u, plen);
if (dhKey->p == NULL) {
BSL_SAL_FREE(dhKey);
return NULL;
}
memset_s(dhKey->p, plen, 1u, plen);
dhKey->plen = plen;
dhKey->g = BSL_SAL_Calloc(1u, plen);
if (dhKey->g == NULL) {
STUB_CRYPT_FreeDhKeyCallback(dhKey);
return NULL;
}
memset_s(dhKey->g, plen, 2u, plen);
dhKey->glen = plen;
dhKey->pubKey = BSL_SAL_Calloc(1u, plen);
if (dhKey->pubKey == NULL) {
STUB_CRYPT_FreeDhKeyCallback(dhKey);
return NULL;
}
memset_s(dhKey->pubKey, plen, 3u, plen);
dhKey->pubKeyLen = plen;
dhKey->privateKey = BSL_SAL_Calloc(1u, plen);
if (dhKey->privateKey == NULL) {
STUB_CRYPT_FreeDhKeyCallback(dhKey);
return NULL;
}
memset_s(dhKey->privateKey, plen, 4u, plen);
dhKey->privateKeyLen = plen;
return dhKey;
}
HITLS_CRYPT_Key *STUB_CRYPT_GenerateDhKeyBySecbitsCallbackLibCtx(void *libCtx, const char *attrName, int32_t secbits)
{
(void)libCtx;
(void)attrName;
return STUB_CRYPT_GenerateDhKeyBySecbitsCallback(secbits);
}
HITLS_CRYPT_Key *STUB_CRYPT_GenerateDhKeyByParamsCallback(uint8_t *p, uint16_t plen, uint8_t *g, uint16_t glen)
{
if ((p == NULL) || (plen == 0) || (g == NULL) || (glen == 0)) {
return NULL;
}
FRAME_DhKey *dhKey = (FRAME_DhKey *)BSL_SAL_Calloc(1u, sizeof(FRAME_DhKey));
if (dhKey == NULL) {
return NULL;
}
dhKey->p = BSL_SAL_Dump(p, plen);
if (dhKey->p == NULL) {
BSL_SAL_FREE(dhKey);
return NULL;
}
dhKey->plen = plen;
dhKey->g = BSL_SAL_Dump(g, glen);
if (dhKey->g == NULL) {
STUB_CRYPT_FreeDhKeyCallback(dhKey);
return NULL;
}
dhKey->glen = glen;
dhKey->pubKey = BSL_SAL_Calloc(1u, plen);
if (dhKey->pubKey == NULL) {
STUB_CRYPT_FreeDhKeyCallback(dhKey);
return NULL;
}
if (memset_s(dhKey->pubKey, plen, 3u, plen) != EOK) {
STUB_CRYPT_FreeDhKeyCallback(dhKey);
return NULL;
}
dhKey->pubKeyLen = plen;
dhKey->privateKey = BSL_SAL_Calloc(1u, plen);
if (dhKey->privateKey == NULL) {
STUB_CRYPT_FreeDhKeyCallback(dhKey);
return NULL;
}
if (memset_s(dhKey->privateKey, plen, 4u, plen) != EOK) {
STUB_CRYPT_FreeDhKeyCallback(dhKey);
return NULL;
}
dhKey->privateKeyLen = plen;
return dhKey;
}
HITLS_CRYPT_Key *STUB_CRYPT_GenerateDhKeyByParamsCallbackLibCtx(void *libCtx, const char *attrName,
uint8_t *p, uint16_t plen, uint8_t *g, uint16_t glen)
{
(void)libCtx;
(void)attrName;
return STUB_CRYPT_GenerateDhKeyByParamsCallback(p, plen, g, glen);
}
int32_t STUB_CRYPT_DHGetParametersCallback(HITLS_CRYPT_Key *key, uint8_t *p, uint16_t *plen, uint8_t *g, uint16_t *glen)
{
if ((key == NULL) || (plen == NULL) || (glen == NULL)) {
return HITLS_INTERNAL_EXCEPTION;
}
FRAME_DhKey *dhKey = (FRAME_DhKey *)key;
if (p != NULL) {
if (memcpy_s(p, *plen, dhKey->p, dhKey->plen) != EOK) {
return HITLS_MEMCPY_FAIL;
}
}
if (g != NULL) {
if (memcpy_s(g, *glen, dhKey->g, dhKey->glen) != EOK) {
return HITLS_MEMCPY_FAIL;
}
}
*plen = dhKey->plen;
*glen = dhKey->glen;
return HITLS_SUCCESS;
}
int32_t STUB_CRYPT_GetDhEncodedPubKeyCallback(HITLS_CRYPT_Key *key, uint8_t *pubKeyBuf, uint32_t bufLen,
uint32_t *pubKeyLen)
{
if ((key == NULL) || (pubKeyBuf == NULL) || (pubKeyLen == NULL)) {
return HITLS_INTERNAL_EXCEPTION;
}
FRAME_DhKey *dhKey = (FRAME_DhKey *)key;
if (memcpy_s(pubKeyBuf, bufLen, dhKey->pubKey, dhKey->pubKeyLen) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*pubKeyLen = dhKey->pubKeyLen;
return HITLS_SUCCESS;
}
int32_t STUB_CRYPT_CalcDhSharedSecretCallback(HITLS_CRYPT_Key *key, uint8_t *peerPubkey, uint32_t pubKeyLen,
uint8_t *sharedSecret, uint32_t *sharedSecretLen)
{
FRAME_DhKey *dhKey = (FRAME_DhKey *)key;
if ((dhKey == NULL) ||
(peerPubkey == NULL) ||
(sharedSecret == NULL) ||
(sharedSecretLen == NULL) ||
(dhKey->plen < pubKeyLen)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (memset_s(sharedSecret, *sharedSecretLen, 1u, dhKey->plen) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*sharedSecretLen = dhKey->plen;
return HITLS_SUCCESS;
}
/**
* @ingroup hitls_crypt_reg
* @brief Obtain the HMAC length
*
* @param hashAlgo [IN] Hash algorithm
*
* @return HMAC length
*/
uint32_t STUB_CRYPT_HmacSizeCallback(HITLS_HashAlgo hashAlgo)
{
switch (hashAlgo) {
case HITLS_HASH_MD5:
return MD5_DIGEST_LENGTH;
case HITLS_HASH_SHA1:
return SHA1_DIGEST_LENGTH;
case HITLS_HASH_SHA_256:
return SHA256_DIGEST_LENGTH;
case HITLS_HASH_SHA_384:
return SHA384_DIGEST_LENGTH;
case HITLS_HASH_SHA_512:
return SHA512_DIGEST_LENGTH;
default:
break;
}
return 0u;
}
/**
* @ingroup hitls_crypt_reg
* @brief Initialize the HMAC context
*
* @param hashAlgo [IN] Hash algorithm
* @param key [IN] Key
* @param len [IN] Key length
*
* @return HMAC context
*/
HITLS_HMAC_Ctx *STUB_CRYPT_HmacInitCallback(HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t len)
{
FRAME_HmacCtx *ctx = BSL_SAL_Calloc(1u, sizeof(FRAME_HmacCtx));
if (ctx == NULL) {
return NULL;
}
ctx->algo = hashAlgo;
ctx->key = BSL_SAL_Dump(key, len);
if (ctx->key == NULL) {
BSL_SAL_FREE(ctx);
return NULL;
}
ctx->keyLen = len;
return ctx;
}
HITLS_HMAC_Ctx *STUB_CRYPT_HmacInitCallbackLibCtx(void *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t len)
{
(void)libCtx;
(void)attrName;
return STUB_CRYPT_HmacInitCallback(hashAlgo, key, len);
}
/**
* @ingroup hitls_crypt_reg
* @brief Release the HMAC context
*
* @param ctx [IN] HMAC context
*/
void STUB_CRYPT_HmacFreeCallback(HITLS_HMAC_Ctx *ctx)
{
FRAME_HmacCtx *hmacCtx = (FRAME_HmacCtx *)ctx;
if (hmacCtx != NULL) {
BSL_SAL_FREE(hmacCtx->key);
BSL_SAL_FREE(hmacCtx);
}
return;
}
/**
* @ingroup hitls_crypt_reg
* @brief Add the input data
*
* @param ctx [IN] HMAC context
* @param data [IN] Input data
* @param len [IN] Data length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_HmacUpdateCallback(HITLS_HMAC_Ctx *ctx, const uint8_t *data, uint32_t len)
{
if ((ctx == NULL) || (data == NULL) || len == 0) {
return HITLS_INTERNAL_EXCEPTION;
}
return HITLS_SUCCESS;
}
/**
* @ingroup hitls_crypt_reg
* @brief Output the HMAC result
*
* @param ctx [IN] HMAC context
* @param out [OUT] Output data
* @param len [IN/OUT] IN: Maximum buffer length OUT: Output data length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_HmacFinalCallback(HITLS_HMAC_Ctx *ctx, uint8_t *out, uint32_t *len)
{
FRAME_HmacCtx *hmacCtx = (FRAME_HmacCtx *)ctx;
if ((hmacCtx == NULL) || (out == NULL) || (len == NULL)) {
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t hmacSize = STUB_CRYPT_HmacSizeCallback(hmacCtx->algo);
if ((hmacSize == 0u) || (hmacSize > *len)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (memset_s(out, *len, 4u, hmacSize) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*len = hmacSize;
return HITLS_SUCCESS;
}
/**
* @ingroup hitls_crypt_reg
* @brief HMAC function
*
* @param hashAlgo [IN] Hash algorithm
* @param key [IN] Key
* @param keyLen [IN] Key length
* @param in [IN] Input data
* @param inLen [IN] Input data length
* @param out [OUT] Output data
* @param outLen [IN/OUT] IN: Maximum buffer length OUT: Output data length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_HmacCallback(HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t keyLen,
const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
if ((key == NULL) || (keyLen == 0) || (in == NULL) || (inLen == 0) ||
(out == NULL) || (outLen == NULL)) {
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t hmacSize = STUB_CRYPT_HmacSizeCallback(hashAlgo);
if ((hmacSize == 0u) || (hmacSize > *outLen)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (memset_s(out, *outLen, 4u, hmacSize) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*outLen = hmacSize;
return HITLS_SUCCESS;
}
int32_t STUB_CRYPT_HmacCallbackLibCtx(void *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t keyLen,
const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
(void)libCtx;
(void)attrName;
return STUB_CRYPT_HmacCallback(hashAlgo, key, keyLen, in, inLen, out, outLen);
}
/**
* @ingroup hitls_crypt_reg
* @brief Obtain the hash length
*
* @param hashAlgo [IN] Hash algorithm
*
* @return Hash length
*/
uint32_t STUB_CRYPT_DigestSizeCallback(HITLS_HashAlgo hashAlgo)
{
return STUB_CRYPT_HmacSizeCallback(hashAlgo);
}
/**
* @ingroup hitls_crypt_reg
* @brief Initialize the hash context
*
* @param hashAlgo [IN] Hash algorithm
*
* @return hash context
*/
HITLS_HASH_Ctx *STUB_CRYPT_DigestInitCallback(HITLS_HashAlgo hashAlgo)
{
FRAME_HashCtx *ctx = BSL_SAL_Calloc(1u, sizeof(FRAME_HashCtx));
if (ctx == NULL) {
return NULL;
}
ctx->algo = hashAlgo;
return ctx;
}
HITLS_HASH_Ctx *STUB_CRYPT_DigestInitCallbackLibCtx(void *libCtx, const char *attrName, HITLS_HashAlgo hashAlgo)
{
(void)libCtx;
(void)attrName;
return STUB_CRYPT_DigestInitCallback(hashAlgo);
}
/**
* @ingroup hitls_crypt_reg
* @brief Copy hash Context
*
* @param ctx [IN] hash Context
*
* @return hash Context
*/
HITLS_HASH_Ctx *STUB_CRYPT_DigestCopyCallback(HITLS_HASH_Ctx *ctx)
{
FRAME_HashCtx *srcCtx = (FRAME_HashCtx *)ctx;
if (srcCtx == NULL) {
return NULL;
}
FRAME_HashCtx *newCtx = BSL_SAL_Calloc(1u, sizeof(FRAME_HashCtx));
if (newCtx == NULL) {
return NULL;
}
newCtx->algo = srcCtx->algo;
return newCtx;
}
/**
* @ingroup hitls_crypt_reg
* @brief Release the hash context
*
* @param ctx [IN] hash Context
*/
void STUB_CRYPT_DigestFreeCallback(HITLS_HASH_Ctx *ctx)
{
BSL_SAL_FREE(ctx);
return;
}
/**
* @ingroup hitls_crypt_reg
* @brief Add the input data
*
* @param ctx [IN] hash Context
* @param data [IN] Input data
* @param len [IN] Input data length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_DigestUpdateCallback(HITLS_HASH_Ctx *ctx, const uint8_t *data, uint32_t len)
{
if ((ctx == NULL) || (data == NULL) || (len == 0u)) {
return HITLS_INTERNAL_EXCEPTION;
}
return HITLS_SUCCESS;
}
/**
* @ingroup hitls_crypt_reg
* @brief Output the hash result
*
* @param ctx [IN] hash Context
* @param out [IN] Output data
* @param len [IN/OUT] IN: Maximum buffer length OUT: Output data length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_DigestFinalCallback(HITLS_HASH_Ctx *ctx, uint8_t *out, uint32_t *len)
{
FRAME_HashCtx *hashCtx = (FRAME_HashCtx *)ctx;
if ((hashCtx == NULL) || (out == NULL) || (len == NULL)) {
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t digestSize = STUB_CRYPT_DigestSizeCallback(hashCtx->algo);
if ((digestSize == 0) || (digestSize > *len)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (memset_s(out, *len, 5u, digestSize) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*len = digestSize;
return HITLS_SUCCESS;
}
/**
* @ingroup hitls_crypt_reg
* @brief hash function
*
* @param hashAlgo [IN] Hash algorithm
* @param in [IN] Input data
* @param inLen [IN] Input data length
* @param out [OUT] Output data
* @param outLen [IN/OUT] IN: Maximum buffer length OUT: Output data length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_DigestCallback(HITLS_HashAlgo hashAlgo, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
if ((in == NULL) ||
(out == NULL) ||
(outLen == NULL) ||
(inLen == 0)) {
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t digestSize = STUB_CRYPT_DigestSizeCallback(hashAlgo);
if ((digestSize == 0) || (digestSize > *outLen)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (memset_s(out, *outLen, 5u, digestSize) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*outLen = digestSize;
return HITLS_SUCCESS;
}
int32_t STUB_CRYPT_DigestCallbackLibCtx(void *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
(void)libCtx;
(void)attrName;
return STUB_CRYPT_DigestCallback(hashAlgo, in, inLen, out, outLen);
}
/**
* @ingroup hitls_crypt_reg
* @brief Encryption
*
* @param cipher [IN] Key parameters
* @param in [IN] Plaintext data
* @param inLen [IN] Plaintext data length
* @param out [OUT] Ciphertext data
* @param outLen [IN/OUT] IN: maximum buffer length OUT: ciphertext data length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_EncryptCallback(const HITLS_CipherParameters *cipher, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
if (cipher->type == HITLS_AEAD_CIPHER) {
if (*outLen < inLen + AEAD_TAG_LENGTH) {
return HITLS_INTERNAL_EXCEPTION;
}
(void)memset_s(out, *outLen, 0, *outLen);
if (inLen != 0 && memcpy_s(out, *outLen, in, inLen) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*outLen = inLen + AEAD_TAG_LENGTH;
} else {
*outLen = 0;
return HITLS_INTERNAL_EXCEPTION;
}
return HITLS_SUCCESS;
}
int32_t STUB_CRYPT_EncryptCallbackLibCtx(void *libCtx, const char *attrName,
const HITLS_CipherParameters *cipher, const uint8_t *in,
uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
(void)libCtx;
(void)attrName;
return STUB_CRYPT_EncryptCallback(cipher, in, inLen, out, outLen);
}
/**
* @ingroup hitls_crypt_reg
* @brief Decrypt
*
* @param cipher [IN] Key parameters
* @param in [IN] Ciphertext data
* @param inLen [IN] Ciphertext data length
* @param out [OUT] Plaintext data
* @param outLen [IN/OUT] IN: Maximum buffer length OUT: Plaintext data length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_DecryptCallback(const HITLS_CipherParameters *cipher, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
if (cipher->type == HITLS_AEAD_CIPHER) {
if (inLen < AEAD_TAG_LENGTH) {
return HITLS_INTERNAL_EXCEPTION;
}
(void)memset_s(out, *outLen, 0, *outLen);
if (memcpy_s(out, *outLen, in, inLen - AEAD_TAG_LENGTH) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*outLen = inLen - AEAD_TAG_LENGTH;
} else {
*outLen = 0;
return HITLS_INTERNAL_EXCEPTION;
}
return HITLS_SUCCESS;
}
int32_t STUB_CRYPT_DecryptCallbackLibCtx(void *libCtx, const char *attrName,
const HITLS_CipherParameters *cipher, const uint8_t *in,
uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
(void)libCtx;
(void)attrName;
return STUB_CRYPT_DecryptCallback(cipher, in, inLen, out, outLen);
}
FuncStubInfo g_tmpRpInfo[16] = {0};
void FRAME_RegCryptMethod(void)
{
#ifndef HITLS_TLS_FEATURE_PROVIDER
HITLS_CRYPT_BaseMethod cryptMethod = { 0 };
cryptMethod.randBytes = STUB_CRYPT_RandBytesCallback;
cryptMethod.hmacSize = STUB_CRYPT_HmacSizeCallback;
cryptMethod.hmacInit = STUB_CRYPT_HmacInitCallback;
cryptMethod.hmacFree = STUB_CRYPT_HmacFreeCallback;
cryptMethod.hmacUpdate = STUB_CRYPT_HmacUpdateCallback;
cryptMethod.hmacFinal = STUB_CRYPT_HmacFinalCallback;
cryptMethod.hmac = STUB_CRYPT_HmacCallback;
cryptMethod.digestSize = STUB_CRYPT_DigestSizeCallback;
cryptMethod.digestInit = STUB_CRYPT_DigestInitCallback;
cryptMethod.digestCopy = STUB_CRYPT_DigestCopyCallback;
cryptMethod.digestFree = CRYPT_DEFAULT_DigestFree;
cryptMethod.digestUpdate = STUB_CRYPT_DigestUpdateCallback;
cryptMethod.digestFinal = STUB_CRYPT_DigestFinalCallback;
cryptMethod.digest = STUB_CRYPT_DigestCallback;
cryptMethod.encrypt = STUB_CRYPT_EncryptCallback;
cryptMethod.decrypt = STUB_CRYPT_DecryptCallback;
cryptMethod.cipherFree = CRYPT_DEFAULT_CipherFree;
HITLS_CRYPT_RegisterBaseMethod(&cryptMethod);
HITLS_CRYPT_EcdhMethod ecdhMethod = { 0 };
ecdhMethod.generateEcdhKeyPair = STUB_CRYPT_GenerateEcdhKeyPairCallback;
ecdhMethod.freeEcdhKey = CRYPT_DEFAULT_FreeKey;
ecdhMethod.getEcdhPubKey = STUB_CRYPT_GetEcdhEncodedPubKeyCallback;
ecdhMethod.calcEcdhSharedSecret = STUB_CRYPT_CalcEcdhSharedSecretCallback;
HITLS_CRYPT_RegisterEcdhMethod(&ecdhMethod);
HITLS_CRYPT_DhMethod dhMethod = { 0 };
dhMethod.generateDhKeyBySecbits = STUB_CRYPT_GenerateDhKeyBySecbitsCallback;
dhMethod.generateDhKeyByParams = STUB_CRYPT_GenerateDhKeyByParamsCallback;
dhMethod.freeDhKey = CRYPT_DEFAULT_FreeKey;
dhMethod.getDhParameters = STUB_CRYPT_DHGetParametersCallback;
dhMethod.getDhPubKey = STUB_CRYPT_GetDhEncodedPubKeyCallback;
dhMethod.calcDhSharedSecret = STUB_CRYPT_CalcDhSharedSecretCallback;
HITLS_CRYPT_RegisterDhMethod(&dhMethod);
#else
STUB_Init();
STUB_Replace(&g_tmpRpInfo[0], CRYPT_EAL_RandbytesEx, STUB_CRYPT_RandBytesCallbackLibCtx);
STUB_Replace(&g_tmpRpInfo[1], HITLS_CRYPT_HMAC_Init, STUB_CRYPT_HmacInitCallbackLibCtx);
STUB_Replace(&g_tmpRpInfo[2], HITLS_CRYPT_HMAC, STUB_CRYPT_HmacCallbackLibCtx);
STUB_Replace(&g_tmpRpInfo[3], HITLS_CRYPT_DigestInit, STUB_CRYPT_DigestInitCallbackLibCtx);
STUB_Replace(&g_tmpRpInfo[4], HITLS_CRYPT_Digest, STUB_CRYPT_DigestCallbackLibCtx);
STUB_Replace(&g_tmpRpInfo[5], HITLS_CRYPT_Encrypt, STUB_CRYPT_EncryptCallbackLibCtx);
STUB_Replace(&g_tmpRpInfo[6], HITLS_CRYPT_Decrypt, STUB_CRYPT_DecryptCallbackLibCtx);
STUB_Replace(&g_tmpRpInfo[7], HITLS_CRYPT_GenerateEcdhKey, STUB_CRYPT_GenerateEcdhKeyPairCallbackLibCtx);
STUB_Replace(&g_tmpRpInfo[8], HITLS_CRYPT_EcdhCalcSharedSecret, STUB_CRYPT_CalcEcdhSharedSecretCallbackLibCtx);
STUB_Replace(&g_tmpRpInfo[9], HITLS_CRYPT_GenerateDhKeyByParameters, STUB_CRYPT_GenerateDhKeyByParamsCallbackLibCtx);
STUB_Replace(&g_tmpRpInfo[10], HITLS_CRYPT_GenerateDhKeyBySecbits, STUB_CRYPT_GenerateDhKeyBySecbitsCallbackLibCtx);
#endif
return;
}
void FRAME_DeRegCryptMethod(void)
{
#ifndef HITLS_TLS_FEATURE_PROVIDER
HITLS_CRYPT_BaseMethod cryptMethod = { 0 };
HITLS_CRYPT_RegisterBaseMethod(&cryptMethod);
HITLS_CRYPT_EcdhMethod ecdhMethod = { 0 };
HITLS_CRYPT_RegisterEcdhMethod(&ecdhMethod);
HITLS_CRYPT_DhMethod dhMethod = { 0 };
HITLS_CRYPT_RegisterDhMethod(&dhMethod);
#else
STUB_Reset(&g_tmpRpInfo[0]);
STUB_Reset(&g_tmpRpInfo[1]);
STUB_Reset(&g_tmpRpInfo[2]);
STUB_Reset(&g_tmpRpInfo[3]);
STUB_Reset(&g_tmpRpInfo[4]);
STUB_Reset(&g_tmpRpInfo[5]);
STUB_Reset(&g_tmpRpInfo[6]);
STUB_Reset(&g_tmpRpInfo[7]);
STUB_Reset(&g_tmpRpInfo[8]);
STUB_Reset(&g_tmpRpInfo[9]);
STUB_Reset(&g_tmpRpInfo[10]);
#endif
return;
} | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/crypt/src/stub_crypt.c | C | unknown | 27,132 |
/*
* 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 <string.h>
#include "securec.h"
#include "bsl_sal.h"
#include "hitls_error.h"
#include "hs_ctx.h"
#include "hs_common.h"
#include "change_cipher_spec.h"
#include "stub_replace.h"
#include "frame_tls.h"
#include "frame_io.h"
#include "frame_link.h"
#include "parse.h"
#define ENTER_USER_SPECIFY_STATE (HITLS_UIO_FAIL_START + 0xFFFF)
#define READ_BUF_SIZE 18432
HITLS_HandshakeState g_nextState;
bool g_isClient;
int32_t FRAME_TrasferMsgBetweenLink(FRAME_LinkObj *linkA, FRAME_LinkObj *linkB)
{
int32_t ret = HITLS_SUCCESS;
uint32_t readLen = 0;
char *buffer = BSL_SAL_Calloc(1u, MAX_RECORD_LENTH);
if (buffer == NULL) {
return HITLS_MEMALLOC_FAIL;
}
// linkA->io->userData to buffer
ret = FRAME_TransportSendMsg(linkA->io, buffer, MAX_RECORD_LENTH, &readLen);
if (ret != HITLS_SUCCESS) {
BSL_SAL_FREE(buffer);
return ret;
}
if (readLen == 0) {
BSL_SAL_FREE(buffer);
return HITLS_SUCCESS;
}
// buffer to linkB->io->userData
ret = FRAME_TransportRecMsg(linkB->io, buffer, readLen);
if (ret != HITLS_SUCCESS) {
BSL_SAL_FREE(buffer);
return ret;
}
BSL_SAL_FREE(buffer);
return HITLS_SUCCESS;
}
static int32_t STUB_ChangeState(TLS_Ctx *ctx, uint32_t nextState)
{
int32_t ret = HITLS_SUCCESS;
if (g_nextState == nextState) {
if (g_isClient == ctx->isClient) {
HS_CleanMsg(ctx->hsCtx->hsMsg);
ctx->hsCtx->hsMsg = NULL;
ret = HITLS_REC_NORMAL_RECV_BUF_EMPTY;
}
}
HS_Ctx *hsCtx = (HS_Ctx *)ctx->hsCtx;
hsCtx->state = nextState;
return ret;
}
static bool StateCompare(FRAME_LinkObj *link, bool isClient, HITLS_HandshakeState state)
{
if ((isClient == link->ssl->isClient) && (link->ssl->hsCtx != NULL) && (link->ssl->hsCtx->state == state)) {
if (state != TRY_RECV_FINISH && state != TRY_RECV_CERTIFICATE) {
return true;
}
/* In tls1.3, if the single-end verification is used, the server may receive the CCS message in the TRY_RECV_FINISH phase */
if (state == TRY_RECV_FINISH){
if (link->needStopBeforeRecvCCS || CCS_IsRecv(link->ssl) == true ||
(link->ssl->config.tlsConfig.maxVersion == HITLS_VERSION_TLS13 && isClient == true) ||
(link->ssl->config.tlsConfig.maxVersion == HITLS_VERSION_TLS13 &&
link->ssl->config.tlsConfig.isSupportClientVerify == true)) {
return true;
}
}
// In tls1.3, the server may receive the CCS message in the TRY_RECV_CERTIFICATIONATE phase
if (state == TRY_RECV_CERTIFICATE){
if (link->needStopBeforeRecvCCS || CCS_IsRecv(link->ssl) == true ||
#ifdef HITLS_TLS_PROTO_TLS13
link->ssl->hsCtx->haveHrr == true ||
#endif /* HITLS_TLS_PROTO_TLS13 */
link->ssl->config.tlsConfig.maxVersion != HITLS_VERSION_TLS13 || isClient == true) {
return true;
}
}
}
return false;
}
int32_t FRAME_CreateConnection(FRAME_LinkObj *client, FRAME_LinkObj *server, bool isClient, HITLS_HandshakeState state)
{
int32_t clientRet;
int32_t serverRet;
int32_t ret;
uint32_t count = 0;
if (client == NULL || server == NULL) {
return HITLS_NULL_INPUT;
}
g_isClient = isClient;
g_nextState = state;
FuncStubInfo tmpRpInfo = {0};
STUB_Init();
STUB_Replace(&tmpRpInfo, HS_ChangeState, STUB_ChangeState);
do {
// Check whether the client needs to be stopped. If yes, return success
if (StateCompare(client, isClient, state)) {
ret = HITLS_SUCCESS;
break;
}
// Invoke the client to establish a connection
clientRet = HITLS_Connect(client->ssl);
if (clientRet != HITLS_SUCCESS) {
ret = clientRet;
if ((clientRet != HITLS_REC_NORMAL_IO_BUSY) && (clientRet != HITLS_REC_NORMAL_RECV_BUF_EMPTY)) {
break;
}
}
// Transfer the message to the server
ret = FRAME_TrasferMsgBetweenLink(client, server);
if (ret != HITLS_SUCCESS) {
break;
}
// Check whether the server needs to be stopped. If yes, return success
if (StateCompare(server, isClient, state)) {
ret = HITLS_SUCCESS;
break;
}
// Invoke the server to establish a connection
serverRet = HITLS_Accept(server->ssl);
if (serverRet != HITLS_SUCCESS) {
ret = serverRet;
if ((serverRet != HITLS_REC_NORMAL_IO_BUSY) && (serverRet != HITLS_REC_NORMAL_RECV_BUF_EMPTY)) {
break;
}
}
// Transfer the message to the client
ret = FRAME_TrasferMsgBetweenLink(server, client);
if (ret != HITLS_SUCCESS) {
break;
}
/* To receive TLS1.3 new session ticket messages */
if (clientRet == HITLS_SUCCESS) {
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen = 0;
ret = HITLS_Read(client->ssl, readBuf, READ_BUF_SIZE, &readLen);
// No application data. return HITLS_REC_NORMAL_RECV_BUF_EMPTY
if (ret != HITLS_REC_NORMAL_RECV_BUF_EMPTY) {
return ret;
}
}
// If the connection is set up on both sides, return success
if (clientRet == HITLS_SUCCESS && serverRet == HITLS_SUCCESS) {
ret = HITLS_SUCCESS;
break;
}
count++;
ret = HITLS_INTERNAL_EXCEPTION;
// Prevent infinite loop. No more than 30 messages are exchanged between the client and server during the handshake
} while (count < 30);
//Check whether the hsCtx status meets the expectation. If hsCtx is destructed, HITLS_INTERNAL_EXCEPTION is returned
if (state != HS_STATE_BUTT) {
FRAME_LinkObj *point = (isClient) ? (client) : (server);
if (point->ssl->hsCtx == NULL) {
ret = HITLS_INTERNAL_EXCEPTION;
} else if (point->ssl->hsCtx->state != state) {
ret = HITLS_INTERNAL_EXCEPTION;
}
}
STUB_Reset(&tmpRpInfo);
return ret;
}
int32_t FRAME_CreateRenegotiation(FRAME_LinkObj *linkA, FRAME_LinkObj *linkB)
{
int32_t clientRet;
int32_t serverRet;
int32_t ret;
uint32_t count = 0;
// renegotiation signal
uint8_t writeBuf[1] = {1};
uint8_t readBuf[32] = {0}; // buffer for receive temporary messages, 32 bytes long
uint32_t readBufLen = 0;
if (linkA->ssl->state != CM_STATE_RENEGOTIATION) {
return HITLS_SUCCESS;
}
do {
uint32_t len = 0;
clientRet = HITLS_Write(linkA->ssl, writeBuf, sizeof(writeBuf), &len);
if (clientRet != HITLS_SUCCESS) {
ret = clientRet;
if ((clientRet != HITLS_REC_NORMAL_IO_BUSY) && (clientRet != HITLS_REC_NORMAL_RECV_BUF_EMPTY)) {
break;
}
}
ret = FRAME_TrasferMsgBetweenLink(linkA, linkB);
if (ret != HITLS_SUCCESS) {
break;
}
readBufLen = 0;
(void)memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
serverRet = HITLS_Read(linkB->ssl, readBuf, sizeof(readBuf), &readBufLen);
if (serverRet != HITLS_SUCCESS) {
ret = serverRet;
if ((serverRet != HITLS_REC_NORMAL_IO_BUSY) && (serverRet != HITLS_REC_NORMAL_RECV_BUF_EMPTY)) {
break;
}
}
ret = FRAME_TrasferMsgBetweenLink(linkB, linkA);
if (ret != HITLS_SUCCESS) {
break;
}
// If the connection is set up on both sides, return success
if (clientRet == HITLS_SUCCESS && serverRet == HITLS_SUCCESS &&
linkA->ssl->state == CM_STATE_TRANSPORTING && linkB->ssl->state == CM_STATE_TRANSPORTING) {
if ((readBufLen != sizeof(writeBuf)) ||
(memcmp(writeBuf, readBuf, readBufLen) != 0)) {
ret = HITLS_INTERNAL_EXCEPTION;
} else {
ret = HITLS_SUCCESS;
}
break;
}
count++;
ret = HITLS_INTERNAL_EXCEPTION;
// Prevent infinite loop. No more than 30 messages are exchanged between the client and server during the handshake
} while (count < 30);
return ret;
}
int32_t FRAME_CreateRenegotiationServer(FRAME_LinkObj *server, FRAME_LinkObj *client)
{
int32_t clientRet;
int32_t serverRet;
int32_t ret;
uint32_t count = 0;
// renegotiation signal
uint8_t readBuf[32] = {0}; // buffer for receive temporary messages, 32 bytes long
uint32_t readBufLen = 0;
if (server->ssl->state != CM_STATE_RENEGOTIATION) {
return HITLS_SUCCESS;
}
do {
readBufLen = 0;
(void)memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
serverRet = HITLS_Read(server->ssl, readBuf, sizeof(readBuf), &readBufLen);
if (serverRet != HITLS_SUCCESS) {
ret = serverRet;
if ((serverRet != HITLS_REC_NORMAL_IO_BUSY) && (serverRet != HITLS_REC_NORMAL_RECV_BUF_EMPTY)) {
break;
}
}
ret = FRAME_TrasferMsgBetweenLink(server, client);
if (ret != HITLS_SUCCESS) {
break;
}
readBufLen = 0;
(void)memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
clientRet = HITLS_Read(client->ssl, readBuf, sizeof(readBuf), &readBufLen);
if (clientRet != HITLS_SUCCESS) {
ret = clientRet;
if ((clientRet != HITLS_REC_NORMAL_IO_BUSY) && (clientRet != HITLS_REC_NORMAL_RECV_BUF_EMPTY)) {
break;
}
}
ret = FRAME_TrasferMsgBetweenLink(client, server);
if (ret != HITLS_SUCCESS) {
break;
}
// If the connection is set up on both sides, return success
if (clientRet == HITLS_REC_NORMAL_RECV_BUF_EMPTY && serverRet == HITLS_REC_NORMAL_RECV_BUF_EMPTY &&
server->ssl->state == CM_STATE_TRANSPORTING && client->ssl->state == CM_STATE_TRANSPORTING) {
ret = HITLS_SUCCESS;
break;
}
count++;
ret = HITLS_INTERNAL_EXCEPTION;
// Prevent infinite loop. No more than 30 messages are exchanged between the client and server during the handshake
} while (count < 30);
return ret;
}
int32_t FRAME_CreateRenegotiationState(FRAME_LinkObj *client, FRAME_LinkObj *server, bool isClient, HITLS_HandshakeState state)
{
int32_t clientRet;
int32_t serverRet;
int32_t ret;
uint32_t count = 0;
// renegotiation signal
uint8_t writeBuf[1] = {1};
uint8_t readBuf[32] = {0}; // buffer for receive temporary messages, 32 bytes long
uint32_t readBufLen = 0;
if (client->ssl->state != CM_STATE_RENEGOTIATION) {
return HITLS_SUCCESS;
}
g_isClient = isClient;
g_nextState = state;
FuncStubInfo tmpRpInfo = {0};
STUB_Init();
STUB_Replace(&tmpRpInfo, HS_ChangeState, STUB_ChangeState);
do {
// Check whether the client needs to be stopped. If yes, return success
if (StateCompare(client, isClient, state)) {
ret = HITLS_SUCCESS;
break;
}
uint32_t len = 0;
clientRet = HITLS_Write(client->ssl, writeBuf, sizeof(writeBuf), &len);
if (clientRet != HITLS_SUCCESS) {
ret = clientRet;
if ((clientRet != HITLS_REC_NORMAL_IO_BUSY) && (clientRet != HITLS_REC_NORMAL_RECV_BUF_EMPTY)) {
break;
}
}
ret = FRAME_TrasferMsgBetweenLink(client, server);
if (ret != HITLS_SUCCESS) {
break;
}
// Check whether the server needs to be stopped. If yes, return success
if (StateCompare(server, isClient, state)) {
ret = HITLS_SUCCESS;
break;
}
readBufLen = 0;
(void)memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
serverRet = HITLS_Read(server->ssl, readBuf, sizeof(readBuf), &readBufLen);
if (serverRet != HITLS_SUCCESS) {
ret = serverRet;
if ((serverRet != HITLS_REC_NORMAL_IO_BUSY) && (serverRet != HITLS_REC_NORMAL_RECV_BUF_EMPTY)) {
break;
}
}
ret = FRAME_TrasferMsgBetweenLink(server, client);
if (ret != HITLS_SUCCESS) {
break;
}
// If the connection is set up on both sides, return success
if (clientRet == HITLS_SUCCESS && serverRet == HITLS_SUCCESS &&
client->ssl->state == CM_STATE_TRANSPORTING && server->ssl->state == CM_STATE_TRANSPORTING) {
if ((readBufLen != sizeof(writeBuf)) ||
(memcmp(writeBuf, readBuf, readBufLen) != 0)) {
ret = HITLS_INTERNAL_EXCEPTION;
} else {
ret = HITLS_SUCCESS;
}
break;
}
count++;
ret = HITLS_INTERNAL_EXCEPTION;
// Prevent infinite loop. No more than 30 messages are exchanged between the client and server during the handshake
} while (count < 30);
//Check whether the hsCtx status meets the expectation. If hsCtx is destructed, HITLS_INTERNAL_EXCEPTION is returned
if (state != HS_STATE_BUTT) {
FRAME_LinkObj *point = (isClient) ? (client) : (server);
if (point->ssl->hsCtx == NULL) {
ret = HITLS_INTERNAL_EXCEPTION;
} else if (point->ssl->hsCtx->state != state) {
ret = HITLS_INTERNAL_EXCEPTION;
}
}
STUB_Reset(&tmpRpInfo);
return ret;
} | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/frame/src/frame_connect.c | C | unknown | 14,226 |
/*
* 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 <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include "hitls_build.h"
#include "cert_callback.h"
#include "bsl_sal.h"
#include "bsl_log.h"
#include "bsl_err.h"
#include "crypt_algid.h"
#include "hitls_crypt_init.h"
#include "crypt_eal_rand.h"
#include "hitls_cert_init.h"
#include "bsl_log.h"
static void *StdMalloc(uint32_t len)
{
return malloc((uint32_t)len);
}
static void StdFree(void *addr)
{
free(addr);
}
static void *StdMallocFail(uint32_t len)
{
(void)len;
return NULL;
}
void BinLogFixLenFunc(uint32_t logId, uint32_t logLevel, uint32_t 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 FRAME_Init(void)
{
BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_MALLOC, StdMalloc);
BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_FREE, StdFree);
BSL_ERR_Init();
#ifdef TLS_DEBUG
BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_DEBUG);
BSL_LOG_BinLogFuncs logFunc = { BinLogFixLenFunc, BinLogVarLenFunc };
BSL_LOG_RegBinLogFunc(&logFunc);
#endif
#ifdef HITLS_TLS_FEATURE_PROVIDER
CRYPT_EAL_ProviderRandInitCtx(NULL, CRYPT_RAND_SHA256, "provider=default", NULL, 0, NULL);
#else
CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0);
HITLS_CertMethodInit();
HITLS_CryptMethodInit();
#endif
return;
}
void FRAME_DeInit(void)
{
BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_MALLOC, StdMallocFail);
BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_FREE, StdFree);
BSL_ERR_DeInit();
return;
} | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/frame/src/frame_init.c | C | unknown | 2,125 |
/*
* 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 "securec.h"
#include "bsl_sal.h"
#include "uio_base.h"
#include "uio_abstraction.h"
#include "hitls_crypt_type.h"
#include "hitls_cert_type.h"
#include "hitls_error.h"
#include "hlt_type.h"
#include "cert_callback.h"
#include "frame_tls.h"
#include "frame_io.h"
#include "frame_link.h"
#define MAX_CERT_PATH_LENGTH (1024)
HITLS_Ctx *FRAME_CreateDefaultDtlsObj(void)
{
HITLS_Config *config = HITLS_CFG_NewDTLS12Config();
if (config == NULL) {
return NULL;
}
char verifyPath[MAX_CERT_PATH_LENGTH] = {0};
char chainPath[MAX_CERT_PATH_LENGTH] = {0};
char certPath[MAX_CERT_PATH_LENGTH] = {0};
char keyPath[MAX_CERT_PATH_LENGTH] = {0};
if (sprintf_s(verifyPath, MAX_CERT_PATH_LENGTH, "%s:%s", RSA_SHA_CA_PATH, ECDSA_SHA_CA_PATH) <= 0) {
HITLS_CFG_FreeConfig(config);
return NULL;
}
if (sprintf_s(chainPath, MAX_CERT_PATH_LENGTH, "%s:%s", RSA_SHA_CHAIN_PATH, ECDSA_SHA_CHAIN_PATH) <= 0) {
HITLS_CFG_FreeConfig(config);
return NULL;
}
if (sprintf_s(certPath, MAX_CERT_PATH_LENGTH, "%s:%s", RSA_SHA256_EE_PATH3, ECDSA_SHA256_EE_PATH) <= 0) {
HITLS_CFG_FreeConfig(config);
return NULL;
}
if (sprintf_s(keyPath, MAX_CERT_PATH_LENGTH, "%s:%s", RSA_SHA256_PRIV_PATH3, ECDSA_SHA256_PRIV_PATH) <= 0) {
HITLS_CFG_FreeConfig(config);
return NULL;
}
int32_t ret = HiTLS_X509_LoadCertAndKey(config, verifyPath, chainPath, certPath, NULL, keyPath, NULL);
if (ret != HITLS_SUCCESS) {
HITLS_CFG_FreeConfig(config);
return NULL;
}
HITLS_Ctx *ctx = HITLS_New(config);
if (ctx == NULL) {
HITLS_CFG_FreeConfig(config);
return NULL;
}
HITLS_CFG_FreeConfig(config);
return ctx;
}
FRAME_LinkObj *CreateLink(HITLS_Config *config, BSL_UIO_TransportType type)
{
BSL_UIO_Method method = {0};
BSL_UIO *io = NULL;
FrameUioUserData *ioUserdata = NULL;
const BSL_UIO_Method *ori = NULL;
switch (type) {
case BSL_UIO_TCP:
#ifdef HITLS_BSL_UIO_TCP
ori = BSL_UIO_TcpMethod();
#endif
break;
case BSL_UIO_UDP:
#ifdef HITLS_BSL_UIO_UDP
ori = BSL_UIO_UdpMethod();
#endif
break;
default:
#ifdef HITLS_BSL_UIO_SCTP
ori = BSL_UIO_SctpMethod();
#endif
break;
}
if (memcpy_s(&method, sizeof(BSL_UIO_Method), ori, sizeof(method)) != EOK) {
return NULL;
}
FRAME_LinkObj *linkObj = BSL_SAL_Calloc(1u, sizeof(FRAME_LinkObj));
if (linkObj == NULL) {
return NULL;
}
HITLS_CFG_SetReadAhead(config, 1);
#ifdef HITLS_TLS_FEATURE_FLIGHT
HITLS_CFG_SetFlightTransmitSwitch(config, false);
#endif
HITLS_Ctx *sslObj = HITLS_New(config);
if (sslObj == NULL) {
goto ERR;
}
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
if (type == BSL_UIO_UDP) {
HITLS_SetMtu(sslObj, 16384);
}
#endif
INIT_IO_METHOD(method, type, FRAME_Write, FRAME_Read, FRAME_Ctrl);
io = BSL_UIO_New(&method);
if (io == NULL) {
goto ERR;
}
ioUserdata = FRAME_IO_CreateUserData();
if (ioUserdata == NULL) {
goto ERR;
}
uint32_t ret = BSL_UIO_SetUserData(io, ioUserdata);
if (ret != HITLS_SUCCESS) {
goto ERR;
}
int32_t fd = 666;
// Set any fd as the value of the underlying transfer I/O
ret = BSL_UIO_Ctrl(io, BSL_UIO_SET_FD, (int32_t)sizeof(fd), &fd);
if (ret != HITLS_SUCCESS) {
goto ERR;
}
BSL_UIO_SetInit(io, true);
// must return success
ret = HITLS_SetUio(sslObj, io);
if (ret != HITLS_SUCCESS) {
goto ERR;
}
linkObj->io = io;
linkObj->ssl = sslObj;
return linkObj;
ERR:
FRAME_IO_FreeUserData(ioUserdata);
BSL_UIO_Free(io);
HITLS_Free(sslObj);
BSL_SAL_FREE(linkObj);
return NULL;
}
#ifdef HITLS_TLS_PROTO_TLCP11
FRAME_LinkObj *FRAME_CreateTLCPLink(HITLS_Config *config, BSL_UIO_TransportType type, bool isClient)
{
#ifdef HITLS_TLS_CONFIG_KEY_USAGE
HITLS_CFG_SetCheckKeyUsage(config, false);
#endif
#ifdef HITLS_TLS_FEATURE_SECURITY
HITLS_CFG_SetSecurityLevel(config, HITLS_SECURITY_LEVEL_ZERO);
#endif /* HITLS_TLS_FEATURE_SECURITY */
int32_t ret;
if (isClient) {
ret = HiTLS_X509_LoadCertAndKey(config, SM2_VERIFY_PATH, SM2_CHAIN_PATH, SM2_CLIENT_ENC_CERT_PATH,
SM2_CLIENT_SIGN_CERT_PATH, SM2_CLIENT_ENC_KEY_PATH, SM2_CLIENT_SIGN_KEY_PATH);
} else {
ret = HiTLS_X509_LoadCertAndKey(config, SM2_VERIFY_PATH, SM2_CHAIN_PATH, SM2_SERVER_ENC_CERT_PATH,
SM2_SERVER_SIGN_CERT_PATH, SM2_SERVER_ENC_KEY_PATH, SM2_SERVER_SIGN_KEY_PATH);
}
if (ret != HITLS_SUCCESS) {
return NULL;
}
return CreateLink(config, type);
}
#endif /* HITLS_TLS_PROTO_TLCP11 */
//Set certificate and creating a connection
FRAME_LinkObj *FRAME_CreateLinkBase(HITLS_Config *config, BSL_UIO_TransportType type, bool setCertFlag)
{
int32_t ret;
if (setCertFlag) {
char verifyPath[MAX_CERT_PATH_LENGTH] = {0};
char chainPath[MAX_CERT_PATH_LENGTH] = {0};
char certPath[MAX_CERT_PATH_LENGTH] = {0};
char keyPath[MAX_CERT_PATH_LENGTH] = {0};
sprintf_s(verifyPath, MAX_CERT_PATH_LENGTH, "%s:%s", ECDSA_SHA_CA_PATH, RSA_SHA_CA_PATH);
sprintf_s(chainPath,
MAX_CERT_PATH_LENGTH,
"%s:%s",
ECDSA_SHA_CHAIN_PATH,
RSA_SHA_CHAIN_PATH);
sprintf_s(
certPath, MAX_CERT_PATH_LENGTH, "%s:%s", ECDSA_SHA256_EE_PATH, RSA_SHA256_EE_PATH3);
sprintf_s(keyPath,
MAX_CERT_PATH_LENGTH,
"%s:%s",
ECDSA_SHA256_PRIV_PATH,
RSA_SHA256_PRIV_PATH3);
ret = HiTLS_X509_LoadCertAndKey(config, verifyPath, chainPath, certPath, NULL, keyPath, NULL);
if (ret != HITLS_SUCCESS) {
return NULL;
}
}
return CreateLink(config, type);
}
FRAME_LinkObj *FRAME_CreateLink(HITLS_Config *config, BSL_UIO_TransportType type)
{
#ifdef HITLS_TLS_CONFIG_KEY_USAGE
HITLS_CFG_SetCheckKeyUsage(config, false);
#endif /* HITLS_TLS_CONFIG_KEY_USAGE */
#ifdef HITLS_TLS_FEATURE_SECURITY
HITLS_CFG_SetSecurityLevel(config, HITLS_SECURITY_LEVEL_ZERO);
#endif /* HITLS_TLS_FEATURE_SECURITY */
return FRAME_CreateLinkBase(config, type, true);
}
FRAME_LinkObj *FRAME_CreateLinkEx(HITLS_Config *config, BSL_UIO_TransportType type)
{
#ifdef HITLS_TLS_CONFIG_KEY_USAGE
HITLS_CFG_SetCheckKeyUsage(config, false);
#endif /* HITLS_TLS_CONFIG_KEY_USAGE */
#ifdef HITLS_TLS_FEATURE_SECURITY
HITLS_CFG_SetSecurityLevel(config, HITLS_SECURITY_LEVEL_ZERO);
#endif /* HITLS_TLS_FEATURE_SECURITY */
return FRAME_CreateLinkBase(config, type, false);
}
FRAME_LinkObj *FRAME_CreateLinkWithCert(HITLS_Config *config, BSL_UIO_TransportType type, const FRAME_CertInfo* certInfo)
{
#ifdef HITLS_TLS_CONFIG_KEY_USAGE
HITLS_CFG_SetCheckKeyUsage(config, false);
#endif /* HITLS_TLS_CONFIG_KEY_USAGE */
#ifdef HITLS_TLS_FEATURE_SECURITY
if (config->securityLevel == HITLS_SECURITY_LEVEL_ONE) {
HITLS_CFG_SetSecurityLevel(config, HITLS_SECURITY_LEVEL_ZERO);
}
#endif /* HITLS_TLS_FEATURE_SECURITY */
int32_t ret;
ret = HiTLS_X509_LoadCertAndKey(config,
certInfo->caFile,
certInfo->chainFile,
certInfo->endEquipmentFile,
certInfo->signFile,
certInfo->privKeyFile,
certInfo->signPrivKeyFile);
if (ret != HITLS_SUCCESS) {
return NULL;
}
return CreateLink(config, type);
}
void FRAME_FreeLink(FRAME_LinkObj *linkObj)
{
if (linkObj == NULL) {
return;
}
FRAME_IO_FreeUserData(BSL_UIO_GetUserData(linkObj->io));
// BSL_UIO_Free is automatically invoked twice in HITLS_Free
#ifdef HITLS_TLS_FEATURE_FLIGHT
if (linkObj->io != NULL && linkObj->io->references.count >= 2) {
while (linkObj->io->references.count > 2) {
BSL_UIO_Free(linkObj->io);
}
} else {
#endif
BSL_UIO_Free(linkObj->io);
#ifdef HITLS_TLS_FEATURE_FLIGHT
}
#endif
HITLS_Free(linkObj->ssl);
BSL_SAL_FREE(linkObj);
return;
}
HITLS_Ctx *FRAME_GetTlsCtx(const FRAME_LinkObj *linkObj)
{
if (linkObj == NULL) {
return NULL;
}
return linkObj->ssl;
}
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/frame/src/frame_link.c | C | unknown | 8,910 |
/*
* 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.
*/
#ifndef FRAME_LINK_H
#define FRAME_LINK_H
#include "hitls.h"
#include "bsl_uio.h"
#ifdef __cplusplus
extern "C" {
#endif
struct FRAME_LinkObj_ {
HITLS_Ctx *ssl;
BSL_UIO *io;
/* For CCS test, make TRY_RECV_FINISH stop before receiving CCS message */
bool needStopBeforeRecvCCS;
};
struct FRAME_CertInfo_ {
const char* caFile;
const char* chainFile;
const char* endEquipmentFile;
const char* signFile; // used TLCP
const char* privKeyFile;
const char* signPrivKeyFile; // used TLCP
};
#define INIT_IO_METHOD(method, tp, pfWrite, pfRead, pfCtrl) \
do { \
(method).uioType = tp; \
(method).uioRead = pfRead; \
(method).uioWrite = pfWrite; \
(method).uioCtrl = pfCtrl; \
} while (0)
#ifdef __cplusplus
}
#endif
#endif // FRAME_LINK_H
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/frame/src/frame_link.h | C | unknown | 1,538 |
/*
* 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 "frame_msg.h"
#include "hitls_error.h"
#include "frame_tls.h"
FRAME_Msg *FRAME_GenerateMsgFromBuffer(const FRAME_LinkObj *linkObj, const uint8_t *buffer, uint32_t len)
{
// Check whether the const Frame_LinkObj *linkObj parameter is required. If the parameter is not required, delete it
(void)linkObj;
(void)buffer;
(void)len;
return NULL;
}
/**
* @ingroup Obtain a message from the I/O receiving buffer of the connection
*
* @return Return the CTX object of the TLS
*/
int32_t FRAME_GetLinkRecMsg(FRAME_LinkObj *link, uint8_t *buffer, uint32_t len, uint32_t *msgLen)
{
(void)link;
(void)buffer;
(void)len;
(void)msgLen;
return HITLS_SUCCESS;
}
/**
* @ingroup Obtain a message from the I/O sending buffer of the connection
*
* @return Return the CTX object of the TLS
*/
int32_t FRAME_GetLinkSndMsg(FRAME_LinkObj *link, uint8_t *buffer, uint32_t len, uint32_t *msgLen)
{
(void)link;
(void)buffer;
(void)len;
(void)msgLen;
return HITLS_SUCCESS;
} | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/frame/src/frame_msg.c | C | unknown | 1,561 |
/*
* 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.
*/
#ifndef REC_WRAPPER_H
#define REC_WRAPPER_H
#include "rec.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief REC_read, REC_write read/write callback
*
* @param ctx [IN] TLS context
* @param buf [IN/OUT] Read/write buffer
* @param bufLen [IN/OUT] Reads and writes len bytes
* @param bufSize [IN] Maximum buffer size
* @param userData [IN/OUT] User-defined data
*/
typedef void (*WrapperFunc)(TLS_Ctx *ctx, uint8_t *buf, uint32_t *bufLen, uint32_t bufSize, void* userData);
typedef struct {
HITLS_HandshakeState ctrlState;
REC_Type recordType;
bool isRecRead;
void *userData;
WrapperFunc func;
} RecWrapper;
void RegisterWrapper(RecWrapper wrapper);
void ClearWrapper(void);
#ifdef __cplusplus
}
#endif
#endif // REC_WRAPPER_H | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/func_wrapper/include/rec_wrapper.h | C | unknown | 1,315 |
/*
* 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 "securec.h"
#include "hitls_build.h"
#include "rec_crypto.h"
#include "hs_ctx.h"
#include "stub_replace.h"
#include "rec_wrapper.h"
#define MAX_BUF 16384
static RecWrapper g_recWrapper;
static bool g_enableWrapper;
static __thread uint8_t g_locBuffer[MAX_BUF] = { 0 };
extern int32_t __real_REC_Read(TLS_Ctx *ctx, REC_Type recordType, uint8_t *data, uint32_t *readLen, uint32_t num);
extern int32_t __real_REC_Write(TLS_Ctx *ctx, REC_Type recordType, const uint8_t *data, uint32_t num);
extern int32_t __wrap_REC_Read(TLS_Ctx *ctx, REC_Type recordType, uint8_t *data, uint32_t *readLen, uint32_t num)
{
return __real_REC_Read(ctx, recordType, data, readLen, num);
}
extern int32_t __wrap_REC_Write(TLS_Ctx *ctx, REC_Type recordType, const uint8_t *data, uint32_t num)
{
// Length that can be manipulated in wrapper
uint32_t manipulateLen = num;
if (!g_enableWrapper || g_recWrapper.isRecRead || g_recWrapper.recordType != recordType) {
return __real_REC_Write(ctx, recordType, data, manipulateLen);
}
if (g_recWrapper.recordType == REC_TYPE_HANDSHAKE && ctx->hsCtx->state != g_recWrapper.ctrlState) {
return __real_REC_Write(ctx, recordType, data, manipulateLen);
}
(void)memcpy_s(g_locBuffer, MAX_BUF, data, num);
// The value of manipulateLen can be greater than or smaller than num
g_recWrapper.func(ctx, g_locBuffer, &manipulateLen, MAX_BUF, g_recWrapper.userData);
if (ctx->hsCtx->bufferLen < manipulateLen) {
uint8_t *tmp = BSL_SAL_Realloc(ctx->hsCtx->msgBuf, manipulateLen, ctx->hsCtx->bufferLen);
if (tmp == NULL) {
return HITLS_MEMALLOC_FAIL;
}
ctx->hsCtx->bufferLen = manipulateLen;
ctx->hsCtx->msgBuf = tmp;
}
if (recordType == REC_TYPE_HANDSHAKE) {
(void)memcpy_s(ctx->hsCtx->msgBuf, ctx->hsCtx->bufferLen, g_locBuffer, manipulateLen);
ctx->hsCtx->msgLen = manipulateLen;
}
int32_t ret = __real_REC_Write(ctx, recordType, g_locBuffer, manipulateLen);
if (recordType == REC_TYPE_HANDSHAKE && ret == HITLS_SUCCESS) {
ctx->hsCtx->msgOffset = manipulateLen - num;
}
return ret;
}
RecCryptoFunc g_aeadFuncs;
RecCryptoFunc g_cbcFuncs;
RecCryptoFunc g_plainFuncs;
void FRAME_InitRecCrypto(void)
{
g_plainFuncs = *RecGetCryptoFuncs(NULL);
RecConnSuitInfo info = {0};
info.cipherType = HITLS_AEAD_CIPHER;
g_aeadFuncs = *RecGetCryptoFuncs(&info);
info.cipherType = HITLS_CBC_CIPHER;
g_cbcFuncs = *RecGetCryptoFuncs(&info);
}
static RecCryptoFunc *RecGetOriginCryptFuncs(RecConnSuitInfo *suiteInfo)
{
if (suiteInfo == NULL) {
return &g_plainFuncs;
}
switch (suiteInfo->cipherType) {
case HITLS_AEAD_CIPHER:
return &g_aeadFuncs;
case HITLS_CBC_CIPHER:
return &g_cbcFuncs;
default:
return &g_plainFuncs;
}
return &g_plainFuncs;
}
static int32_t WrapperDecryptFunc(TLS_Ctx *ctx, RecConnState *state, const REC_TextInput *cryptMsg,
uint8_t *data, uint32_t *dataLen)
{
int32_t ret = RecGetOriginCryptFuncs(state->suiteInfo)->decrypt(ctx, state, cryptMsg, data, dataLen);
if (ret == HITLS_SUCCESS && IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask) && g_recWrapper.isRecRead) {
if (g_recWrapper.recordType != cryptMsg->type) {
return ret;
}
if (g_recWrapper.recordType == REC_TYPE_HANDSHAKE) {
if (ctx->hsCtx == NULL || ctx->hsCtx->state != g_recWrapper.ctrlState) {
return ret;
}
}
g_recWrapper.func(ctx, data, dataLen, *dataLen, g_recWrapper.userData);
}
return ret;
}
static int32_t WrapperDecryptPostProcess(TLS_Ctx *ctx, RecConnSuitInfo *suitInfo, REC_TextInput *cryptMsg,
uint8_t *data, uint32_t *dataLen)
{
int32_t ret = RecGetOriginCryptFuncs(suitInfo)->decryptPostProcess(ctx, suitInfo, cryptMsg, data, dataLen);
if (ret == HITLS_SUCCESS && g_recWrapper.isRecRead) {
if (g_recWrapper.recordType != cryptMsg->type) {
return ret;
}
if (g_recWrapper.recordType == REC_TYPE_HANDSHAKE) {
if (ctx->hsCtx == NULL || ctx->hsCtx->state != g_recWrapper.ctrlState) {
return ret;
}
}
g_recWrapper.func(ctx, data, dataLen, *dataLen, g_recWrapper.userData);
}
return ret;
}
static int32_t WrapperCalPlantextBufLenFunc(TLS_Ctx *ctx, RecConnSuitInfo *suitInfo,
uint32_t ciphertextLen, uint32_t *offset, uint32_t *plainLen)
{
(void)ctx;
(void)suitInfo;
(void)ciphertextLen;
(void)offset;
*plainLen = 16384 + 2048;
return HITLS_SUCCESS;
}
static RecCryptoFunc *Stub_RecCrypto(RecConnSuitInfo *suiteInfo)
{
static RecCryptoFunc recCryptoFunc = { 0 };
recCryptoFunc = *RecGetOriginCryptFuncs(suiteInfo);
recCryptoFunc.calPlantextBufLen = WrapperCalPlantextBufLenFunc;
recCryptoFunc.decrypt = WrapperDecryptFunc;
recCryptoFunc.decryptPostProcess = WrapperDecryptPostProcess;
return &recCryptoFunc;
}
FuncStubInfo g_stubRecFuncs;
void RegisterWrapper(RecWrapper wrapper)
{
if (g_enableWrapper) {
ClearWrapper();
}
FRAME_InitRecCrypto();
STUB_Init();
STUB_Replace(&g_stubRecFuncs, (void *)RecGetCryptoFuncs, (void *)Stub_RecCrypto);
g_enableWrapper = true;
g_recWrapper = wrapper;
}
void ClearWrapper(void)
{
STUB_Reset(&g_stubRecFuncs);
g_enableWrapper = false;
} | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/func_wrapper/src/rec_wrapper.c | C | unknown | 6,020 |
/*
* 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.
*/
#ifndef FRAME_MSG_H
#define FRAME_MSG_H
#include <stdint.h>
#include "hs_msg.h"
#include "rec.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Used to determine the field status during packing */
typedef enum {
/* field is missing. If this state is set, the field will not be packed into the buffer during packing */
MISSING_FIELD = 0,
/* field initial status. The field status in the parsed msg structure is filled with the value. */
INITIAL_FIELD,
/* Specifies the value of the field. If the field content is modified, set the status to the value. */
ASSIGNED_FIELD,
/* Repeat the field. During the packing, the field will be packed again */
DUPLICATE_FIELD,
/* Only one byte length is packed and used to construct abnormal messages.
It is used for two or more bytes of fields (such as the cipher suite length). */
SET_LEN_TO_ONE_BYTE,
} FieldState;
// uint64_t data with status
typedef struct {
FieldState state; /* Field state */
uint64_t data; /* Content */
} FRAME_Integer;
// uint8_t data with status
typedef struct {
FieldState state; /* Field state */
uint32_t size; /* Number of data records */
uint8_t *data; /* Content */
} FRAME_Array8;
// uint16_t data with status
typedef struct {
FieldState state; /* Field state */
uint32_t size; /* Number of data records */
uint16_t *data; /* Content */
} FRAME_Array16;
typedef struct {
FieldState exState; /* extension Field state */
FRAME_Integer exType; /* extension type */
FRAME_Integer exLen; /* Full length of extension */
FRAME_Integer exDataLen; /* Length of extension content */
FRAME_Array8 exData; /* extension content */
} FRAME_HsExtArray8;
// The handshake extension with state carries a variable-length array with uint16_t
// such as the signature algorithm extension
typedef struct {
FieldState exState; /* extension Field state */
FRAME_Integer exType; /* extension type */
FRAME_Integer exLen; /* Full length of extension */
FRAME_Integer exDataLen; /* Length of extension content */
FRAME_Array16 exData; /* extension content */
} FRAME_HsExtArray16;
typedef struct {
FieldState state; /* Field state */
FRAME_Integer group; /* group */
FRAME_Integer keyExchangeLen; /* key exchange size */
FRAME_Array8 keyExchange;
} FRAME_HsKeyShareEntry;
typedef struct {
FieldState state; /* Field state */
uint32_t size; /* Number of entries */
FRAME_HsKeyShareEntry *data; /* key shareContent */
} FRAME_HsArrayKeyShare;
typedef struct {
FieldState exState; /* extension Field state */
FRAME_Integer exType; /* extension type */
FRAME_Integer exLen; /* Full length of extension */
FRAME_Integer exKeyShareLen; /* keyshare Array length */
FRAME_HsArrayKeyShare exKeyShares; /* keyshare array content */
} FRAME_HsExtKeyShare;
typedef struct {
FieldState state; /* Field state */
FRAME_Integer identityLen;
FRAME_Array8 identity;
FRAME_Integer obfuscatedTicketAge;
} FRAME_HsPskIdentity;
typedef struct {
FieldState state; /* Field state */
uint32_t size; /* Number of identities */
FRAME_HsPskIdentity *data; /* identity Content */
} FRAME_HsArrayPskIdentity;
typedef struct {
FieldState state; /* Field state */
FRAME_Integer binderLen;
FRAME_Array8 binder;
} FRAME_HsPskBinder;
typedef struct {
FieldState state; /* Field state */
uint32_t size; /* Number of identities */
FRAME_HsPskBinder *data; /* identity Content */
} FRAME_HsArrayPskBinder;
typedef struct {
FieldState exState; /* extension Field state */
FRAME_Integer exType; /* extension type */
FRAME_Integer exLen; /* Full length of extension */
FRAME_Integer identitySize;
FRAME_HsArrayPskIdentity identities;
FRAME_Integer binderSize;
FRAME_HsArrayPskBinder binders;
} FRAME_HsExtOfferedPsks;
typedef struct {
FieldState exState; /* extension Field state */
FRAME_Integer exType; /* extension type */
FRAME_Integer exLen; /* Full length of extension */
FRAME_Array8 list; /* CA list */
FRAME_Integer listSize; /* CA list length */
} FRAME_HsExtCaList;
typedef struct {
FRAME_Integer version; /* Version number */
FRAME_Array8 randomValue; /* Random number */
FRAME_Integer sessionIdSize; /* session ID length */
FRAME_Array8 sessionId; /* session ID */
FRAME_Integer cookiedLen; /* Cookie length (for DTLS) */
FRAME_Array8 cookie; /* cookie(for DTLS) */
FRAME_Integer cipherSuitesSize; /* cipher suite length */
FRAME_Array16 cipherSuites; /* cipher suite */
FRAME_Integer compressionMethodsLen; /* compression method length */
FRAME_Array8 compressionMethods; /* compression method */
FieldState extensionState; /* Indicates whether the extension is packed */
FRAME_Integer extensionLen; /* Total length of the extension */
FRAME_HsExtArray8 pointFormats;
FRAME_HsExtArray16 supportedGroups;
FRAME_HsExtArray16 signatureAlgorithms;
FRAME_HsExtArray8 encryptThenMac;
FRAME_HsExtArray8 extendedMasterSecret;
FRAME_HsExtArray8 secRenego; /* security renegotiation */
FRAME_HsExtArray8 sessionTicket;
FRAME_HsExtArray8 serverName; /* sni */
FRAME_HsExtArray8 alpn; /* alpn */
FRAME_HsExtArray8 tls13Cookie; /* tls1.3 cookie */
FRAME_HsExtKeyShare keyshares; /* tls1.3 key share */
FRAME_HsExtArray8 pskModes; /* tls1.3 psk exchange mode */
FRAME_HsExtArray16 supportedVersion; /* tls1.3 support version */
FRAME_HsExtOfferedPsks psks; /* tls1.3 psk */
FRAME_HsExtCaList caList;
} FRAME_ClientHelloMsg;
typedef struct {
FieldState exState; /* extension Field state */
FRAME_Integer exType; /* extension type */
FRAME_Integer exLen; /* Full length of extension */
FRAME_Integer data; /* extension content */
} FRAME_HsExtUint16;
typedef struct {
FieldState exState; /* extension Field state */
FRAME_Integer exType; /* extension type */
FRAME_Integer exLen; /* Full length of extension */
FRAME_HsKeyShareEntry data; /* extension content */
} FRAME_HsExtServerKeyShare;
typedef struct {
FRAME_Integer version; /* Version number */
FRAME_Array8 randomValue; /* Random number */
FRAME_Integer sessionIdSize; /* session ID length */
FRAME_Array8 sessionId; /* session ID */
FRAME_Integer cipherSuite;
FRAME_Integer compressionMethod;
FRAME_Integer extensionLen; /* Full length of the extended field */
FRAME_HsExtArray8 pointFormats;
FRAME_HsExtArray8 extendedMasterSecret;
FRAME_HsExtArray8 secRenego; /* security renegotiation */
FRAME_HsExtArray8 sessionTicket; /* sessionTicket */
FRAME_HsExtArray8 serverName; /* sni */
FRAME_HsExtArray8 alpn; /* alpn */
FRAME_HsExtUint16 supportedVersion; /* tls1.3 supported version */
FRAME_HsExtServerKeyShare keyShare; /* tls1.3 key share */
FRAME_HsExtUint16 pskSelectedIdentity; /* tls1.3 psk extension */
FRAME_HsExtArray8 tls13Cookie; /* tls1.3 cookie */
FRAME_HsExtArray8 encryptThenMac;
} FRAME_ServerHelloMsg;
typedef struct {
FRAME_Array8 extra; /* server hello done is a null message. This field is used to construct abnormal messages */
} FRAME_ServerHelloDoneMsg;
typedef struct FrameCertItem_ {
FieldState state; /* Certificate Field state */
FRAME_Integer certLen; /* Certificate length */
FRAME_Array8 cert; /* Certificate Content */
FRAME_Integer extensionLen; /* Certificate extension length. only for tls1.3 */
FRAME_Array8 extension; /* Certificate extension Content. only for tls1.3 */
struct FrameCertItem_ *next;
} FrameCertItem;
typedef struct {
FRAME_Integer certsLen; /* Certificate total length */
FrameCertItem *certItem; /* Certificate */
FRAME_Array8 certificateReqCtx; /* For TLS 1.3 */
FRAME_Integer certificateReqCtxSize; /* For TLS 1.3 */
} FRAME_CertificateMsg;
typedef struct {
FRAME_Integer curveType; /* Curve type */
FRAME_Integer namedcurve; /* Named curve */
FRAME_Integer pubKeySize; /* ecdh public key size */
FRAME_Array8 pubKey; /* ecdh public key content */
FRAME_Integer signAlgorithm; /* Signature hash algorithm, for TLS1.2 and DTLS1.2 */
FRAME_Integer signSize; /* Signature length */
FRAME_Array8 signData; /* Signature Content */
} FRAME_ServerEcdh;
typedef struct {
FRAME_Integer plen;
FRAME_Array8 p;
FRAME_Integer glen;
FRAME_Array8 g;
FRAME_Integer pubKeyLen; /* dh public key */
FRAME_Array8 pubKey; /* dH public key content */
FRAME_Integer signAlgorithm; /* Signature hash algorithm, for TLS1.2 and DTLS1.2 */
FRAME_Integer signSize; /* Signature length */
FRAME_Array8 signData; /* Signature content */
} FRAME_ServerDh;
typedef struct {
union {
FRAME_ServerEcdh ecdh;
FRAME_ServerDh dh;
} keyEx;
} FRAME_ServerKeyExchangeMsg;
typedef struct {
FRAME_Integer pubKeySize; /* Key exchange data length */
FRAME_Array8 pubKey; /* Key exchange data */
} FRAME_ClientKeyExchangeMsg;
typedef struct {
FieldState state; /* Field state */
FRAME_Integer certTypesSize; /* certificate type length */
FRAME_Array8 certTypes; /* Certificate type list */
FRAME_Integer signatureAlgorithmsSize; /* signature algorithm length */
FRAME_Array16 signatureAlgorithms; /* signature algorithm list */
FRAME_Integer reserved; /* Four-byte alignment */
FRAME_Integer distinguishedNamesSize; /* DN length */
FRAME_Array8 distinguishedNames; /* DN */
FRAME_Array8 certificateReqCtx; /* For TLS 1.3 */
FRAME_Integer certificateReqCtxSize; /* For TLS 1.3 */
FRAME_Integer exMsgLen;
} FRAME_CertificateRequestMsg;
/* Used to transmit certificate verification packets. */
typedef struct {
FRAME_Integer signHashAlg; /* Signature hash algorithm, used for TLS1.2 and DTLS1.2 */
FRAME_Integer signSize; /* Length of the signature data */
FRAME_Array8 sign; /* Signature data */
} FRAME_CertificateVerifyMsg;
typedef struct {
FRAME_Integer ticketLifetime;
FRAME_Integer ticketAgeAdd;
FRAME_Integer ticketNonceSize;
FRAME_Array8 ticketNonce;
FRAME_Integer ticketSize;
FRAME_Array8 ticket;
FRAME_Integer extensionLen; /* Total length of the extension */
} FRAME_NewSessionTicketMsg;
/* Transmit the Finish message */
typedef struct {
FRAME_Array8 verifyData; /* verify data Content */
} FRAME_FinishedMsg;
typedef struct {
FRAME_Integer type; /* Handshake type */
FRAME_Integer length; /* Length of the handshake message */
/* Sequence number of DTLS handshake messages. Increases by 1 each time a new handshake message is sent.
*Does not increase for retransmission */
FRAME_Integer sequence;
FRAME_Integer fragmentOffset; /* Fragment offset of DTLS handshake message */
FRAME_Integer fragmentLength; /* DTLS Handshake message Fragment Length */
union {
FRAME_ClientHelloMsg clientHello;
FRAME_ServerHelloMsg serverHello;
FRAME_CertificateMsg certificate;
FRAME_ServerKeyExchangeMsg serverKeyExchange;
FRAME_CertificateRequestMsg certificateReq;
FRAME_ServerHelloDoneMsg serverHelloDone;
FRAME_ClientKeyExchangeMsg clientKeyExchange;
FRAME_CertificateVerifyMsg certificateVerify;
FRAME_NewSessionTicketMsg newSessionTicket;
FRAME_FinishedMsg finished;
} body;
} FRAME_HsMsg;
typedef struct {
uint8_t level; /* To be deleted. The member is not processed because some code uses it */
uint8_t description; /* To be deleted. The member is not processed because some code uses it */
FRAME_Integer alertLevel; /* Alert level: See ALERT_Level */
FRAME_Integer alertDescription; /* Alert description: See ALERT_Description */
FRAME_Array8 extra; /* This field is used to construct abnormal messages */
} FRAME_AlertMsg;
typedef struct {
uint8_t type; /* To be deleted. The member is not processed because some code uses it */
FRAME_Integer ccsType; /* ccs type */
FRAME_Array8 extra; /* This field is used to construct abnormal messages */
} FRAME_CcsMsg;
typedef struct {
char *buffer; /* To be deleted. The member is not processed because some code uses it */
uint32_t len; /* To be deleted. The member is not processed because some code uses it */
FRAME_Array8 appData; /* app data */
} FRAME_AppMsg;
typedef struct {
uint8_t type; /* To be deleted. The member is not processed because some code uses it */
uint8_t reverse; /* To be deleted. The member is not processed because some code uses it */
uint16_t version; /* To be deleted. The member is not processed because some code uses it */
uint16_t bodyLen; /* To be deleted. The member is not processed because some code uses it */
BSL_UIO_TransportType transportType;
uint64_t epochSeq; /* To be deleted. The member is not processed because some code uses it */
FRAME_Integer recType; /* record the message type */
FRAME_Integer recVersion; /* record version */
FRAME_Integer epoch; /* Counter value that increases each time the password status changes.
This counter is used by DTLS */
FRAME_Integer sequence; /* Record message sequence number, for DTLS */
FRAME_Integer length; /* Length of the record message */
union {
HS_Msg handshakeMsg; /* To be deleted. The member is not processed because some code uses it */
FRAME_HsMsg hsMsg;
FRAME_AlertMsg alertMsg;
FRAME_CcsMsg ccsMsg;
FRAME_AppMsg appMsg;
} body;
uint8_t *buffer; /* To be deleted. The member is not processed because some code uses it */
uint32_t len; /* To be deleted. The member is not processed because some code uses it */
} FRAME_Msg;
/* Used to transfer the message type. The framework packs and parses the corresponding message based on the field value
* of this structure */
typedef struct {
uint16_t versionType;
/* To ensure that the memory can be released normally, a value is assigned to the member during parsing */
REC_Type recordType;
/* To ensure that the memory can be released normally, a value is assigned to the member during parsing */
HS_MsgType handshakeType;
HITLS_KeyExchAlgo keyExType;
BSL_UIO_TransportType transportType;
} FRAME_Type;
/**
* @brief Generate a TLS record byte stream based on the specified parameter of frameType
* and the field content of the msg structure and save the stream to the buffer
* @param frameType [IN] Specified packing parameters
* @param msg [IN] Message structure
* @param buf [OUT] Returned handshake message
* @param bufLen [IN] Input buffer size
* @param usedLen [OUT] Returned message length
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_PackMsg(FRAME_Type *frameType, const FRAME_Msg *msg, uint8_t *buffer, uint32_t bufLen, uint32_t *usedLen);
/**
* @brief Generate tls13 handshake message according to type
* @param type [IN] Specified packing parameters
* @param buf [OUT] Returned handshake message
* @param bufLen [IN] Input buffer size
* @param usedLen [OUT] Returned message length
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_GetTls13DisorderHsMsg(HS_MsgType type, uint8_t *buffer, uint32_t bufLen, uint32_t *usedLen);
/**
* @brief Generate a TLS record body byte stream based on the specified parameter of frameType
* and the field content of the msg structure and save the byte stream to the buffer.
*
* @param frameType [IN] Specified packing parameters
* @param msg [IN] Message structure
* @param buffer [OUT] Returned handshake message
* @param bufLen [IN] Input buffer size
* @param usedLen [OUT] Returned message length
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_PackRecordBody(FRAME_Type *frameType, const FRAME_Msg *msg,
uint8_t *buffer, uint32_t bufLen, uint32_t *usedLen);
/**
* @brief Parse the MSG structure based on the specified parameter of frameType and the TLS record byte stream.
* Only the record message header is parsed
*
* @param frameType [IN] Specified parsing parameter, mainly versionType
* @param buffer [IN] TLS record byte stream
* @param bufLen [IN] Input buffer size
* @param msg [OUT] Parsed Message structure
* @param parseLen [OUT] Length of the parsed message
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_ParseMsgHeader(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_Msg *msg, uint32_t *parseLen);
/**
* @brief parse TLS record header
*
* @param buffer [IN] TLS record byte stream
* @param bufferLen [IN] Input buffer size
* @param msg [OUT] Parsed Message structure
* @param headerLen [OUT] Length of the parsed message
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_ParseTLSRecordHeader(const uint8_t *buffer, uint32_t bufferLen,
FRAME_Msg *msg, uint32_t *parseLen);
/**
* @brief Parse the body of the TLS non-handshake record
*
* @param buffer [IN] TLS record byte stream
* @param bufferLen [IN] Input buffer size
* @param msg [OUT] Parsed Message structure
* @param headerLen [OUT] Length of the parsed message
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_ParseTLSNonHsRecordBody(const uint8_t *buffer, uint32_t bufferLen,
FRAME_Msg *msg, uint32_t *parseLen);
/**
* @brief Parse the TLS non-handshake record
*
* @param buffer [IN] TLS record byte stream
* @param bufferLen [IN] Input buffer size
* @param msg [OUT] Parsed Message structure
* @param headerLen [OUT] Length of the parsed message
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_ParseTLSNonHsRecord(const uint8_t *buffer, uint32_t bufferLen,
FRAME_Msg *msg, uint32_t *parseLen);
/**
* @brief Parse the record of the handshake type
*
* @param buffer [IN] TLS record byte stream
* @param bufferLen [IN] Input buffer size
* @param msg [OUT] Parsed Message structure
* @param headerLen [OUT] Length of the parsed message
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_ParseHsRecord(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufferLen,
FRAME_Msg *msg, uint32_t *parseLen);
/**
* @brief Parse the MSG structure based on the specified parameter of frameType and the TLS record byte stream.
* Only the record message body is parsed
*
* @attention Invoke the Frame_ParseMsgHeader interface to parse the message header
*
* @param frameType [IN] Specified parsing parameters, mainly versionType and keyExType
* @param buffer [IN] TLS record byte stream
* @param bufLen [IN] Input buffer size
* @param msg [OUT] Parsed Message structure
* @param parseLen [OUT] Length of the parsed message
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_ParseMsgBody(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_Msg *msg, uint32_t *parseLen);
/**
* @brief Parse the message into the msg structure based on the specified parameter of frameType and
* the TLS record byte stream
*
* @param frameType [IN] Specified parsing parameters, mainly versionType and keyExType
* @param buffer [IN] TLS record byte stream
* @param bufLen [IN] Input buffer size
* @param msg [OUT] Parsed Message structure
* @param parseLen [OUT] Length of the parsed message
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_ParseMsg(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_Msg *msg, uint32_t *parseLen);
/**
* @brief Clear the memory allocated during parsing
*
* @param frameType [IN] Specified parsing parameters, mainly versionType and keyExType
* @param msg [IN] Message structure
*/
void FRAME_CleanMsg(FRAME_Type *frameType, FRAME_Msg *msg);
/**
* @brief Clear the memory allocated during parsing
*
* @param recType [IN] Specified record type
* @param msg [IN] Message structure
*/
void FRAME_CleanNonHsRecord(REC_Type recType, FRAME_Msg *msg);
/**
* @brief Obtain a structure of a specified message type
*
* @attention This interface does not set the callback function. User need to set the callback interface first
* This interface obtains only the HANDSHAKE,Change_CIPHER_SPEC, and ALERT messages
* The existing framework does not support parsing of encrypted finished messages.
* Therefore, the finished messages cannot be obtained.
*
* @param frameType [IN] Specified message parameters
* @param msg [OUT] Returned Message structure
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_GetDefaultMsg(FRAME_Type *frameType, FRAME_Msg *msg);
/**
* @brief Modify a message field
* This method is used to modify the contents of integer fields in a message, such as the message type,
* version number, and field length
*
* @param data [IN] Data content
* @param frameInteger [IN/OUT] IN original field; OUT New field
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_ModifyMsgInteger(const uint64_t data, FRAME_Integer *frameInteger);
/**
* @brief Modify the message field content. User can increase or decrease the length of the message field and modify
* the field content.
* (This implementation performs deep copy of the data content.)
* This method is used to modify the content of the uint8_t array field in a message, such as the session ID,
* cookie, and signature data
*
* @param data [IN] Data content
* @param dataLen [IN] Number of data records
* @param frameArray [IN/OUT] IN original field; OUT New field
* @param frameArrayLen [IN/OUT] IN Original field length; Length of the new field in the OUT field. This parameter
* can be none
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_ModifyMsgArray8(const uint8_t *data, uint32_t dataLen,
FRAME_Array8 *frameArray, FRAME_Integer *frameArrayLen);
/**
* @brief Retain the original handshake message field content and add a string of data data to the end of the data.
* (This implementation performs deep copy of the data content.)
* This method is used to modify the content of the uint8_t array field in a message, such as the session ID,
* cookie, and signature data.
*
* @param data [IN] Data content
* @param dataLen [IN] Number of data records
* @param frameArray [IN/OUT] IN original field; OUT New field
* @param frameArrayLen [IN/OUT] IN Original field length; Length of the new field in the OUT field. This parameter
* can be none
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_AppendMsgArray8(const uint8_t *data, uint32_t dataLen,
FRAME_Array8 *frameArray, FRAME_Integer *frameArrayLen);
/**
* @brief Modify the message field content. User can increase or decrease the length of the message field and modify
* the field content.
* (This implementation performs deep copy of the data content.)
* This method is used to modify the uint16_t array field in a message, for example, cipher suite and support
* group extension
*
* @param data [IN] Data content
* @param dataLen [IN] Number of data records
* @param frameArray [IN/OUT] IN original field; OUT New field
* @param frameArrayLen [IN/OUT] IN Original field length; Length of the new field in the OUT field. This parameter
* can be none
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_ModifyMsgArray16(const uint16_t *data, uint32_t dataLen,
FRAME_Array16 *frameArray, FRAME_Integer *frameArrayLen);
/**
* @brief Retain the original handshake message field content and add a string of data data to the end of the data.
* (This implementation performs deep copy of the data content.)
* This method is used to modify the uint16_t array field in a message, for example, the cipher suite and
* support group extension
*
* @param data [IN] Data content
* @param dataLen [IN] Number of data records
* @param frameArray [IN/OUT] IN original field; OUT New field
* @param frameArrayLen [IN/OUT] IN Original field length; Length of the new field in the OUT field. This parameter
* can be none
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_AppendMsgArray16(const uint16_t *data, uint32_t dataLen,
FRAME_Array16 *frameArray, FRAME_Integer *frameArrayLen);
#ifdef __cplusplus
}
#endif
#endif // FRAME_MSG_H | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/include/frame_msg.h | C | unknown | 26,690 |
/*
* 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.
*/
#ifndef FRAME_TLS_H
#define FRAME_TLS_H
#include "bsl_uio.h"
#include "hs_ctx.h"
#include "frame_msg.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct FRAME_LinkObj_ FRAME_LinkObj;
typedef struct FRAME_CertInfo_ FRAME_CertInfo;
typedef struct SSL_LINK_OBJ_ SSL_LINK_OBJ;
HITLS_Ctx *FRAME_CreateDefaultDtlsObj(void);
/**
* @brief Load the certificate to the connection configuration context resource.
*
* @return If the value 0 is returned, the certificate is loaded successfully.
* Otherwise, the certificate fails to be loaded
*/
int32_t FRAME_LoadCertToConfig(HITLS_Config *config, const char *verifyCert, const char *chainCert, const char *eeCert,
const char *prvKey);
/**
* @brief Create a TLCP connection.
This interface loads the certificate, applies for SSL CTX, and creates the underlying UIO
*
* @return Return the connection object, which can be used by the test framework to perform operations
*/
FRAME_LinkObj *FRAME_CreateTLCPLink(HITLS_Config *config, BSL_UIO_TransportType type, bool isClient);
/**
* @brief Create an SSL connection. This interface will complete the SSL CTX application,
bottom-layer UIO creation, and load the default certificate
*
* @return Return the connection object, which can be used by the test framework to perform operations
*/
FRAME_LinkObj *FRAME_CreateLink(HITLS_Config *config, BSL_UIO_TransportType type);
// This interface is used to create an SSL connection.
// The SSL CTX application and bottom-layer UIO creation are completed. The default certificate is not loaded.
FRAME_LinkObj *FRAME_CreateLinkEx(HITLS_Config *config, BSL_UIO_TransportType type);
FRAME_LinkObj *FRAME_CreateLinkWithCert(
HITLS_Config *config, BSL_UIO_TransportType type, const FRAME_CertInfo *certInfo);
/**
* @brief Create an SSL connection with configurable certificate loading.
* This interface will complete the SSL CTX application and bottom-layer UIO creation.
* The setCertFlag parameter controls whether to load the default certificate.
*
* @param config [IN] TLS configuration
* @param type [IN] Transport type
* @param setCertFlag [IN] Whether to load default certificate
*
* @return Return the connection object, which can be used by the test framework to perform operations
*/
FRAME_LinkObj *FRAME_CreateLinkBase(HITLS_Config *config, BSL_UIO_TransportType type, bool setCertFlag);
/**
* @brief Releases an SSL connection, which corresponds to Frame_CreateLink
*
* @return
*/
void FRAME_FreeLink(FRAME_LinkObj *linkObj);
/**
* @brief Obtain the TLS ctx from the Frame_LinkObj to facilitate the test of HiTLS APIs because HiTLS APIs use
* HITLS_Ctx as the input parameter.
* Do not call HiTLS_Free to release the return values of this API.
* The values will be released in the Frame_FreeLink.
*
* @return Return the CTX object of the TLS
*/
HITLS_Ctx *FRAME_GetTlsCtx(const FRAME_LinkObj *linkObj);
/*
* @brief Simulate link establishment or simulate an SSL link in a certain state.
* For example, if state is TRY_RECV_SERVER_HELLO, the client is ready to receive the SERVER Hello message,
* and The server link is just sent SERVER_HELLO.
*
* @return If the operation is successful, HITLS_SUCCESS is returned.
*/
int32_t FRAME_CreateConnection(FRAME_LinkObj *client, FRAME_LinkObj *server, bool isClient, HITLS_HandshakeState state);
/**
* @brief Simulate renegotiation
* @attention Internally invokes HITLS_Write and HITLS_Read to perform renegotiation.
* Ensure that linkA is the initiator of the renegotiation request and
* linkB is the receiver of the renegotiation request
*
* @param server [IN] Initiator of the renegotiation request
* @param client [IN] Recipient of the renegotiation request
*
* @return If the operation is successful, HITLS_SUCCESS is returned
*/
int32_t FRAME_CreateRenegotiationServer(FRAME_LinkObj *server, FRAME_LinkObj *client);
/*
* @ingroup Simulate connection establishment or an SSL connection in a certain state.
* For example, if the value of state is TRY_RECV_SERVER_HELLO,
* the client is ready to receive the SERVER Hello message,
* and the server connection is SERVER_HELLO has just been sent.
*
*
* @return If the operation is successful, HITLS_SUCCESS is returned
*/
int32_t FRAME_CreateRenegotiationState(FRAME_LinkObj *client, FRAME_LinkObj *server, bool isClient, HITLS_HandshakeState state);
/**
* @brief Simulate renegotiation
* @attention Internally invokes HITLS_Write and HITLS_Read to perform renegotiation.
* Ensure that linkA is the initiator of the renegotiation request and
* linkB is the receiver of the renegotiation request
*
* @param linkA [IN] Initiator of the renegotiation request
* @param linkB [IN] Recipient of the renegotiation request
*
* @return If the operation is successful, HITLS_SUCCESS is returned
*/
int32_t FRAME_CreateRenegotiation(FRAME_LinkObj *linkA, FRAME_LinkObj *linkB);
/**
* @brief Obtain a message from the I/O receiving buffer of the connection
*
* @return If the operation is successful, HITLS_SUCCESS is returned
*/
int32_t FRAME_GetLinkRecMsg(FRAME_LinkObj *link, uint8_t *buffer, uint32_t len, uint32_t *msgLen);
/**
* @brief Obtain a message from the I/O sending buffer of the connection.
*
* @return If the operation is successful, HITLS_SUCCESS is returned.
*/
int32_t FRAME_GetLinkSndMsg(FRAME_LinkObj *link, uint8_t *buffer, uint32_t len, uint32_t *msgLen);
/**
* @brief Generate a framework message based on the content in the message buffer
*
* @return Return the Constructed Frame_Msg object
*/
FRAME_Msg *FRAME_GenerateMsgFromBuffer(const FRAME_LinkObj *linkObj, const uint8_t *buffer, uint32_t len);
/**
* @brief Send data from connection A to connection B
*
* @return If the operation is successful, HITLS_SUCCESS is returned
*/
int32_t FRAME_TrasferMsgBetweenLink(FRAME_LinkObj *linkA, FRAME_LinkObj *linkB);
/**
* @brief Initialize the framework
*/
void FRAME_Init(void);
/**
* @brief Deinitialize the framework
*/
void FRAME_DeInit(void);
#ifdef __cplusplus
}
#endif
#endif // FRAME_TLS_H
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/include/frame_tls.h | C | unknown | 6,723 |
/*
* 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.
*/
#ifndef HLT_H
#define HLT_H
#include <stddef.h>
#include "hlt_type.h"
#ifdef __cplusplus
extern "C" {
#endif
void HLT_ConfigTimeOut(const char* timeout);
void HLT_UnsetTimeOut();
// Create a process
HLT_Process* InitSrcProcess(TLS_TYPE tlsType, char* srcDomainPath);
HLT_Process* InitPeerProcess(TLS_TYPE tlsType, HILT_TransportType connType, int port, bool isBlock);
#define HLT_InitLocalProcess(tlsType) InitSrcProcess(tlsType, __FILE__)
#define HLT_CreateRemoteProcess(tlsType) InitPeerProcess(tlsType, NONE_TYPE, 0, 0)
#define HLT_LinkRemoteProcess(tlsType, connType, port, isBlock) InitPeerProcess(tlsType, connType, port, isBlock)
// Clear all process resources
void HLT_FreeAllProcess(void);
int HLT_FreeResFormSsl(const void *ssl);
// Create a local data connection
HLT_FD HLT_CreateDataChannel(HLT_Process* process1, HLT_Process* process2, DataChannelParam channelParam);
int HLT_DataChannelConnect(DataChannelParam* dstChannelParam);
pthread_t HLT_DataChannelAccept(DataChannelParam* channelParam);
void HLT_CloseFd(int fd, int linkType);
// Interface for setting connection information
int HLT_SetVersion(HLT_Ctx_Config* ctxConfig, uint16_t minVersion, uint16_t maxVersion);
int HLT_SetSecurityLevel(HLT_Ctx_Config *ctxConfig, int32_t level);
int HLT_SetRenegotiationSupport(HLT_Ctx_Config* ctxConfig, bool support);
int HLT_SetLegacyRenegotiateSupport(HLT_Ctx_Config* ctxConfig, bool support);
int HLT_SetClientRenegotiateSupport(HLT_Ctx_Config* ctxConfig, bool support);
int HLT_SetEmptyRecordsNum(HLT_Ctx_Config *ctxConfig, uint32_t emptyNum);
int HLT_SetFlightTransmitSwitch(HLT_Ctx_Config *ctxConfig, bool support);
int HLT_SetKeyLogCb(HLT_Ctx_Config *ctxConfig, char *SetKeyLogCb);
int HLT_SetClientVerifySupport(HLT_Ctx_Config* ctxConfig, bool support);
int HLT_SetNoClientCertSupport(HLT_Ctx_Config* ctxConfig, bool support);
int HLT_SetPostHandshakeAuth(HLT_Ctx_Config *ctxConfig, bool support);
int HLT_SetExtenedMasterSecretSupport(HLT_Ctx_Config* ctxConfig, bool support);
int HLT_SetEncryptThenMac(HLT_Ctx_Config *ctxConfig, int support);
int HLT_SetMiddleBoxCompat(HLT_Ctx_Config *ctxConfig, int support);
int HLT_SetModeSupport(HLT_Ctx_Config *ctxConfig, uint32_t mode);
int HLT_SetCipherSuites(HLT_Ctx_Config* ctxConfig, const char* cipherSuites);
int HLT_SetProviderPath(HLT_Ctx_Config *ctxConfig, char *providerPath);
int HLT_SetProviderAttrName(HLT_Ctx_Config *ctxConfig, char *attrName);
int HLT_AddProviderInfo(HLT_Ctx_Config *ctxConfig, char *providerName, int providerLibFmt);
int HLT_SetTls13CipherSuites(HLT_Ctx_Config *ctxConfig, const char *cipherSuites);
int HLT_SetEcPointFormats(HLT_Ctx_Config* ctxConfig, const char* pointFormat);
int HLT_SetGroups(HLT_Ctx_Config* ctxConfig, const char* groups);
int HLT_SetSignature(HLT_Ctx_Config* ctxConfig, const char* signature);
int HLT_SetCaCertPath(HLT_Ctx_Config* ctxConfig, const char* caCertPath);
int HLT_SetChainCertPath(HLT_Ctx_Config* ctxConfig, const char* chainCertPath);
int HLT_SetEeCertPath(HLT_Ctx_Config* ctxConfig, const char* eeCertPath);
int HLT_SetPrivKeyPath(HLT_Ctx_Config* ctxConfig, const char* privKeyPath);
int HLT_SetPassword(HLT_Ctx_Config* ctxConfig, const char* password);
void HLT_SetCertPath(HLT_Ctx_Config* ctxConfig, const char *caPath,
const char *chainPath, const char *EePath, const char *PrivPath, const char *signCert, const char *signPrivKey);
int HLT_SetPsk(HLT_Ctx_Config *ctxConfig, char *psk);
int HLT_SetKeyExchMode(HLT_Ctx_Config *config, uint32_t mode);
int HLT_SetTicketKeyCb(HLT_Ctx_Config *ctxConfig, char *ticketKeyCbName);
int HLT_SetServerName(HLT_Ctx_Config *ctxConfig, const char *serverName);
int HLT_SetServerNameArg(HLT_Ctx_Config *ctxConfig, char *arg);
int HLT_SetServerNameCb(HLT_Ctx_Config *ctxConfig, char *sniCbName);
int HLT_SetAlpnProtos(HLT_Ctx_Config *ctxConfig, const char *alpnProtos);
int HLT_SetAlpnProtosSelectCb(HLT_Ctx_Config *ctxConfig, char *callback, char *userData);
// Interface for setting abnormal message operations
int HLT_SetFrameHandle(HLT_FrameHandle *frameHandle);
void HLT_CleanFrameHandle(void);
int HLT_FreeResFromSsl(const void *ssl);
int HLT_SetClientHelloCb(HLT_Ctx_Config *ctxConfig, HITLS_ClientHelloCb callback, void *arg);
int HLT_SetCertCb(HLT_Ctx_Config *ctxConfig, HITLS_CertCb certCb, void *arg);
int HLT_SetCAList(HLT_Ctx_Config *ctxConfig, HITLS_TrustedCAList *caList);
// General initialization interface
int HLT_LibraryInit(TLS_TYPE tlsType);
// The local process invokes TLS functions
HLT_Tls_Res* HLT_ProcessTlsInit(HLT_Process *process, TLS_VERSION tlsVersion,
HLT_Ctx_Config *ctxConfig, HLT_Ssl_Config *sslConfig);
void* HLT_TlsNewCtx(TLS_VERSION tlsVersion);
void* HLT_TlsProviderNewCtx(char *providerPath, char (*providerNames)[MAX_PROVIDER_NAME_LEN], int *providerLibFmts,
int providerCnt, char *attrName, TLS_VERSION tlsVersion);
HLT_Ctx_Config* HLT_NewCtxConfig(char* setFile, const char* key);
HLT_Ctx_Config* HLT_NewCtxConfigTLCP(char *setFile, const char *key, bool isClient);
int HLT_TlsSetCtx(void* ctx, HLT_Ctx_Config* config);
HLT_Ssl_Config* HLT_NewSslConfig(char* setFile);
void* HLT_TlsNewSsl(void* ctx);
int HLT_TlsSetSsl(void* ssl, HLT_Ssl_Config* config);
unsigned long int HLT_TlsListen(void *ssl);
unsigned long int HLT_TlsAccept(void* ssl);
int HLT_TlsListenBlock(void* ssl);
int HLT_TlsAcceptBlock(void* ssl);
int HLT_GetTlsAcceptResultFromId(unsigned long int threadId);
int HLT_GetTlsAcceptResult(HLT_Tls_Res* tlsRes);
int HLT_TlsConnect(void* ssl);
int HLT_TlsRead(void* ssl, uint8_t *data, uint32_t bufSize, uint32_t *readLen);
int HLT_TlsWrite(void* ssl, uint8_t *data, uint32_t dataLen);
int HLT_TlsRegCallback(TlsCallbackType type);
int HLT_TlsRenegotiate(void *ssl);
int HLT_TlsVerifyClientPostHandshake(void *ssl);
int HLT_TlsClose(void *ssl);
int HLT_TlsSetSession(void *ssl, void *session);
int HLT_TlsSessionReused(void *ssl);
void *HLT_TlsGet1Session(void *ssl);
int32_t HLT_SetSessionCacheMode(HLT_Ctx_Config* config, HITLS_SESS_CACHE_MODE mode);
int32_t HLT_SetSessionTicketSupport(HLT_Ctx_Config* config, bool issupport);
int HLT_TlsSessionHasTicket(void *session);
int HLT_TlsSessionIsResumable(void *session);
void HLT_TlsFreeSession(void *session);
// The RPC controls the remote process to invoke TLS functions
int HLT_RpcTlsNewCtx(HLT_Process* peerProcess, TLS_VERSION tlsVersion, bool isClient);
int HLT_RpcProviderTlsNewCtx(HLT_Process *peerProcess, TLS_VERSION tlsVersion, bool isClient, char *providerPath,
char (*providerNames)[MAX_PROVIDER_NAME_LEN], int32_t *providerLibFmts, int32_t providerCnt, char *attrName);
int HLT_RpcTlsSetCtx(HLT_Process* peerProcess, int ctxId, HLT_Ctx_Config* config);
int HLT_RpcTlsNewSsl(HLT_Process* peerProcess, int ctxId);
int HLT_RpcTlsSetSsl(HLT_Process* peerProcess, int sslId, HLT_Ssl_Config* config);
int HLT_RpcTlsListen(HLT_Process* peerProcess, int sslId);
int HLT_RpcTlsAccept(HLT_Process* peerProcess, int sslId);
int HLT_RpcGetTlsListenResult(int acceptId);
int HLT_RpcGetTlsAcceptResult(int acceptId);
int HLT_RpcTlsConnect(HLT_Process* peerProcess, int sslId);
int HLT_RpcTlsConnectUnBlock(HLT_Process *peerProcess, int sslId);
int HLT_RpcGetTlsConnectResult(int cmdIndex);
int HLT_RpcTlsRead(HLT_Process* peerProcess, int sslId, uint8_t *data, uint32_t bufSize, uint32_t *readLen);
int HLT_RpcTlsReadUnBlock(HLT_Process *peerProcess, int sslId, uint8_t *data, uint32_t bufSize, uint32_t *readLen);
int HLT_RpcGetTlsReadResult(int cmdIndex, uint8_t *data, uint32_t bufSize, uint32_t *readLen);
int HLT_RpcTlsWrite(HLT_Process* peerProcess, int sslId, uint8_t *data, uint32_t bufSize);
int HLT_RpcTlsWriteUnBlock(HLT_Process *peerProcess, int sslId, uint8_t *data, uint32_t bufSize);
int HLT_RpcGetTlsWriteResult(int cmdIndex);
int HLT_RpcTlsRenegotiate(HLT_Process *peerProcess, int sslId);
int HLT_RpcTlsVerifyClientPostHandshake(HLT_Process *peerProcess, int sslId);
int HLT_RpcTlsRegCallback(HLT_Process* peerProcess, TlsCallbackType type);
int HLT_RpcProcessExit(HLT_Process* peerProcess);
int HLT_RpcDataChannelBind(HLT_Process *peerProcess, DataChannelParam *channelParam);
int HLT_RpcDataChannelAccept(HLT_Process* peerProcess, DataChannelParam* channelParam);
int HLT_RpcGetAcceptFd(int acceptId);
int HLT_RpcDataChannelConnect(HLT_Process* peerProcess, DataChannelParam* channelParam);
int HLT_RpcTlsGetStatus(HLT_Process *peerProcess, int sslId);
int HLT_RpcTlsGetAlertFlag(HLT_Process *peerProcess, int sslId);
int HLT_RpcTlsGetAlertLevel(HLT_Process *peerProcess, int sslId);
int HLT_RpcTlsGetAlertDescription(HLT_Process *peerProcess, int sslId);
int HLT_RpcTlsClose(HLT_Process *peerProcess, int sslId);
int HLT_RpcFreeResFormSsl(HLT_Process *peerProcess, int sslId);
int HLT_RpcSctpClose(HLT_Process *peerProcess, int fd);
int HLT_RpcCloseFd(HLT_Process *peerProcess, int fd, int linkType);
int HLT_RpcTlsSetMtu(HLT_Process *peerProcess, int sslId, uint16_t mtu);
int HLT_RpcTlsGetErrorCode(HLT_Process *peerProcess, int sslId);
// TLS connection establishment encapsulation interface
HLT_Tls_Res* HLT_ProcessTlsAccept(HLT_Process *process, TLS_VERSION tlsVersion,
HLT_Ctx_Config *ctxConfig, HLT_Ssl_Config *sslConfig);
HLT_Tls_Res* HLT_ProcessTlsConnect(HLT_Process *process, TLS_VERSION tlsVersion,
HLT_Ctx_Config *ctxConfig, HLT_Ssl_Config *sslConfig);
int HLT_ProcessTlsRead(HLT_Process *process, HLT_Tls_Res* tlsRes, uint8_t *data, uint32_t bufSize, uint32_t *dataLen);
int HLT_ProcessTlsWrite(HLT_Process *process, HLT_Tls_Res* tlsRes, uint8_t *data, uint32_t dataLen);
int HLT_TlsSetMtu(void *ssl, uint16_t mtu);
int HLT_TlsGetErrorCode(void *ssl);
bool IsEnableSctpAuth(void);
#ifdef __cplusplus
}
#endif
#endif // HLT_H | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/include/hlt.h | C | unknown | 10,222 |
/*
* 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.
*/
#ifndef HLT_TYPE_H
#define HLT_TYPE_H
#include <stdint.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdbool.h>
#include "uio_base.h"
#include "bsl_uio.h"
#include "hitls_type.h"
#include "tls_config.h"
#ifdef __cplusplus
extern "C" {
#endif
#define IP_LEN (32)
#define MAX_CIPHERSUITES_LEN (512)
#define MAX_POINTFORMATS_LEN (512)
#define MAX_GROUPS_LEN (512)
#define MAX_SIGNALGORITHMS_LEN (512)
#define MAX_CERT_LEN (512)
#define PSK_MAX_LEN (256)
#define TICKET_KEY_CB_NAME_LEN (50)
#define MAX_SERVER_NAME_LEN (256)
#define SERVER_NAME_CB_NAME_LEN (50)
#define SERVER_NAME_ARG_NAME_LEN (50)
#define MAX_ALPN_LEN (256)
#define ALPN_CB_NAME_LEN (50)
#define ALPN_DATA_NAME_LEN (50)
#define MAX_NO_RENEGOTIATIONCB_LEN (1024)
#define MAX_PROVIDER_NAME_LEN (256)
#define MAX_ATTR_NAME_LEN (256)
#define MAX_PROVIDER_PATH_LEN (256)
#define MAX_PROVIDER_COUNT (10)
#define KEY_LOG_CB_LEN (1024)
#define DEFAULT_CERT_PATH "../../testcode/testdata/tls/certificate/der/"
#define RSAPSS_SHA256_CA_PATH "rsa_pss_sha256/rsa_pss_root.der:rsa_pss_sha256/rsa_pss_intCa.der"
#define RSAPSS_SHA256_CHAIN_PATH "rsa_pss_sha256/rsa_pss_intCa.der"
#define RSAPSS_SHA256_EE_PATH "rsa_pss_sha256/rsa_pss_dev.der"
#define RSAPSS_SHA256_PRIV_PATH "rsa_pss_sha256/rsa_pss_dev.key.der"
#define RSAPSS_RSAE_CA_PATH "rsa_pss_rsae/rsa_root.der:rsa_pss_rsae/rsa_intCa.der"
#define RSAPSS_RSAE_CHAIN_PATH "rsa_pss_rsae/rsa_intCa.der"
#define RSAPSS_RSAE_EE_PATH "rsa_pss_rsae/rsa_dev.der"
#define RSAPSS_RSAE_PRIV_PATH "rsa_pss_rsae/rsa_dev.key.der"
#define RSA_SHA_CA_PATH "rsa_sha/ca-3072.der:rsa_sha/inter-3072.der"
#define RSA_SHA_CHAIN_PATH "rsa_sha/inter-3072.der"
#define RSA_SHA1_EE_PATH "rsa_sha/end-sha1.der"
#define RSA_SHA1_PRIV_PATH "rsa_sha/end-sha1.key.der"
#define RSA_SHA384_EE_PATH "rsa_sha/end-sha384.der"
#define RSA_SHA384_PRIV_PATH "rsa_sha/end-sha384.key.der"
#define RSA_SHA512_EE_PATH "rsa_sha/end-sha512.der"
#define RSA_SHA512_PRIV_PATH "rsa_sha/end-sha512.key.der"
#define ED25519_SHA512_CA_PATH "ed25519/ed25519.ca.der:ed25519/ed25519.intca.der"
#define ED25519_SHA512_CHAIN_PATH "ed25519/ed25519.intca.der"
#define ED25519_SHA512_EE_PATH "ed25519/ed25519.end.der"
#define ED25519_SHA512_PRIV_PATH "ed25519/ed25519.end.key.der"
#define ECDSA_SHA_CA_PATH "ecdsa/ca-nist521.der:ecdsa/inter-nist521.der"
#define ECDSA_SHA_CHAIN_PATH "ecdsa/inter-nist521.der"
#define ECDSA_SHA256_EE_PATH "ecdsa/end256-sha256.der"
#define ECDSA_SHA256_PRIV_PATH "ecdsa/end256-sha256.key.der"
#define ECDSA_SHA384_EE_PATH "ecdsa/end384-sha384.der"
#define ECDSA_SHA384_PRIV_PATH "ecdsa/end384-sha384.key.der"
#define ECDSA_SHA512_EE_PATH "ecdsa/end521-sha512.der"
#define ECDSA_SHA512_PRIV_PATH "ecdsa/end521-sha512.key.der"
#define ECDSA_SHA1_CA_PATH "ecdsa_sha1/ca-nist521.der:ecdsa_sha1/inter-nist521.der"
#define ECDSA_SHA1_CHAIN_PATH "ecdsa_sha1/inter-nist521.der"
#define ECDSA_SHA1_EE_PATH "ecdsa_sha1/end384-sha1.der"
#define ECDSA_SHA1_PRIV_PATH "ecdsa_sha1/end384-sha1.key.der"
#define RSA_SHA256_CA_PATH "rsa_sha256/ca.der:rsa_sha256/inter.der"
#define RSA_SHA256_CHAIN_PATH "rsa_sha256/inter.der"
#define RSA_SHA256_EE_PATH1 "rsa_sha256/server.der"
#define RSA_SHA256_PRIV_PATH1 "rsa_sha256/server.key.der"
#define RSA_SHA256_EE_PATH2 "rsa_sha256/client.der"
#define RSA_SHA256_PRIV_PATH2 "rsa_sha256/client.key.der"
#define RSA_SHA256_EE_PATH3 "rsa_sha/end-sha256.der"
#define RSA_SHA256_PRIV_PATH3 "rsa_sha/end-sha256.key.der"
#define ECDSA_SHA256_CA_PATH "ecdsa_sha256/ca.der:ecdsa_sha256/inter.der"
#define ECDSA_SHA256_CHAIN_PATH "ecdsa_sha256/inter.der"
#define ECDSA_SHA256_EE_PATH1 "ecdsa_sha256/server.der"
#define ECDSA_SHA256_PRIV_PATH1 "ecdsa_sha256/server.key.der"
#define ECDSA_SHA256_EE_PATH2 "ecdsa_sha256/client.der"
#define ECDSA_SHA256_PRIV_PATH2 "ecdsa_sha256/client.key.der"
#define SM2_VERIFY_PATH "sm2_with_userid/ca.der:sm2_with_userid/inter.der"
#define SM2_CHAIN_PATH "sm2_with_userid/inter.der"
#define SM2_SERVER_ENC_CERT_PATH "sm2_with_userid/enc.der"
#define SM2_SERVER_ENC_KEY_PATH "sm2_with_userid/enc.key.der"
#define SM2_SERVER_SIGN_CERT_PATH "sm2_with_userid/sign.der"
#define SM2_SERVER_SIGN_KEY_PATH "sm2_with_userid/sign.key.der"
#define SM2_CLIENT_ENC_CERT_PATH "sm2_with_userid/enc22.der"
#define SM2_CLIENT_ENC_KEY_PATH "sm2_with_userid/enc22.key.der"
#define SM2_CLIENT_SIGN_CERT_PATH "sm2_with_userid/sign22.der"
#define SM2_CLIENT_SIGN_KEY_PATH "sm2_with_userid/sign22.key.der"
typedef struct ProcessSt HLT_Process;
typedef enum {
HITLS,
HITLS_PROVIDER,
} TLS_TYPE;
typedef enum {
CLIENT,
SERVER
} TLS_ROLE;
typedef enum {
DTLS_ALL,
DTLS1_0,
DTLS1_2,
TLS_ALL,
SSL3_0,
TLS1_0,
TLS1_1,
TLS1_2,
TLS1_3,
TLCP1_1,
DTLCP1_1,
} TLS_VERSION;
typedef enum {
TCP = 0, /**< TCP protocol */
SCTP = 1, /**< SCTP protocol */
UDP = 2, /**< UDP protocol */
NONE_TYPE = 10,
} HILT_TransportType;
typedef enum {
CERT_CALLBACK_DEFAULT,
} CertCallbackType;
typedef enum {
MEM_CALLBACK_DEFAULT,
} MemCallbackType;
typedef enum {
HITLS_CALLBACK_DEFAULT,
} TlsCallbackType;
typedef enum {
COOKIE_CB_DEFAULT, // Normal cookie callback
COOKIE_CB_LEN_0, // The length of the generated cookie is 0
} CookieCallbackType;
typedef struct {
struct sockaddr_in sockAddr;
HILT_TransportType type;
char ip[IP_LEN];
int port;
int bindFd;
bool isBlock;
} DataChannelParam;
typedef struct {
struct sockaddr_in sockAddr;
int connPort;
int srcFd;
int peerFd;
} HLT_FD;
typedef enum {
SERVER_CTX_SET_TRUE = 1,
SERVER_CTX_SET_FALSE = 2,
SERVER_CFG_SET_TRUE = 3,
SERVER_CFG_SET_FALSE = 4,
} HILT_SupportType;
typedef struct {
uint16_t mtu; // Set the MTU in the dtls.
// The maximum version number and minimum version number must be both TLS and DTLS.
// Currently, only DTLS 1.2 is supported
uint32_t minVersion;
uint32_t maxVersion;
char cipherSuites[MAX_CIPHERSUITES_LEN]; // cipher suite
char tls13CipherSuites[MAX_CIPHERSUITES_LEN]; // TLS13 cipher suite
char pointFormats[MAX_POINTFORMATS_LEN]; // ec Point Format
// According to RFC 8446 4.2.7, before TLS 1.3: ec curves; TLS 1.3: group supported by the key exchange.
char groups[MAX_GROUPS_LEN];
char signAlgorithms[MAX_SIGNALGORITHMS_LEN]; // signature algorithm
char serverName[MAX_SERVER_NAME_LEN]; // Client server_name
// Name of the server_name callback function for processing the first handshake on the server
char sniDealCb[SERVER_NAME_CB_NAME_LEN];
// name of the value function related to the server_name registered by the product
char sniArg[SERVER_NAME_ARG_NAME_LEN];
char alpnList[MAX_ALPN_LEN]; // alpn
char alpnUserData[ALPN_CB_NAME_LEN];
char alpnSelectCb[ALPN_DATA_NAME_LEN]; // Application Layer Protocol Select Callback
char keyLogCb[KEY_LOG_CB_LEN];
// Indicates whether renegotiation is supported. The default value is False, indicating that renegotiation is not
// supported
bool isSupportRenegotiation;
bool allowClientRenegotiate; /* allow a renegotiation initiated by the client */
bool allowLegacyRenegotiate; /* whether to abort handshake when server doesn't support SecRenegotiation */
int SupportType; // 1:The server algorithm is preferred
bool needCheckKeyUsage; // Client verification is supported. The default value is False
// Indicates whether to allow the empty certificate list on the client. The default value is False
bool isSupportClientVerify;
bool isSupportNoClientCert; // supports extended master keys. The default value is True
// The handshake will be continued regardless of the verification result. for server and client
bool isSupportVerifyNone;
bool isSupportPostHandshakeAuth; // Indicates whether to support post handshake auth. The default value is false.
bool isSupportExtendMasterSecret; // supports extended master keys. The default value is True
bool isSupportSessionTicket; // Support session ticket
bool isEncryptThenMac; // Encrypt-then-mac is supported
// Users can set the DH parameter to be automatically selected. If the switch is enabled,
// the DH parameter is automatically selected based on the length of the certificate private key
bool isSupportDhAuto;
int32_t setSessionCache; // Setting the Session Storage Mode
uint32_t keyExchMode; // TLS1.3 key exchange mode
void *infoCb; // connection establishment callback function
void *msgCb; // Message callback function
void *msgArg; // Message callback parameter function
void *certCb;
void *certArg;
void *clientHelloCb;
void *clientHelloArg;
// Indicates whether to enable the function of sending handshake information by flight
bool isFlightTransmitEnable;
bool isNoSetCert; // Indicates whether the certificate does not need to be set
int32_t securitylevel; // Security level
int32_t readAhead;
void *caList;
char psk[PSK_MAX_LEN]; // psk password
char ticketKeyCb[TICKET_KEY_CB_NAME_LEN]; // ticket key Callback Function Name
char eeCert[MAX_CERT_LEN];
char privKey[MAX_CERT_LEN];
char signCert[MAX_CERT_LEN];
char signPrivKey[MAX_CERT_LEN];
char password[MAX_CERT_LEN];
char caCert[MAX_CERT_LEN];
char chainCert[MAX_CERT_LEN];
bool isClient;
uint32_t emptyRecordsNum;
char providerPath[MAX_PROVIDER_PATH_LEN];
char providerNames[MAX_PROVIDER_COUNT][MAX_PROVIDER_NAME_LEN];
int32_t providerLibFmts[MAX_PROVIDER_COUNT];
int32_t providerCnt;
char attrName[MAX_ATTR_NAME_LEN];
uint32_t modeSupport; // support features, such as HITLS_MODE_SEND_FALLBACK_SCSV. All mode at hitls_type.h
bool isMiddleBoxCompat; // Indicates whether to enable the middle box compatibility mode.
} HLT_Ctx_Config;
typedef struct {
struct sockaddr_in sockAddr;
int connPort;
int sockFd;
HILT_TransportType connType;
int SupportType; // 3:The server algorithm is preferred
int sctpCtrlCmd;
} HLT_Ssl_Config;
typedef struct {
void *ctx; // hitls config
void *ssl; // hitls ctx
int ctxId;
int sslId;
unsigned long int acceptId;
} HLT_Tls_Res;
typedef enum {
EXP_NONE,
EXP_IO_BUSY,
EXP_RECV_BUF_EMPTY,
} HLT_ExpectIoState;
typedef enum {
POINT_NONE,
POINT_RECV,
POINT_SEND,
} HLT_PointType;
/**
* @brief msg processing callback
*/
typedef void (*HLT_FrameCallBack)(void *msg, void *userData);
typedef struct {
BSL_UIO_Method method; /**< User-defined message sending and receiving control function */
HLT_FrameCallBack frameCallBack; /**< msg processing callback */
void *ctx; /**< TLS context */
int32_t expectReType; /**< Corresponding enumeration REC_Type */
int32_t expectHsType; /**< Corresponding enumerated value HS_MsgType */
HLT_ExpectIoState ioState; /**< customized I/O status */
HLT_PointType pointType; /**< Callback function for recording keys */
void *userData; /**< Customized data, which will be transferred to the msg processing callback */
} HLT_FrameHandle;
#if (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
#define TIME_OUT_SEC 50
#else
#define TIME_OUT_SEC 8
#endif
#ifdef __cplusplus
}
#endif
#endif // HLT_TYPE_H
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/include/hlt_type.h | C | unknown | 12,384 |
/*
* 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.
*/
#ifndef FRAME_IO_H
#define FRAME_IO_H
#include "bsl_errno.h"
#include "bsl_uio.h"
#ifdef __cplusplus
extern "C" {
#endif
#define MAX_RECORD_LENTH (20 * 1024) // Simulates the bottom-layer sending and receiving processing of the DT framework.
typedef struct FrameUioUserData_ FrameUioUserData;
/**
* @brief SCTP bottom-layer I/O function, which is used to simulate the SCTP message sending interface.
*
* @par Description:
* SCTP bottom-layer I/O function, which is used to simulate the SCTP message sending interface.
*
* @attention
* @return If the operation is successful, success is returned. Otherwise, other values are returned. In this framework,
* a success message is returned without special reasons.
*/
int32_t FRAME_Write(BSL_UIO *uio, const void *buf, uint32_t len, uint32_t *writeLen);
/**
* @brief SCTP bottom-layer I/O function, which is used to simulate the SCTP message receiving interface.
*
* @par Description:
* SCTP bottom-layer I/O function, which is used to simulate the SCTP message receiving interface.
*
* @attention
* @return If the operation is successful, success is returned. Otherwise, other values are returned.
*/
int32_t FRAME_Read(BSL_UIO *uio, void *buf, uint32_t len, uint32_t *readLen);
/**
* @brief SCTP bottom-layer I/O function, which is used to simulate the SCTP control interface.
*
* @par Description:
* SCTP bottom-layer I/O function, which is used to simulate the SCTP control interface.
*
* @attention
* @return If the operation is successful, success is returned. Otherwise, other values are returned.
*/
int32_t FRAME_Ctrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *param);
/**
* @brief Create a UIO user data. The user data must be used when the I/O of the test framework is used. The user data
* stores the data to be sent and received by the I/O.
*
* @return If the operation is successful, the pointer of userdata is returned.
*/
FrameUioUserData *FRAME_IO_CreateUserData(void);
/**
* @brief Releases userdata created by the Frame_IO_CreateUserData function.
*
* @return NA
*/
void FRAME_IO_FreeUserData(FrameUioUserData *userData);
/**
* @brief Frame_TransportSendMsg sends the messages in the sending buffer in the I/O.
*
* @return If the operation is successful, 0 is returned. Otherwise, another value is returned.
*/
int32_t FRAME_TransportSendMsg(BSL_UIO *uio, void *buf, uint32_t len, uint32_t *readLen);
/**
* @brief Frame_TransportRecMsg simulates receiving messages from the I/O.
*
* @return If the operation is successful, 0 is returned. Otherwise, another value is returned.
*/
int32_t FRAME_TransportRecMsg(BSL_UIO *uio, void *buf, uint32_t len);
#ifdef __cplusplus
}
#endif
#endif // FRAME_IO_H
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/io/include/frame_io.h | C | unknown | 3,272 |
/*
* 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 "simulate_io.h"
#include "hitls_error.h"
#include "bsl_sal.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_errno.h"
#include "bsl_uio.h"
#include "securec.h"
#define FAKE_BSL_UIO_FD 666
FrameUioUserData *FRAME_IO_CreateUserData(void)
{
FrameUioUserData *userData = BSL_SAL_Calloc(1u, sizeof(FrameUioUserData));
if (userData == NULL) {
return NULL;
}
return userData;
}
void FRAME_IO_FreeUserData(FrameUioUserData *userData)
{
if (userData == NULL) {
return;
}
BSL_SAL_FREE(userData);
return;
}
int32_t FRAME_Write(BSL_UIO *uio, const void *buf, uint32_t len, uint32_t *writeLen)
{
*writeLen = 0;
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(uio);
if (ioUserData == NULL) {
return BSL_NULL_INPUT;
}
// This indicates that there is still a message in the buffer. The second message can be sent only after the peer
// end receives the message.
if (ioUserData->sndMsg.len != 0) {
return BSL_SUCCESS;
}
memcpy_s(ioUserData->sndMsg.msg, MAX_RECORD_LENTH, buf, len);
ioUserData->sndMsg.len = len;
*writeLen = len;
return BSL_SUCCESS;
}
int32_t FRAME_Read(BSL_UIO *uio, void *buf, uint32_t len, uint32_t *readLen)
{
*readLen = 0;
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(uio);
if (ioUserData == NULL) {
return BSL_NULL_INPUT;
}
// This indicates that the user inserts data. Therefore, the simulated data inserted by the user is received first.
if (ioUserData->userInsertMsg.len != 0) {
if (len < ioUserData->userInsertMsg.len) {
return BSL_UIO_FAIL;
}
memcpy_s(buf, len, ioUserData->userInsertMsg.msg, ioUserData->userInsertMsg.len);
*readLen = ioUserData->userInsertMsg.len;
ioUserData->userInsertMsg.len = 0;
return BSL_SUCCESS;
} else if (ioUserData->recMsg.len != 0) {
uint32_t copyLen = len < ioUserData->recMsg.len ? len : ioUserData->recMsg.len;
memcpy_s(buf, len, ioUserData->recMsg.msg, copyLen);
*readLen = copyLen;
if (copyLen < ioUserData->recMsg.len) {
memmove_s(ioUserData->recMsg.msg, ioUserData->recMsg.len,
&ioUserData->recMsg.msg[copyLen], ioUserData->recMsg.len - copyLen);
}
ioUserData->recMsg.len -= copyLen;
return BSL_SUCCESS;
} // If there is no data in the receive buffer, a success message is returned and *readLen is set to 0.
return BSL_SUCCESS;
}
int32_t FRAME_Ctrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *param)
{
(void)uio;
(void)larg;
if (cmd == BSL_UIO_SCTP_SND_BUFF_IS_EMPTY) {
*(uint8_t *)param = true;
}
if (cmd == BSL_UIO_GET_FD) {
*(int32_t *)param = FAKE_BSL_UIO_FD;
}
return BSL_SUCCESS;
}
/*
Frame_TransportSendMsg: Sends messages in the send buffer in the I/O.
Copy uio->userData to the buffer.
*/
int32_t FRAME_TransportSendMsg(BSL_UIO *uio, void *buf, uint32_t len, uint32_t *readLen)
{
*readLen = 0;
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(uio);
if (ioUserData == NULL) {
return HITLS_NULL_INPUT;
}
if (ioUserData->sndMsg.len != 0) {
// The length of the data in the buffer exceeds len.
if (len < ioUserData->sndMsg.len) {
return HITLS_UIO_FAIL;
}
memcpy_s(buf, len, ioUserData->sndMsg.msg, ioUserData->sndMsg.len);
*readLen = ioUserData->sndMsg.len;
ioUserData->sndMsg.len = 0;
} // If there is no data in the receive buffer, a success message is returned and *readLen is set to 0.
return HITLS_SUCCESS;
}
/*
Frame_TransportRecMsg simulates receiving messages from the I/O.
Copy the data in the buffer to uio->userData.
*/
int32_t FRAME_TransportRecMsg(BSL_UIO *uio, void *buf, uint32_t len)
{
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(uio);
if (ioUserData == NULL) {
return HITLS_NULL_INPUT;
}
if (ioUserData->recMsg.len != 0 || len > MAX_RECORD_LENTH) {
return HITLS_UIO_FAIL;
}
memcpy_s(ioUserData->recMsg.msg, MAX_RECORD_LENTH, buf, len);
ioUserData->recMsg.len = len;
return HITLS_SUCCESS;
}
#ifdef __cplusplus
}
#endif
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/io/src/simulate_io.c | C | unknown | 4,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.
*/
#ifndef SIMULATE_IO_H
#define SIMULATE_IO_H
#include "frame_io.h"
#include "bsl_bytes.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
uint8_t msg[MAX_RECORD_LENTH];
uint32_t len;
} FrameMsg;
struct FrameUioUserData_ {
FrameMsg sndMsg;
FrameMsg recMsg;
FrameMsg userInsertMsg;
};
#define REC_RECORD_DTLS_EPOCH_OFFSET 3
#define REC_RECORD_DTLS_LENGTH_OFFSET 11
#ifdef __cplusplus
}
#endif
#endif // SIMULATE_IO_H | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/io/src/simulate_io.h | C | unknown | 994 |
/*
* 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.
*/
#ifndef PACK_FRAME_MSG_H
#define PACK_FRAME_MSG_H
#include "frame_msg.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Generate a framework message based on the content in the message buffer.
*
* @return Returns the CTX object of the TLS.
*/
int32_t PackFrameMsg(FRAME_Msg *msg);
#ifdef __cplusplus
}
#endif
#endif // PACK_FRAME_MSG_H | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/msg/include/pack_frame_msg.h | C | unknown | 889 |
/*
* 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.
*/
#ifndef PARSER_FRAME_MSG_H
#define PARSER_FRAME_MSG_H
#include "frame_msg.h"
#ifdef __cplusplus
extern "C" {
#endif
int32_t ParserRecordHeader(FRAME_Msg *frameMsg, const uint8_t *buffer, uint32_t len, uint32_t *parserLen);
int32_t ParserRecordBody(const FRAME_LinkObj *linkObj, FRAME_Msg *frameMsg,
const uint8_t *buffer, uint32_t len, uint32_t *parserLen);
int32_t ParserTotalRecord(const FRAME_LinkObj *linkObj, FRAME_Msg *frameMsg,
const uint8_t *buffer, uint32_t len, uint32_t *parserLen);
void CleanRecordBody(FRAME_Msg *frameMsg);
#ifdef __cplusplus
}
#endif
#endif // PARSER_FRAME_MSG_H
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/msg/include/parser_frame_msg.h | C | unknown | 1,151 |
/*
* 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "securec.h"
#include "bsl_sal.h"
#include "hitls.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "hitls_type.h"
#include "frame_tls.h"
#include "frame_msg.h"
#include "frame_link.h"
#include "frame_io.h"
#include "simulate_io.h"
#define DEFAUTL_COOKIE_LEN 32
/* Used to establish a link and stop in the state. */
typedef struct {
HITLS_Config *config;
FRAME_LinkObj *client;
FRAME_LinkObj *server;
HITLS_HandshakeState state;
bool isClient;
BSL_UIO_TransportType transportType;
} LinkPara;
static void CleanLinkPara(LinkPara *linkPara)
{
HITLS_CFG_FreeConfig(linkPara->config);
FRAME_FreeLink(linkPara->client);
FRAME_FreeLink(linkPara->server);
}
static int32_t PauseState(LinkPara *linkPara, uint16_t version)
{
(void)version;
BSL_UIO_TransportType transportType = linkPara->transportType;
#ifdef HITLS_TLS_PROTO_TLCP11
/* Constructing a Link */
if ( version == HITLS_VERSION_TLCP_DTLCP11 ) {
linkPara->client = FRAME_CreateTLCPLink(linkPara->config, transportType, true);
linkPara->server = FRAME_CreateTLCPLink(linkPara->config, transportType, false);
} else
#endif /* HITLS_TLS_PROTO_TLCP11 */
{
linkPara->client = FRAME_CreateLink(linkPara->config, transportType);
linkPara->server = FRAME_CreateLink(linkPara->config, transportType);
}
if (linkPara->client == NULL || linkPara->server == NULL) {
return HITLS_INTERNAL_EXCEPTION;
}
/* Establish a link and stop in a certain state. */
if (FRAME_CreateConnection(linkPara->client, linkPara->server,
linkPara->isClient, linkPara->state) != HITLS_SUCCESS) {
return HITLS_INTERNAL_EXCEPTION;
}
/* Check whether the status is consistent. */
HITLS_Ctx *ctx = linkPara->isClient ? linkPara->client->ssl : linkPara->server->ssl;
if ((ctx->hsCtx == NULL) || (ctx->hsCtx->state != linkPara->state)) {
return HITLS_INTERNAL_EXCEPTION;
}
return HITLS_SUCCESS;
}
static int32_t SetLinkState(HS_MsgType hsType, LinkPara *linkPara)
{
linkPara->isClient = true;
switch (hsType) {
case CLIENT_HELLO:
linkPara->isClient = false;
linkPara->state = TRY_RECV_CLIENT_HELLO;
return HITLS_SUCCESS;
case SERVER_HELLO:
linkPara->state = TRY_RECV_SERVER_HELLO;
return HITLS_SUCCESS;
case CERTIFICATE:
linkPara->state = TRY_RECV_CERTIFICATE;
return HITLS_SUCCESS;
case SERVER_KEY_EXCHANGE:
linkPara->state = TRY_RECV_SERVER_KEY_EXCHANGE;
return HITLS_SUCCESS;
case CERTIFICATE_REQUEST:
linkPara->state = TRY_RECV_CERTIFICATE_REQUEST;
return HITLS_SUCCESS;
case SERVER_HELLO_DONE:
linkPara->state = TRY_RECV_SERVER_HELLO_DONE;
return HITLS_SUCCESS;
case CERTIFICATE_VERIFY:
linkPara->isClient = false;
linkPara->state = TRY_RECV_CERTIFICATE_VERIFY;
return HITLS_SUCCESS;
case CLIENT_KEY_EXCHANGE:
linkPara->isClient = false;
linkPara->state = TRY_RECV_CLIENT_KEY_EXCHANGE;
return HITLS_SUCCESS;
case FINISHED:
// The existing framework does not support parsing of encrypted finished messages.
// Therefore, finished messages cannot be obtained.
break;
default:
break;
}
return HITLS_INTERNAL_EXCEPTION;
}
static int32_t SetLinkConfig(uint16_t version, HITLS_KeyExchAlgo keyExAlgo, LinkPara *linkPara)
{
if (linkPara == NULL) {
return HITLS_INTERNAL_EXCEPTION;
}
linkPara->config = NULL;
if (IS_DTLS_VERSION(version)) {
linkPara->config = HITLS_CFG_NewDTLS12Config();
} else if (version == HITLS_VERSION_TLS12) {
linkPara->config = HITLS_CFG_NewTLS12Config();
} else if (version == HITLS_VERSION_TLS13) {
linkPara->config = HITLS_CFG_NewTLS13Config();
} else if (version == HITLS_VERSION_TLCP_DTLCP11) {
if (IS_TRANSTYPE_DATAGRAM(linkPara->transportType)) {
linkPara->config = HITLS_CFG_NewDTLCPConfig();
} else {
linkPara->config = HITLS_CFG_NewTLCPConfig();
}
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_CONFIG_KEY_USAGE
HITLS_CFG_SetCheckKeyUsage(linkPara->config, false);
#endif /* HITLS_TLS_CONFIG_KEY_USAGE */
#ifdef HITLS_TLS_FEATURE_CERT_MODE
int32_t ret = HITLS_CFG_SetClientVerifySupport(linkPara->config, true);
if (ret != HITLS_SUCCESS) {
return ret;
}
#endif /* HITLS_TLS_FEATURE_CERT_MODE */
if (keyExAlgo == HITLS_KEY_EXCH_DHE) {
uint16_t cipherSuites[] = {HITLS_DHE_RSA_WITH_AES_128_GCM_SHA256};
HITLS_CFG_SetCipherSuites(linkPara->config, cipherSuites, sizeof(cipherSuites) / sizeof(uint16_t));
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256};
HITLS_CFG_SetSignature(linkPara->config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
} else {
uint16_t groups[] = {HITLS_EC_GROUP_SECP256R1};
HITLS_CFG_SetGroups(linkPara->config, groups, sizeof(groups) / sizeof(uint16_t));
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(linkPara->config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
}
return HITLS_SUCCESS;
}
static int32_t GetdefaultHsMsg(FRAME_Type *frameType, FRAME_Msg *parsedMsg)
{
int32_t ret;
LinkPara linkPara = {0};
/* Configure config. */
linkPara.transportType = frameType->transportType;
ret = SetLinkConfig(frameType->versionType, frameType->keyExType, &linkPara);
if (ret != HITLS_SUCCESS) {
CleanLinkPara(&linkPara);
return ret;
}
/* Setting the parked state */
ret = SetLinkState(frameType->handshakeType, &linkPara);
if (ret != HITLS_SUCCESS) {
CleanLinkPara(&linkPara);
return ret;
}
/* Stop in this state */
ret = PauseState(&linkPara, frameType->versionType);
if (ret != HITLS_SUCCESS) {
CleanLinkPara(&linkPara);
return ret;
}
/* Obtain the message buffer. */
FRAME_LinkObj *link = linkPara.isClient ? linkPara.client : linkPara.server;
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(link->io);
uint8_t *buffer = ioUserData->recMsg.msg;
uint32_t len = ioUserData->recMsg.len;
if (len == 0) {
CleanLinkPara(&linkPara);
return HITLS_INTERNAL_EXCEPTION;
}
/* Parse to msg structure */
uint32_t parseLen = 0;
ret = FRAME_ParseMsg(frameType, buffer, len, parsedMsg, &parseLen);
if ((ret != HITLS_SUCCESS) || (len != parseLen)) {
CleanLinkPara(&linkPara);
return HITLS_INTERNAL_EXCEPTION;
}
CleanLinkPara(&linkPara);
return HITLS_SUCCESS;
}
static void SetDefaultRecordHeader(FRAME_Type *frameType, FRAME_Msg *msg, REC_Type recType)
{
msg->recType.state = INITIAL_FIELD;
msg->recType.data = recType;
msg->recVersion.state = INITIAL_FIELD;
if (IS_DTLS_VERSION(frameType->versionType)) {
msg->recVersion.data = HITLS_VERSION_DTLS12;
} else if (frameType->versionType == HITLS_VERSION_TLCP_DTLCP11) {
msg->recVersion.data = HITLS_VERSION_TLCP_DTLCP11;
} else {
msg->recVersion.data = HITLS_VERSION_TLS12;
}
msg->epoch.state = INITIAL_FIELD;
/* In the default message, the value is set to 0 by default. You need to assign a value to the value. */
msg->epoch.data = 0;
msg->sequence.state = INITIAL_FIELD;
/* In the default message, the value is set to 0 by default. You need to assign a value to the value. */
msg->sequence.data = 0;
msg->length.state = INITIAL_FIELD;
/* The value of length is automatically calculated during assembly.
* Therefore, the value of length is initialized to 0. */
msg->length.data = 0;
}
static int32_t GetdefaultCcsMsg(FRAME_Type *frameType, FRAME_Msg *msg)
{
SetDefaultRecordHeader(frameType, msg, REC_TYPE_CHANGE_CIPHER_SPEC); /* Setting the Default Record Header */
msg->body.ccsMsg.ccsType.state = INITIAL_FIELD;
msg->body.ccsMsg.ccsType.data = 1u; /* In the protocol, the CCS type has only this value. */
return HITLS_SUCCESS;
}
static int32_t GetdefaultAlertMsg(FRAME_Type *frameType, FRAME_Msg *msg)
{
SetDefaultRecordHeader(frameType, msg, REC_TYPE_ALERT); /* Setting the Default Record Header */
msg->body.alertMsg.alertLevel.state = INITIAL_FIELD;
/*Default value. You can change the default value as required. */
msg->body.alertMsg.alertLevel.data = ALERT_LEVEL_FATAL;
msg->body.alertMsg.alertDescription.state = INITIAL_FIELD;
/*Default value. You can change the default value as required. */
msg->body.alertMsg.alertDescription.data = ALERT_HANDSHAKE_FAILURE;
return HITLS_SUCCESS;
}
int32_t FRAME_GetDefaultMsg(FRAME_Type *frameType, FRAME_Msg *msg)
{
if ((frameType == NULL) || (msg == NULL)) {
return HITLS_INTERNAL_EXCEPTION;
}
switch (frameType->recordType) {
case REC_TYPE_HANDSHAKE:
return GetdefaultHsMsg(frameType, msg);
case REC_TYPE_CHANGE_CIPHER_SPEC:
return GetdefaultCcsMsg(frameType, msg);
case REC_TYPE_ALERT:
return GetdefaultAlertMsg(frameType, msg);
default:
break;
}
return HITLS_INTERNAL_EXCEPTION;
}
int32_t FRAME_ModifyMsgInteger(const uint64_t data, FRAME_Integer *frameInteger)
{
if (frameInteger == NULL) {
return HITLS_INTERNAL_EXCEPTION;
}
frameInteger->state = ASSIGNED_FIELD;
frameInteger->data = data;
return HITLS_SUCCESS;
}
int32_t FRAME_ModifyMsgArray8(const uint8_t *data, uint32_t dataLen,
FRAME_Array8 *frameArray, FRAME_Integer *frameArrayLen)
{
if ((data == NULL) || (frameArray == NULL) || (dataLen == 0)) {
return HITLS_INTERNAL_EXCEPTION;
}
BSL_SAL_FREE(frameArray->data); /* Clear the old memory. */
frameArray->data = BSL_SAL_Dump(data, dataLen);
if (frameArray->data == NULL) {
return HITLS_MEMALLOC_FAIL;
}
frameArray->state = ASSIGNED_FIELD;
frameArray->size = dataLen;
if (frameArrayLen != NULL) {
frameArrayLen->state = ASSIGNED_FIELD;
frameArrayLen->data = dataLen;
}
return HITLS_SUCCESS;
}
int32_t FRAME_AppendMsgArray8(const uint8_t *data, uint32_t dataLen,
FRAME_Array8 *frameArray, FRAME_Integer *frameArrayLen)
{
if ((data == NULL) || (frameArray == NULL) || (dataLen == 0)) {
return HITLS_INTERNAL_EXCEPTION;
}
/* extended memory */
uint32_t newDataLen = dataLen + frameArray->size;
uint8_t *newData = (uint8_t *)BSL_SAL_Calloc(1u, newDataLen);
if (newData == NULL) {
return HITLS_MEMALLOC_FAIL;
}
if (memcpy_s(newData, newDataLen, frameArray->data, frameArray->size) != EOK) {
BSL_SAL_FREE(newData);
return HITLS_MEMCPY_FAIL;
}
if (memcpy_s(&newData[frameArray->size], newDataLen - frameArray->size, data, dataLen) != EOK) {
BSL_SAL_FREE(newData);
return HITLS_MEMCPY_FAIL;
}
BSL_SAL_FREE(frameArray->data); /* Clear the old memory. */
frameArray->state = ASSIGNED_FIELD;
frameArray->data = newData;
frameArray->size = newDataLen;
if (frameArrayLen != NULL) {
frameArrayLen->state = ASSIGNED_FIELD;
frameArrayLen->data = newDataLen;
}
return HITLS_SUCCESS;
}
int32_t FRAME_ModifyMsgArray16(const uint16_t *data, uint32_t dataLen,
FRAME_Array16 *frameArray, FRAME_Integer *frameArrayLen)
{
if ((data == NULL) || (frameArray == NULL) || (dataLen == 0)) {
return HITLS_INTERNAL_EXCEPTION;
}
BSL_SAL_FREE(frameArray->data); /* Clear the old memory. */
frameArray->data = (uint16_t *)BSL_SAL_Dump(data, dataLen * sizeof(uint16_t));
if (frameArray->data == NULL) {
return HITLS_MEMALLOC_FAIL;
}
frameArray->state = ASSIGNED_FIELD;
frameArray->size = dataLen;
if (frameArrayLen != NULL) {
frameArrayLen->state = ASSIGNED_FIELD;
frameArrayLen->data = dataLen * sizeof(uint16_t);
}
return HITLS_SUCCESS;
}
int32_t FRAME_AppendMsgArray16(const uint16_t *data, uint32_t dataLen,
FRAME_Array16 *frameArray, FRAME_Integer *frameArrayLen)
{
if ((data == NULL) || (frameArray == NULL) || (dataLen == 0)) {
return HITLS_INTERNAL_EXCEPTION;
}
/* extended memory */
uint32_t newDataLen = (frameArray->size + dataLen) * sizeof(uint16_t); /* Data length */
uint16_t *newData = (uint16_t *)BSL_SAL_Calloc(1u, newDataLen);
if (newData == NULL) {
return HITLS_MEMALLOC_FAIL;
}
for (uint32_t i = 0; i < frameArray->size; i++) {
newData[i] = frameArray->data[i];
}
for (uint32_t i = 0; i < dataLen; i++) {
newData[frameArray->size + i] = data[i];
}
BSL_SAL_FREE(frameArray->data); /* Clear the old memory. */
frameArray->state = ASSIGNED_FIELD;
frameArray->data = newData;
frameArray->size = newDataLen / sizeof(uint16_t); /* Number of data records */
if (frameArrayLen != NULL) {
frameArrayLen->state = ASSIGNED_FIELD;
frameArrayLen->data = newDataLen;
}
return HITLS_SUCCESS;
}
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/msg/src/frame_msg_method.c | C | unknown | 14,060 |
/*
* 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 "securec.h"
#include "bsl_bytes.h"
#include "hitls_error.h"
#include "hitls.h"
#include "tls.h"
#include "hs_ctx.h"
#include "frame_msg.h"
#include "hs_extensions.h"
#define TLS_RECORD_HEADER_LEN 5
#define DTLS_RECORD_HEADER_LEN 13
#define SIZE_OF_UINT24 3
#define SIZE_OF_UINT32 4
#define SIZE_OF_UINT48 6
#define ONE_TIME 1
#define TWO_TIMES 2
// Assemble 8-bit data(1 byte)
static int32_t PackInteger8(const FRAME_Integer *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
uint32_t bufOffset = 0;
// No assembly required
if (field->state == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Repeated assembly
if (field->state == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Not enough to assemble
if (bufLen < (sizeof(uint8_t) * repeats)) {
return HITLS_INTERNAL_EXCEPTION;
}
for (uint32_t i = 0; i < repeats; i++) {
uint8_t data = (uint8_t)(field->data);
buf[bufOffset] = data;
bufOffset += sizeof(uint8_t);
*offset += sizeof(uint8_t);
}
return HITLS_SUCCESS;
}
// Assemble 16-bit data(2 bytes)
static int32_t PackInteger16(const FRAME_Integer *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
uint32_t bufOffset = 0;
// No assembly required
if (field->state == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Repeated assembly
if (field->state == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Not enough to assemble
if (bufLen < (sizeof(uint16_t) * repeats)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (field->state == SET_LEN_TO_ONE_BYTE) {
uint8_t data = (uint8_t)field->data;
buf[0] = data;
*offset += sizeof(uint8_t);
return HITLS_SUCCESS;
}
for (uint32_t i = 0; i < repeats; i++) {
uint16_t data = (uint16_t)(field->data);
BSL_Uint16ToByte(data, &buf[bufOffset]);
bufOffset += sizeof(uint16_t);
*offset += sizeof(uint16_t);
}
return HITLS_SUCCESS;
}
// Assemble 24-bit data(3 bytes)
static int32_t PackInteger24(const FRAME_Integer *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
uint32_t bufOffset = 0;
// No assembly required
if (field->state == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Repeated assembly
if (field->state == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Not enough to assemble
if (bufLen < (SIZE_OF_UINT24 * repeats)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (field->state == SET_LEN_TO_ONE_BYTE) {
uint8_t data = (uint8_t)field->data;
buf[0] = data;
*offset += sizeof(uint8_t);
return HITLS_SUCCESS;
}
for (uint32_t i = 0; i < repeats; i++) {
uint32_t data = (uint32_t)field->data;
BSL_Uint24ToByte(data, &buf[bufOffset]);
bufOffset += SIZE_OF_UINT24;
*offset += SIZE_OF_UINT24;
}
return HITLS_SUCCESS;
}
// Assemble 32-bit data(8 bytes)
static int32_t PackInteger32(const FRAME_Integer *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
uint32_t bufOffset = 0;
// No assembly required
if (field->state == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Repeated assembly
if (field->state == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Not enough to assemble
if (bufLen < (SIZE_OF_UINT32 * repeats)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (field->state == SET_LEN_TO_ONE_BYTE) {
uint8_t data = (uint8_t)field->data;
buf[0] = data;
*offset += sizeof(uint8_t);
return HITLS_SUCCESS;
}
for (uint32_t i = 0; i < repeats; i++) {
uint32_t data = (uint32_t)field->data;
BSL_Uint32ToByte(data, &buf[bufOffset]);
bufOffset += SIZE_OF_UINT32;
*offset += SIZE_OF_UINT32;
}
return HITLS_SUCCESS;
}
// Assemble 48-bit data(8 bytes)
static int32_t PackInteger48(const FRAME_Integer *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
uint32_t bufOffset = 0;
// No assembly required
if (field->state == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Repeated assembly
if (field->state == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Not enough to assemble
if (bufLen < (SIZE_OF_UINT48 * repeats)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (field->state == SET_LEN_TO_ONE_BYTE) {
uint8_t data = (uint8_t)field->data;
buf[0] = data;
*offset += sizeof(uint8_t);
return HITLS_SUCCESS;
}
for (uint32_t i = 0; i < repeats; i++) {
uint64_t data = (uint64_t)field->data;
BSL_Uint48ToByte(data, &buf[bufOffset]);
bufOffset += SIZE_OF_UINT48;
*offset += SIZE_OF_UINT48;
}
return HITLS_SUCCESS;
}
// Assembles the buffer of 8-bit data.(1 byte * n)
static int32_t PackArray8(const FRAME_Array8 *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
// No assembly required
if (field->state == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Total length to be assembled
uint32_t length = field->size;
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
if (memcpy_s(buf, bufLen, field->data, field->size) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*offset += length;
return HITLS_SUCCESS;
}
// Assemble the buffer of 16-bit data.(2 bytes * n)
static int32_t PackArray16(const FRAME_Array16 *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
// No assembly required
if (field->state == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Total length to be assembled
uint32_t length = field->size * sizeof(uint16_t);
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t bufoffset = 0;
for (uint32_t i = 0; i < field->size; i++) {
BSL_Uint16ToByte(field->data[i], &buf[bufoffset]);
bufoffset += sizeof(uint16_t);
}
*offset += length;
return HITLS_SUCCESS;
}
static int32_t PackHsExtArray8(const FRAME_HsExtArray8 *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
// This extension does not need to be assembled.
if (field->exState == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Currently, duplicate extension types can be assembled. Only one extension type can be assembled.
if (field->exState == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Calculate the total length to be assembled
uint32_t length = 0;
length += ((field->exType.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exDataLen.state == MISSING_FIELD) ? 0 : sizeof(uint8_t));
length += ((field->exData.state == MISSING_FIELD) ? 0 : sizeof(uint8_t) * field->exData.size);
length *= repeats;
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
// Assembly extension type. Duplicate extensions exist. Currently, assembly is performed twice consecutively.
uint32_t bufoffset = 0;
uint32_t tmpOffset;
for (uint32_t i = 0; i < repeats; i++) {
PackInteger16(&field->exType, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->exLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger8(&field->exDataLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackArray8(&field->exData, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->exLen.state == INITIAL_FIELD) {
uint32_t len = bufoffset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackHsExtArrayForList(const FRAME_HsExtArray8 *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
// This extension does not need to be assembled.
if (field->exState == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Currently, duplicate extension types can be assembled. Only one extension type can be assembled.
if (field->exState == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Calculate the total length to be assembled
uint32_t length = 0;
length += ((field->exType.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exDataLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exData.state == MISSING_FIELD) ? 0 : sizeof(uint8_t) * field->exData.size);
length *= repeats;
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
// Assembly extension type. Duplicate extensions exist. Currently, assembly is performed twice consecutively.
uint32_t bufoffset = 0;
uint32_t tmpOffset;
for (uint32_t i = 0; i < repeats; i++) {
PackInteger16(&field->exType, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->exLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger16(&field->exDataLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackArray8(&field->exData, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->exLen.state == INITIAL_FIELD) {
uint32_t len = bufoffset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackHsExtArrayForTicket(const FRAME_HsExtArray8 *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
// This extension does not need to be assembled.
if (field->exState == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Currently, duplicate extension types can be assembled. Only one extension type can be assembled.
if (field->exState == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Calculate the total length to be assembled
uint32_t length = 0;
length += ((field->exType.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exDataLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exData.state == MISSING_FIELD) ? 0 : sizeof(uint8_t) * field->exData.size);
length *= repeats;
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
// Assembly extension type. Duplicate extensions exist. Currently, assembly is performed twice consecutively.
uint32_t bufoffset = 0;
uint32_t tmpOffset;
for (uint32_t i = 0; i < repeats; i++) {
PackInteger16(&field->exType, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->exDataLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackArray8(&field->exData, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->exDataLen.state == INITIAL_FIELD) {
uint32_t len = bufoffset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackHsExtArray16(const FRAME_HsExtArray16 *field, uint8_t *buf,
uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
// This extension does not need to be assembled.
if (field->exState == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Currently, duplicate extension types can be assembled. Only one extension type can be assembled.
if (field->exState == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Calculate the total length to be assembled
uint32_t length = 0;
length += ((field->exType.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exDataLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exData.state == MISSING_FIELD) ? 0 : sizeof(uint16_t) * field->exData.size);
length *= repeats;
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
// Assembly extension type. Duplicate extensions exist. Currently, assembly is performed twice consecutively.
uint32_t bufoffset = 0;
uint32_t tmpOffset;
for (uint32_t i = 0; i < repeats; i++) {
PackInteger16(&field->exType, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->exLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger16(&field->exDataLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackArray16(&field->exData, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->exLen.state == INITIAL_FIELD) {
uint32_t len = bufoffset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackPskIdentity(const FRAME_HsArrayPskIdentity *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
// This extension does not need to be assembled.
if (field->state == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Duplicate identity arrays are meaningless. The configuration value can be duplicated.
uint32_t bufoffset = 0;
uint32_t tmpOffset = 0;
for (uint32_t j = 0; j < field->size; j++) {
uint32_t innerRepeat = ONE_TIME;
if (field->data[j].state == MISSING_FIELD) {
continue;
}
if (field->data[j].state == DUPLICATE_FIELD) {
innerRepeat = TWO_TIMES;
}
for (uint32_t k = 0; k < innerRepeat; k++) {
tmpOffset = bufoffset;
PackInteger16(&field->data[j].identityLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackArray8(&field->data[j].identity, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->data[j].identityLen.state == INITIAL_FIELD) {
BSL_Uint16ToByte(field->data[j].identity.size, &buf[tmpOffset]);
}
PackInteger32(&field->data[j].obfuscatedTicketAge, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackPskBinder(const FRAME_HsArrayPskBinder *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
// This extension does not need to be assembled.
if (field->state == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Duplicate identity arrays are meaningless. The configuration value can be duplicated.
uint32_t bufoffset = 0;
uint32_t tmpOffset = 0;
for (uint32_t j = 0; j < field->size; j++) {
uint32_t innerRepeat = ONE_TIME;
if (field->data[j].state == MISSING_FIELD) {
continue;
}
if (field->data[j].state == DUPLICATE_FIELD) {
innerRepeat = TWO_TIMES;
}
for (uint32_t k = 0; k < innerRepeat; k++) {
tmpOffset = bufoffset;
PackInteger8(&field->data[j].binderLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackArray8(&field->data[j].binder, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->data[j].binderLen.state == INITIAL_FIELD) {
buf[tmpOffset] = field->data[j].binder.size;
}
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackHsExtCaList(const FRAME_HsExtCaList *field, uint8_t *buf,
uint32_t bufLen, uint32_t *offset)
{
if (field->exState == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Calculate the total length to be assembled
uint32_t length = 0;
length += ((field->exType.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->listSize.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->list.state == MISSING_FIELD) ? 0 : sizeof(uint8_t) * field->list.size);
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t bufoffset = 0;
uint32_t tmpOffset = 0;
PackInteger16(&field->exType, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->exLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger16(&field->listSize, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackArray8(&field->list, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->exLen.state == INITIAL_FIELD) {
uint32_t len = bufoffset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackHsExtOfferedPsks(const FRAME_HsExtOfferedPsks *field, uint8_t *buf,
uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
// This extension does not need to be assembled.
if (field->exState == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Currently, duplicate extension types can be assembled. Only one extension type can be assembled.
if (field->exState == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Calculate the total length to be assembled
uint32_t length = 0;
length += ((field->exType.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += field->exLen.data;
length *= repeats;
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t bufoffset = 0;
uint32_t tmpOffset = 0;
for (uint32_t i = 0; i < repeats; i++) {
PackInteger16(&field->exType, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->exLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger16(&field->identitySize, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
// identity len INITIAL_FIELD Not supported currently
PackPskIdentity(&field->identities, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger16(&field->binderSize, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
// binder len INITIAL_FIELD Not supported currently
PackPskBinder(&field->binders, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->exLen.state == INITIAL_FIELD) {
uint32_t len = bufoffset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackKeyShareArray(const FRAME_HsArrayKeyShare *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
// This extension does not need to be assembled.
if (field->state == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Duplicate key share arrays are meaningless. The configuration value can be duplicated.
uint32_t bufoffset = 0;
uint32_t tmpOffset = 0;
for (uint32_t j = 0; j < field->size; j++) {
uint32_t innerRepeat = ONE_TIME;
if (field->data[j].state == MISSING_FIELD) {
continue;
}
if (field->data[j].state == DUPLICATE_FIELD) {
innerRepeat = TWO_TIMES;
}
for (uint32_t k = 0; k < innerRepeat; k++) {
PackInteger16(&field->data[j].group, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->data[j].keyExchangeLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackArray8(&field->data[j].keyExchange, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->data[j].keyExchangeLen.state == INITIAL_FIELD) {
BSL_Uint16ToByte(field->data[j].keyExchange.size, &buf[tmpOffset]);
}
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackHsExtKeyShare(const FRAME_HsExtKeyShare *field, uint8_t *buf,
uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
// This extension does not need to be assembled.
if (field->exState == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Currently, duplicate extension types can be assembled. Only one extension type can be assembled.
if (field->exState == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Calculate the total length to be assembled
uint32_t length = 0;
length += ((field->exType.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += field->exLen.data;
length *= repeats;
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t bufoffset = 0;
uint32_t tmpOffset = 0;
for (uint32_t i = 0; i < repeats; i++) {
PackInteger16(&field->exType, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->exLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger16(&field->exKeyShareLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
// exKeyShareLen INITIAL_FIELD Not supported currently
PackKeyShareArray(&field->exKeyShares, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->exLen.state == INITIAL_FIELD) {
uint32_t len = bufoffset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackHsExtSupportedVersion(const FRAME_HsExtArray16 *field, uint8_t *buf,
uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
// This extension does not need to be assembled.
if (field->exState == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Currently, duplicate extension types can be assembled. Only one extension type can be assembled.
if (field->exState == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Calculate the total length to be assembled
uint32_t length = 0;
length += ((field->exType.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exDataLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exData.state == MISSING_FIELD) ? 0 : sizeof(uint16_t) * field->exData.size);
length *= repeats;
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
// Assembly extension type. Duplicate extensions exist. Currently, assembly is performed twice consecutively.
uint32_t bufoffset = 0;
uint32_t tmpOffset;
for (uint32_t i = 0; i < repeats; i++) {
PackInteger16(&field->exType, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->exLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger8(&field->exDataLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackArray16(&field->exData, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->exLen.state == INITIAL_FIELD) {
uint32_t len = bufoffset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackClientHelloMsg(const FRAME_ClientHelloMsg *clientHello, uint8_t *buf,
uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
uint32_t bufOffset;
PackInteger16(&clientHello->version, &buf[offset], bufLen, &offset);
PackArray8(&clientHello->randomValue, &buf[offset], bufLen - offset, &offset);
PackInteger8(&clientHello->sessionIdSize, &buf[offset], bufLen - offset, &offset);
PackArray8(&clientHello->sessionId, &buf[offset], bufLen - offset, &offset);
PackInteger8(&clientHello->cookiedLen, &buf[offset], bufLen - offset, &offset);
PackArray8(&clientHello->cookie, &buf[offset], bufLen - offset, &offset);
PackInteger16(&clientHello->cipherSuitesSize, &buf[offset], bufLen - offset, &offset);
PackArray16(&clientHello->cipherSuites, &buf[offset], bufLen - offset, &offset);
PackInteger8(&clientHello->compressionMethodsLen, &buf[offset], bufLen - offset, &offset);
PackArray8(&clientHello->compressionMethods, &buf[offset], bufLen - offset, &offset);
bufOffset = offset;
if (clientHello->extensionState != MISSING_FIELD) {
PackInteger16(&clientHello->extensionLen, &buf[offset], bufLen - offset, &offset);
if (clientHello->extensionLen.state == SET_LEN_TO_ONE_BYTE) {
goto EXIT;
}
PackHsExtArrayForList(&clientHello->serverName, &buf[offset], bufLen - offset, &offset);
PackHsExtArray16(&clientHello->signatureAlgorithms, &buf[offset], bufLen - offset, &offset);
PackHsExtArray16(&clientHello->supportedGroups, &buf[offset], bufLen - offset, &offset);
PackHsExtArray8(&clientHello->pointFormats, &buf[offset], bufLen - offset, &offset);
PackHsExtSupportedVersion(&clientHello->supportedVersion, &buf[offset], bufLen - offset, &offset);
PackHsExtArrayForList(&clientHello->tls13Cookie, &buf[offset], bufLen - offset, &offset);
PackHsExtArray8(&clientHello->extendedMasterSecret, &buf[offset], bufLen - offset, &offset);
PackHsExtArrayForList(&clientHello->alpn, &buf[offset], bufLen - offset, &offset);
PackHsExtArray8(&clientHello->pskModes, &buf[offset], bufLen - offset, &offset);
PackHsExtKeyShare(&clientHello->keyshares, &buf[offset], bufLen - offset, &offset);
PackHsExtArray8(&clientHello->secRenego, &buf[offset], bufLen - offset, &offset);
PackHsExtArrayForTicket(&clientHello->sessionTicket, &buf[offset], bufLen - offset, &offset);
PackHsExtArray8(&clientHello->encryptThenMac, &buf[offset], bufLen - offset, &offset);
PackHsExtOfferedPsks(&clientHello->psks, &buf[offset], bufLen - offset, &offset);
PackHsExtCaList(&clientHello->caList, &buf[offset], bufLen - offset, &offset);
if (clientHello->extensionLen.state == INITIAL_FIELD) {
uint32_t extensionLen = offset - sizeof(uint16_t) - bufOffset;
BSL_Uint16ToByte(extensionLen, &buf[bufOffset]);
}
}
EXIT:
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackHsExtUint16(const FRAME_HsExtUint16 *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
// This extension does not need to be assembled.
if (field->exState == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Currently, duplicate extension types can be assembled. Only one extension type can be assembled.
if (field->exState == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Calculate the total length to be assembled
uint32_t length = 0;
length += ((field->exType.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += field->exLen.data;
length *= repeats;
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
// Assembly extension type. Duplicate extensions exist. Currently, assembly is performed twice consecutively.
uint32_t bufoffset = 0;
uint32_t tmpOffset;
for (uint32_t i = 0; i < repeats; i++) {
PackInteger16(&field->exType, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->exLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger16(&field->data, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->exLen.state == INITIAL_FIELD) {
uint32_t len = bufoffset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackHsExtServerKeyShare(
const FRAME_HsExtServerKeyShare *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
// This extension does not need to be assembled.
if (field->exState == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Currently, duplicate extension types can be assembled. Only one extension type can be assembled.
if (field->exState == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Calculate the total length to be assembled
uint32_t length = 0;
length += ((field->exType.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += field->exLen.data;
length *= repeats;
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
// Assembly extension type. Duplicate extensions exist. Currently, assembly is performed twice consecutively.
uint32_t bufoffset = 0;
uint32_t tmpOffset;
for (uint32_t i = 0; i < repeats; i++) {
PackInteger16(&field->exType, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->exLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger16(&field->data.group, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger16(&field->data.keyExchangeLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackArray8(&field->data.keyExchange, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->exLen.state == INITIAL_FIELD) {
uint32_t len = bufoffset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackServerHelloMsg(const FRAME_ServerHelloMsg *serverHello, uint8_t *buf,
uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
uint32_t bufOffset;
PackInteger16(&serverHello->version, &buf[offset], bufLen, &offset);
PackArray8(&serverHello->randomValue, &buf[offset], bufLen - offset, &offset);
PackInteger8(&serverHello->sessionIdSize, &buf[offset], bufLen - offset, &offset);
PackArray8(&serverHello->sessionId, &buf[offset], bufLen - offset, &offset);
PackInteger16(&serverHello->cipherSuite, &buf[offset], bufLen - offset, &offset);
PackInteger8(&serverHello->compressionMethod, &buf[offset], bufLen - offset, &offset);
bufOffset = offset;
PackInteger16(&serverHello->extensionLen, &buf[offset], bufLen - offset, &offset);
PackHsExtArrayForList(&serverHello->serverName, &buf[offset], bufLen - offset, &offset);
PackHsExtArrayForList(&serverHello->tls13Cookie, &buf[offset], bufLen - offset, &offset);
PackHsExtArrayForTicket(&serverHello->sessionTicket, &buf[offset], bufLen - offset, &offset);
PackHsExtUint16(&serverHello->supportedVersion, &buf[offset], bufLen - offset, &offset);
PackHsExtArray8(&serverHello->extendedMasterSecret, &buf[offset], bufLen - offset, &offset);
PackHsExtArrayForList(&serverHello->alpn, &buf[offset], bufLen - offset, &offset);
PackHsExtServerKeyShare(&serverHello->keyShare, &buf[offset], bufLen - offset, &offset);
// hello retry request key share
PackHsExtArray8(&serverHello->secRenego, &buf[offset], bufLen - offset, &offset);
PackHsExtArray8(&serverHello->pointFormats, &buf[offset], bufLen - offset, &offset);
PackHsExtUint16(&serverHello->pskSelectedIdentity, &buf[offset], bufLen - offset, &offset);
// encrypt then mac
PackHsExtArray8(&serverHello->encryptThenMac, &buf[offset], bufLen - offset, &offset);
if (serverHello->extensionLen.state == INITIAL_FIELD) {
uint32_t extensionLen = offset - sizeof(uint16_t) - bufOffset;
BSL_Uint16ToByte(extensionLen, &buf[bufOffset]);
}
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackCertificateMsg(FRAME_Type *type, const FRAME_CertificateMsg *certificate, uint8_t *buf,
uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
uint32_t bufOffset;
if (type->versionType == HITLS_VERSION_TLS13) {
PackInteger8(&certificate->certificateReqCtxSize, &buf[offset], bufLen - offset, &offset);
PackArray8(&certificate->certificateReqCtx, &buf[offset], bufLen - offset, &offset);
}
bufOffset = offset;
PackInteger24(&certificate->certsLen, &buf[offset], bufLen - offset, &offset);
const FrameCertItem *next = certificate->certItem;
while (next != NULL) {
if (next->state == MISSING_FIELD) {
break;
}
PackInteger24(&next->certLen, &buf[offset], bufLen - offset, &offset);
PackArray8(&next->cert, &buf[offset], bufLen - offset, &offset);
if (type->versionType == HITLS_VERSION_TLS13) {
PackInteger16(&next->extensionLen, &buf[offset], bufLen - offset, &offset);
PackArray8(&next->extension, &buf[offset], bufLen - offset, &offset);
}
next = next->next;
}
if (certificate->certsLen.state == INITIAL_FIELD) {
uint32_t certsLen = offset - SIZE_OF_UINT24 - bufOffset;
BSL_Uint24ToByte(certsLen, &buf[bufOffset]);
}
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackServerEcdheMsg(FRAME_Type *type, const FRAME_ServerKeyExchangeMsg *serverKeyExchange, uint8_t *buf,
uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
// Fill in the following values in sequence: curve type, curve ID, pubkeylen, pubkey value, signature algorithm,
// signature len, and signature value.
PackInteger8(&serverKeyExchange->keyEx.ecdh.curveType, &buf[offset], bufLen, &offset);
PackInteger16(&serverKeyExchange->keyEx.ecdh.namedcurve, &buf[offset], bufLen - offset, &offset);
PackInteger8(&serverKeyExchange->keyEx.ecdh.pubKeySize, &buf[offset], bufLen- offset, &offset);
PackArray8(&serverKeyExchange->keyEx.ecdh.pubKey, &buf[offset], bufLen- offset, &offset);
if (((IS_DTLS_VERSION(type->versionType)) && (type->versionType <= HITLS_VERSION_DTLS12)) ||
((!IS_DTLS_VERSION(type->versionType)) && (type->versionType >= HITLS_VERSION_TLS12))) {
// DTLS1.2, TLS1.2, and later versions
PackInteger16(&serverKeyExchange->keyEx.ecdh.signAlgorithm, &buf[offset], bufLen- offset, &offset);
}
PackInteger16(&serverKeyExchange->keyEx.ecdh.signSize, &buf[offset], bufLen- offset, &offset);
PackArray8(&serverKeyExchange->keyEx.ecdh.signData, &buf[offset], bufLen- offset, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackServerDheMsg(FRAME_Type *type, const FRAME_ServerKeyExchangeMsg *serverKeyExchange, uint8_t *buf,
uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
// Fill in the following values in sequence: plen, p value, glen, g value, pubkeylen, pubkey value,
// signature algorithm, signature len, and signature value.
PackInteger16(&serverKeyExchange->keyEx.dh.plen, &buf[offset], bufLen, &offset);
PackArray8(&serverKeyExchange->keyEx.dh.p, &buf[offset], bufLen - offset, &offset);
PackInteger16(&serverKeyExchange->keyEx.dh.glen, &buf[offset], bufLen - offset, &offset);
PackArray8(&serverKeyExchange->keyEx.dh.g, &buf[offset], bufLen - offset, &offset);
PackInteger16(&serverKeyExchange->keyEx.dh.pubKeyLen, &buf[offset], bufLen- offset, &offset);
PackArray8(&serverKeyExchange->keyEx.dh.pubKey, &buf[offset], bufLen- offset, &offset);
if (((IS_DTLS_VERSION(type->versionType)) && (type->versionType <= HITLS_VERSION_DTLS12)) ||
((!IS_DTLS_VERSION(type->versionType)) && (type->versionType >= HITLS_VERSION_TLS12))) {
// DTLS1.2, TLS1.2, and later versions
PackInteger16(&serverKeyExchange->keyEx.dh.signAlgorithm, &buf[offset], bufLen- offset, &offset);
}
PackInteger16(&serverKeyExchange->keyEx.dh.signSize, &buf[offset], bufLen- offset, &offset);
PackArray8(&serverKeyExchange->keyEx.dh.signData, &buf[offset], bufLen- offset, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackServerEccMsg(const FRAME_ServerKeyExchangeMsg *serverKeyExchange, uint8_t *buf,
uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
PackInteger16(&serverKeyExchange->keyEx.ecdh.signSize, &buf[offset], bufLen- offset, &offset);
PackArray8(&serverKeyExchange->keyEx.ecdh.signData, &buf[offset], bufLen- offset, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackServerKeyExchangeMsg(FRAME_Type *type, const FRAME_ServerKeyExchangeMsg *serverKeyExchange,
uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
// Currently, ECDHE and DHE key exchange packets can be assembled.
if (type->keyExType == HITLS_KEY_EXCH_ECDHE) {
return PackServerEcdheMsg(type, serverKeyExchange, buf, bufLen, usedLen);
} else if (type->keyExType == HITLS_KEY_EXCH_DHE) {
return PackServerDheMsg(type, serverKeyExchange, buf, bufLen, usedLen);
} else if (type->keyExType == HITLS_KEY_EXCH_ECC) {
return PackServerEccMsg(serverKeyExchange, buf, bufLen, usedLen);
}
return HITLS_PACK_UNSUPPORT_KX_ALG;
}
static int32_t PackCertificateRequestExt(uint32_t type, const FRAME_CertificateRequestMsg *certificateRequest,
uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
FRAME_Integer exType;
FRAME_Integer size;
switch (type) {
case HS_EX_TYPE_SIGNATURE_ALGORITHMS:
exType.data = HS_EX_TYPE_SIGNATURE_ALGORITHMS;
exType.state = INITIAL_FIELD;
PackInteger16(&exType, &buf[offset], bufLen, &offset);
size.data = certificateRequest->signatureAlgorithmsSize.data + sizeof(uint16_t);
size.state = INITIAL_FIELD;
PackInteger16(&size, &buf[offset], bufLen, &offset);
PackInteger16(&certificateRequest->signatureAlgorithmsSize, &buf[offset], bufLen, &offset);
PackArray16(&certificateRequest->signatureAlgorithms, &buf[offset], bufLen - offset, &offset);
break;
default:
break;
}
*usedLen += offset;
return HITLS_SUCCESS;
}
static int32_t PackCertificateRequestMsg(FRAME_Type *type, const FRAME_CertificateRequestMsg *certificateRequest,
uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
if (certificateRequest->state == MISSING_FIELD){
return HITLS_SUCCESS;
}
if (type->versionType != HITLS_VERSION_TLS13) {
PackInteger8(&certificateRequest->certTypesSize, &buf[offset], bufLen, &offset);
PackArray8(&certificateRequest->certTypes, &buf[offset], bufLen - offset, &offset);
PackInteger16(&certificateRequest->signatureAlgorithmsSize, &buf[offset], bufLen, &offset);
PackArray16(&certificateRequest->signatureAlgorithms, &buf[offset], bufLen - offset, &offset);
PackInteger16(&certificateRequest->distinguishedNamesSize, &buf[offset], bufLen, &offset);
PackArray8(&certificateRequest->distinguishedNames, &buf[offset], bufLen - offset, &offset);
} else {
PackInteger8(&certificateRequest->certificateReqCtxSize, &buf[offset], bufLen, &offset);
PackArray8(&certificateRequest->certificateReqCtx, &buf[offset], bufLen - offset, &offset);
// Packaged extension
uint32_t tmpOffset = offset;
PackInteger16(&certificateRequest->exMsgLen, &buf[offset], bufLen, &offset);
bool ifPackSign = (certificateRequest->signatureAlgorithmsSize.state != MISSING_FIELD);
// Package HS_EX_TYPE_SIGNATURE_ALGORITHMS Extensions
if(ifPackSign) {
PackCertificateRequestExt(HS_EX_TYPE_SIGNATURE_ALGORITHMS, certificateRequest, &buf[offset],
bufLen - offset, &offset);
}
if(certificateRequest->signatureAlgorithmsSize.state == DUPLICATE_FIELD) {
PackCertificateRequestExt(HS_EX_TYPE_SIGNATURE_ALGORITHMS, certificateRequest, &buf[offset],
bufLen - offset, &offset);
}
if (certificateRequest->exMsgLen.state == INITIAL_FIELD) {
uint32_t len = offset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
}
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackServerHelloDoneMsg(const FRAME_ServerHelloDoneMsg *serverHelloDone, uint8_t *buf,
uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
/* The ServerHelloDone packet is an empty packet. Extra data is assembled here to construct abnormal packets. */
PackArray8(&serverHelloDone->extra, &buf[offset], bufLen, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackClientEcdheMsg(FRAME_Type *type, const FRAME_ClientKeyExchangeMsg *clientKeyExchange, uint8_t *buf,
uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
if (type->versionType == HITLS_VERSION_TLCP_DTLCP11) { /* Three bytes are added to the client key exchange. */
buf[offset] = HITLS_EC_CURVE_TYPE_NAMED_CURVE;
offset += sizeof(uint8_t);
BSL_Uint16ToByte(HITLS_EC_GROUP_SM2, &buf[offset]);
offset += sizeof(uint16_t);
}
PackInteger8(&clientKeyExchange->pubKeySize, &buf[offset], bufLen, &offset);
PackArray8(&clientKeyExchange->pubKey, &buf[offset], bufLen - offset, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackClientDheMsg(const FRAME_ClientKeyExchangeMsg *clientKeyExchange, uint8_t *buf,
uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
PackInteger16(&clientKeyExchange->pubKeySize, &buf[offset], bufLen, &offset);
PackArray8(&clientKeyExchange->pubKey, &buf[offset], bufLen - offset, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackClientKeyExchangeMsg(FRAME_Type *type, const FRAME_ClientKeyExchangeMsg *clientKeyExchange,
uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
// Currently, ECDHE and DHE key exchange packets can be assembled.
if (type->keyExType == HITLS_KEY_EXCH_ECDHE) {
return PackClientEcdheMsg(type, clientKeyExchange, buf, bufLen, usedLen);
} else if (type->keyExType == HITLS_KEY_EXCH_DHE || type->keyExType == HITLS_KEY_EXCH_RSA) {
return PackClientDheMsg(clientKeyExchange, buf, bufLen, usedLen);
}
return HITLS_PACK_UNSUPPORT_KX_ALG;
}
static int32_t PackCertificateVerifyMsg(FRAME_Type *type, const FRAME_CertificateVerifyMsg *certificateVerify,
uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
if (((IS_DTLS_VERSION(type->versionType)) && (type->versionType <= HITLS_VERSION_DTLS12)) ||
((!IS_DTLS_VERSION(type->versionType)) && (type->versionType >= HITLS_VERSION_TLS12))) {
// DTLS1.2, TLS1.2, and later versions
PackInteger16(&certificateVerify->signHashAlg, &buf[offset], bufLen, &offset);
}
PackInteger16(&certificateVerify->signSize, &buf[offset], bufLen - offset, &offset);
PackArray8(&certificateVerify->sign, &buf[offset], bufLen - offset, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackFinishedMsg(const FRAME_FinishedMsg *finished, uint8_t *buf,
uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
PackArray8(&finished->verifyData, &buf[offset], bufLen - offset, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static void PackHsMsgHeader(uint16_t version, const FRAME_HsMsg *hsMsg, uint32_t bodyLen,
uint8_t *buf, uint32_t bufLen, uint32_t *usedLen, BSL_UIO_TransportType transportType)
{
(void)version;
uint32_t offset = 0;
uint32_t bufOffset;
PackInteger8(&hsMsg->type, &buf[offset], bufLen, &offset);
bufOffset = offset;
PackInteger24(&hsMsg->length, &buf[offset], bufLen - offset, &offset);
if (IS_TRANSTYPE_DATAGRAM(transportType)) {
PackInteger16(&hsMsg->sequence, &buf[offset], bufLen - offset, &offset);
PackInteger24(&hsMsg->fragmentOffset, &buf[offset], bufLen - offset, &offset);
if (hsMsg->fragmentLength.state == INITIAL_FIELD) {
BSL_Uint24ToByte(bodyLen, &buf[offset]);
offset += SIZE_OF_UINT24;
} else {
PackInteger24(&hsMsg->fragmentLength, &buf[offset], bufLen - offset, &offset);
}
}
if (hsMsg->length.state == INITIAL_FIELD) {
BSL_Uint24ToByte(bodyLen, &buf[bufOffset]);
}
*usedLen = offset;
}
static int32_t PackNewSessionTicketMsg(FRAME_Type *type, const FRAME_NewSessionTicketMsg *newSessionTicket,
uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
PackInteger32(&newSessionTicket->ticketLifetime, &buf[offset], bufLen - offset, &offset);
if (type->versionType != HITLS_VERSION_TLS13) {
PackInteger16(&newSessionTicket->ticketSize, &buf[offset], bufLen - offset, &offset);
PackArray8(&newSessionTicket->ticket, &buf[offset], bufLen - offset, &offset);
} else {
PackInteger32(&newSessionTicket->ticketAgeAdd, &buf[offset], bufLen - offset, &offset);
PackInteger8(&newSessionTicket->ticketNonceSize, &buf[offset], bufLen - offset, &offset);
PackArray8(&newSessionTicket->ticketNonce, &buf[offset], bufLen - offset, &offset);
PackInteger16(&newSessionTicket->ticketSize, &buf[offset], bufLen - offset, &offset);
PackArray8(&newSessionTicket->ticket, &buf[offset], bufLen - offset, &offset);
PackInteger16(&newSessionTicket->extensionLen, &buf[offset], bufLen - offset, &offset);
}
*usedLen = offset;
if (offset != bufLen) {
return HITLS_PACK_UNSUPPORT_HANDSHAKE_MSG;
}
return HITLS_SUCCESS;
}
static int32_t PackHsMsgBody(FRAME_Type *type, const FRAME_Msg *msg,
uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
int32_t ret;
const FRAME_HsMsg *hsMsg = &(msg->body.hsMsg);
switch (type->handshakeType) {
case CLIENT_HELLO:
ret = PackClientHelloMsg(&(hsMsg->body.clientHello), buf, bufLen, usedLen);
break;
case SERVER_HELLO:
ret = PackServerHelloMsg(&(hsMsg->body.serverHello), buf, bufLen, usedLen);
break;
case CERTIFICATE:
ret = PackCertificateMsg(type, &(hsMsg->body.certificate), buf, bufLen, usedLen);
break;
case SERVER_KEY_EXCHANGE:
ret = PackServerKeyExchangeMsg(type, &(hsMsg->body.serverKeyExchange), buf, bufLen, usedLen);
break;
case CERTIFICATE_REQUEST:
ret = PackCertificateRequestMsg(type, &(hsMsg->body.certificateReq), buf, bufLen, usedLen);
break;
case SERVER_HELLO_DONE:
ret = PackServerHelloDoneMsg(&(hsMsg->body.serverHelloDone), buf, bufLen, usedLen);
break;
case CLIENT_KEY_EXCHANGE:
ret = PackClientKeyExchangeMsg(type, &(hsMsg->body.clientKeyExchange), buf, bufLen, usedLen);
break;
case CERTIFICATE_VERIFY:
ret = PackCertificateVerifyMsg(type, &(hsMsg->body.certificateVerify), buf, bufLen, usedLen);
break;
case FINISHED:
ret = PackFinishedMsg(&(hsMsg->body.finished), buf, bufLen, usedLen);
break;
case NEW_SESSION_TICKET:
ret = PackNewSessionTicketMsg(type, &(hsMsg->body.newSessionTicket), buf, bufLen, usedLen);
break;
default:
ret = HITLS_PACK_UNSUPPORT_HANDSHAKE_MSG;
break;
}
return ret;
}
static int32_t PackHandShakeMsg(FRAME_Type *type, const FRAME_Msg *msg,
uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
const FRAME_HsMsg *hsMsg = &(msg->body.hsMsg);
uint32_t ret;
uint32_t offset;
uint32_t bodyMaxLen;
uint32_t headerLen;
uint32_t bodyLen = 0;
if (IS_TRANSTYPE_DATAGRAM(type->transportType)) { // DTLS
if (bufLen < DTLS_HS_MSG_HEADER_SIZE) {
return HITLS_INTERNAL_EXCEPTION;
}
bodyMaxLen = bufLen - DTLS_HS_MSG_HEADER_SIZE;
offset = DTLS_HS_MSG_HEADER_SIZE;
headerLen = DTLS_HS_MSG_HEADER_SIZE;
} else { // TLS
if (bufLen < HS_MSG_HEADER_SIZE) {
return HITLS_INTERNAL_EXCEPTION;
}
bodyMaxLen = bufLen - HS_MSG_HEADER_SIZE;
offset = HS_MSG_HEADER_SIZE;
headerLen = HS_MSG_HEADER_SIZE;
}
// Assemble the body of the handshake message.
ret = PackHsMsgBody(type, msg, &buf[offset], bodyMaxLen, &bodyLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
// Assemble the handshake packet header.
PackHsMsgHeader(type->versionType, hsMsg, bodyLen, buf, headerLen, &headerLen, type->transportType);
// Splicing body and head
// If some fields are missing in the header, the packet body is filled with an offset forward.
if (headerLen != offset) {
ret = memmove_s(&buf[headerLen], bufLen - headerLen, &buf[offset], bodyLen);
if (ret != EOK) {
return ret;
}
}
*usedLen = headerLen + bodyLen;
return ret;
}
static int32_t PackCcsMsg(const FRAME_Msg *msg, uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
PackInteger8(&msg->body.ccsMsg.ccsType, &buf[offset], bufLen, &offset);
/* Extra data is used to construct abnormal packets. */
PackArray8(&msg->body.ccsMsg.extra, &buf[offset], bufLen - offset, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackAlertMsg(const FRAME_Msg *msg, uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
PackInteger8(&msg->body.alertMsg.alertLevel, &buf[offset], bufLen, &offset);
PackInteger8(&msg->body.alertMsg.alertDescription, &buf[offset], bufLen - offset, &offset);
/* Extra data is used to construct abnormal packets. */
PackArray8(&msg->body.alertMsg.extra, &buf[offset], bufLen - offset, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackAppMsg(const FRAME_Msg *msg, uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
PackArray8(&msg->body.appMsg.appData, &buf[offset], bufLen, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackRecordHeader(uint16_t version, const FRAME_Msg *msg, uint32_t bodyLen,
uint8_t *buf, uint32_t bufLen, uint32_t *usedLen, BSL_UIO_TransportType transportType)
{
(void)version;
uint32_t offset = 0;
PackInteger8(&msg->recType, &buf[offset], bufLen, &offset);
PackInteger16(&msg->recVersion, &buf[offset], bufLen - offset, &offset);
if (IS_TRANSTYPE_DATAGRAM(transportType)) {
PackInteger16(&msg->epoch, &buf[offset], bufLen - offset, &offset);
PackInteger48(&msg->sequence, &buf[offset], bufLen - offset, &offset);
}
if (msg->length.state == INITIAL_FIELD) {
BSL_Uint16ToByte(bodyLen, &buf[offset]);
offset += sizeof(uint16_t);
} else {
PackInteger16(&msg->length, &buf[offset], bufLen - offset, &offset);
}
*usedLen = offset;
return HITLS_SUCCESS;
}
int32_t FRAME_PackRecordBody(FRAME_Type *frameType, const FRAME_Msg *msg,
uint8_t *buffer, uint32_t bufLen, uint32_t *usedLen)
{
int32_t ret;
// pack Body
switch (frameType->recordType) {
case REC_TYPE_HANDSHAKE:
ret = PackHandShakeMsg(frameType, msg, buffer, bufLen, usedLen);
break;
case REC_TYPE_CHANGE_CIPHER_SPEC:
ret = PackCcsMsg(msg, buffer, bufLen, usedLen);
break;
case REC_TYPE_ALERT:
ret = PackAlertMsg(msg, buffer, bufLen, usedLen);
break;
case REC_TYPE_APP:
ret = PackAppMsg(msg, buffer, bufLen, usedLen);
break;
default:
ret = HITLS_INTERNAL_EXCEPTION;
break;
}
return ret;
}
int32_t FRAME_PackMsg(FRAME_Type *frameType, const FRAME_Msg *msg, uint8_t *buffer, uint32_t bufLen, uint32_t *usedLen)
{
int32_t ret;
uint32_t offset;
uint32_t bodyMaxLen;
uint32_t headerLen;
uint32_t bodyLen = 0;
if (msg == NULL || buffer == NULL || usedLen == NULL) {
return HITLS_INTERNAL_EXCEPTION;
}
if (IS_TRANSTYPE_DATAGRAM(frameType->transportType)) { // DTLS
if (bufLen < DTLS_RECORD_HEADER_LEN) {
return HITLS_INTERNAL_EXCEPTION;
}
bodyMaxLen = bufLen - DTLS_RECORD_HEADER_LEN;
offset = DTLS_RECORD_HEADER_LEN;
headerLen = DTLS_RECORD_HEADER_LEN;
} else { // TLS
if (bufLen < TLS_RECORD_HEADER_LEN) {
return HITLS_INTERNAL_EXCEPTION;
}
bodyMaxLen = bufLen - TLS_RECORD_HEADER_LEN;
offset = TLS_RECORD_HEADER_LEN;
headerLen = TLS_RECORD_HEADER_LEN;
}
// Assemble the message body.
ret = FRAME_PackRecordBody(frameType, msg, &buffer[offset], bodyMaxLen, &bodyLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
// Assemble the packet header.
PackRecordHeader(frameType->versionType, msg, bodyLen, buffer, headerLen, &headerLen, frameType->transportType);
// Splicing body and head
// If some fields are missing in the header, the packet body is filled with an offset forward.
if (headerLen != offset) {
ret = memmove_s(&buffer[headerLen], bufLen - headerLen, &buffer[offset], bodyLen);
if (ret != EOK) {
return ret;
}
}
*usedLen = headerLen + bodyLen;
return ret;
}
int32_t FRAME_GetTls13DisorderHsMsg(HS_MsgType type, uint8_t *buffer, uint32_t bufLen, uint32_t *usedLen)
{
if (bufLen < 5) {
return HITLS_INTERNAL_EXCEPTION;
}
buffer[0] = type;
buffer[1] = 0;
buffer[2] = 0;
buffer[3] = 1;
buffer[4] = 0;
*usedLen = 5;
return HITLS_SUCCESS;
} | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/msg/src/frame_pack_msg.c | C | unknown | 55,281 |
/*
* 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 "securec.h"
#include "bsl_bytes.h"
#include "bsl_sal.h"
#include "hitls_error.h"
#include "hitls_crypt_type.h"
#include "tls.h"
#include "hs_ctx.h"
#include "hs_extensions.h"
#include "frame_tls.h"
#include "frame_msg.h"
#define SIZE_OF_UINT_24 3u
#define SIZE_OF_UINT_48 6u
static int32_t ParseFieldInteger8(const uint8_t *buffer, uint32_t bufLen, FRAME_Integer *field, uint32_t *offset)
{
if (bufLen < sizeof(uint8_t)) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
field->state = INITIAL_FIELD;
field->data = buffer[0];
*offset += sizeof(uint8_t);
return HITLS_SUCCESS;
}
static int32_t ParseFieldInteger16(const uint8_t *buffer, uint32_t bufLen, FRAME_Integer *field, uint32_t *offset)
{
if (bufLen < sizeof(uint16_t)) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
field->state = INITIAL_FIELD;
field->data = BSL_ByteToUint16(buffer);
*offset += sizeof(uint16_t);
return HITLS_SUCCESS;
}
static int32_t ParseFieldInteger24(const uint8_t *buffer, uint32_t bufLen, FRAME_Integer *field, uint32_t *offset)
{
if (bufLen < SIZE_OF_UINT_24) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
field->state = INITIAL_FIELD;
field->data = BSL_ByteToUint24(buffer);
*offset += SIZE_OF_UINT_24;
return HITLS_SUCCESS;
}
static int32_t ParseFieldInteger32(const uint8_t *buffer, uint32_t bufLen, FRAME_Integer *field, uint32_t *offset)
{
if (bufLen < sizeof(uint32_t)) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
field->state = INITIAL_FIELD;
field->data = BSL_ByteToUint32(buffer);
*offset += sizeof(uint32_t);
return HITLS_SUCCESS;
}
static int32_t ParseFieldInteger48(const uint8_t *buffer, uint32_t bufLen, FRAME_Integer *field, uint32_t *offset)
{
if (bufLen < SIZE_OF_UINT_48) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
field->state = INITIAL_FIELD;
field->data = BSL_ByteToUint48(buffer);
*offset += SIZE_OF_UINT_48;
return HITLS_SUCCESS;
}
static int32_t ParseFieldArray8(const uint8_t *buffer, uint32_t bufLen, FRAME_Array8 *field, uint32_t fieldLen,
uint32_t *offset)
{
if (bufLen < fieldLen) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
BSL_SAL_FREE(field->data);
field->data = BSL_SAL_Dump(buffer, fieldLen);
if (field->data == NULL) {
return HITLS_MEMALLOC_FAIL;
}
field->size = fieldLen;
field->state = INITIAL_FIELD;
*offset += fieldLen;
return HITLS_SUCCESS;
}
static int32_t ParseFieldArray16(const uint8_t *buffer, uint32_t bufLen, FRAME_Array16 *field, uint32_t fieldLen,
uint32_t *offset)
{
if ((bufLen < fieldLen) || (fieldLen % sizeof(uint16_t) != 0)) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
field->data = BSL_SAL_Calloc(1u, fieldLen);
if (field->data == NULL) {
return HITLS_MEMALLOC_FAIL;
}
field->size = fieldLen / sizeof(uint16_t);
for (uint32_t i = 0; i < field->size; i++) {
field->data[i] = BSL_ByteToUint16(&buffer[i * sizeof(uint16_t)]);
}
field->state = INITIAL_FIELD;
*offset += fieldLen;
return HITLS_SUCCESS;
}
static int32_t ParseHsExtArray8(const uint8_t *buffer, uint32_t bufLen, FRAME_HsExtArray8 *field, uint32_t *offset)
{
uint32_t exOffset = 0;
field->exState = INITIAL_FIELD;
ParseFieldInteger16(&buffer[0], bufLen, &field->exType, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exLen, &exOffset);
if (field->exLen.data == 0u) {
*offset += exOffset;
return HITLS_SUCCESS;
}
ParseFieldInteger8(&buffer[exOffset], bufLen - exOffset, &field->exDataLen, &exOffset);
ParseFieldArray8(&buffer[exOffset], bufLen - exOffset, &field->exData, field->exDataLen.data, &exOffset);
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseHsExtArrayForList(
const uint8_t *buffer, uint32_t bufLen, FRAME_HsExtArray8 *field, uint32_t *offset)
{
uint32_t exOffset = 0;
field->exState = INITIAL_FIELD;
ParseFieldInteger16(&buffer[0], bufLen, &field->exType, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exLen, &exOffset);
if (field->exLen.data == 0u) {
*offset += exOffset;
return HITLS_SUCCESS;
}
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exDataLen, &exOffset);
ParseFieldArray8(&buffer[exOffset], bufLen - exOffset, &field->exData, field->exDataLen.data, &exOffset);
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseHsSessionTicketExtArray8(
const uint8_t *buffer, uint32_t bufLen, FRAME_HsExtArray8 *field, uint32_t *offset)
{
uint32_t exOffset = 0;
field->exState = INITIAL_FIELD;
ParseFieldInteger16(&buffer[0], bufLen, &field->exType, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exDataLen, &exOffset);
if (field->exDataLen.data == 0u) {
*offset += exOffset;
return HITLS_SUCCESS;
}
ParseFieldArray8(&buffer[exOffset], bufLen - exOffset, &field->exData, field->exDataLen.data, &exOffset);
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseHsExtArray16(const uint8_t *buffer, uint32_t bufLen, FRAME_HsExtArray16 *field, uint32_t *offset)
{
uint32_t exOffset = 0;
field->exState = INITIAL_FIELD;
ParseFieldInteger16(&buffer[0], bufLen - exOffset, &field->exType, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exLen, &exOffset);
if (field->exLen.data == 0u) {
*offset += exOffset;
return HITLS_SUCCESS;
}
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exDataLen, &exOffset);
ParseFieldArray16(&buffer[exOffset], bufLen - exOffset, &field->exData, field->exDataLen.data, &exOffset);
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseHsExtPskIdentity(const uint8_t *buffer, uint32_t bufLen, FRAME_HsArrayPskIdentity *field,
uint32_t fieldLen, uint32_t *offset)
{
uint32_t exOffset = 0;
field->state = INITIAL_FIELD;
uint32_t size = 0;
FRAME_Integer tmpIdentityLen = { 0 };
while (exOffset < fieldLen) {
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &tmpIdentityLen, &exOffset);
exOffset += (tmpIdentityLen.data + sizeof(uint32_t));
if (exOffset <= fieldLen) {
size++;
}
}
if (size == 0) {
return HITLS_SUCCESS;
}
field->data = BSL_SAL_Calloc(size, sizeof(FRAME_HsPskIdentity));
if (field->data == NULL) {
return HITLS_MEMALLOC_FAIL;
}
field->size = size;
exOffset = 0;
for (uint32_t i = 0; i < size; i++) {
field->data[i].state = INITIAL_FIELD;
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->data[i].identityLen, &exOffset);
ParseFieldArray8(&buffer[exOffset], bufLen - exOffset, &field->data[i].identity,
field->data[i].identityLen.data, &exOffset);
ParseFieldInteger32(&buffer[exOffset], bufLen - exOffset, &field->data[i].obfuscatedTicketAge, &exOffset);
}
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseHsExtPskBinder(const uint8_t *buffer, uint32_t bufLen, FRAME_HsArrayPskBinder *field,
uint32_t fieldLen, uint32_t *offset)
{
uint32_t exOffset = 0;
field->state = INITIAL_FIELD;
uint32_t size = 0;
FRAME_Integer tmpBinderLen = { 0 };
while (exOffset < fieldLen) {
ParseFieldInteger8(&buffer[exOffset], bufLen - exOffset, &tmpBinderLen, &exOffset);
exOffset += tmpBinderLen.data;
if (exOffset <= fieldLen) {
size++;
}
}
if (size == 0) {
return HITLS_SUCCESS;
}
field->data = BSL_SAL_Calloc(size, sizeof(FRAME_HsPskBinder));
if (field->data == NULL) {
return HITLS_MEMALLOC_FAIL;
}
field->size = size;
exOffset = 0;
for (uint32_t i = 0; i < size; i++) {
field->data[i].state = INITIAL_FIELD;
ParseFieldInteger8(&buffer[exOffset], bufLen - exOffset, &field->data[i].binderLen, &exOffset);
ParseFieldArray8(&buffer[exOffset], bufLen - exOffset, &field->data[i].binder,
field->data[i].binderLen.data, &exOffset);
}
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseHsExtPsk(const uint8_t *buffer, uint32_t bufLen, FRAME_HsExtOfferedPsks *field, uint32_t *offset)
{
uint32_t exOffset = 0;
field->exState = INITIAL_FIELD;
ParseFieldInteger16(&buffer[0], bufLen - exOffset, &field->exType, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exLen, &exOffset);
if (field->exLen.data == 0u) {
*offset += exOffset;
return HITLS_SUCCESS;
}
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->identitySize, &exOffset);
ParseHsExtPskIdentity(&buffer[exOffset], bufLen - exOffset, &field->identities,
field->identitySize.data, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->binderSize, &exOffset);
ParseHsExtPskBinder(&buffer[exOffset], bufLen - exOffset, &field->binders, field->binderSize.data, &exOffset);
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseHsExtArrayKeyShare(const uint8_t *buffer, uint32_t bufLen, FRAME_HsArrayKeyShare *field,
uint32_t fieldLen, uint32_t *offset)
{
uint32_t exOffset = 0;
field->state = INITIAL_FIELD;
uint32_t size = 0;
FRAME_Integer tmpIdentityLen = { 0 };
while (exOffset < fieldLen) {
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &tmpIdentityLen, &exOffset); // group
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &tmpIdentityLen, &exOffset); // key_exchange len
exOffset += tmpIdentityLen.data;
if (exOffset <= fieldLen) {
size++;
}
}
if (size == 0) {
return HITLS_SUCCESS;
}
field->data = BSL_SAL_Calloc(size, sizeof(FRAME_HsKeyShareEntry));
if (field->data == NULL) {
return HITLS_MEMALLOC_FAIL;
}
field->size = size;
exOffset = 0;
for (uint32_t i = 0; i < size; i++) {
field->data[i].state = INITIAL_FIELD;
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->data[i].group, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->data[i].keyExchangeLen, &exOffset);
ParseFieldArray8(&buffer[exOffset], bufLen - exOffset, &field->data[i].keyExchange,
field->data[i].keyExchangeLen.data, &exOffset);
}
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseHsExtKeyShare(const uint8_t *buffer, uint32_t bufLen, FRAME_HsExtKeyShare *field, uint32_t *offset)
{
uint32_t exOffset = 0;
field->exState = INITIAL_FIELD;
ParseFieldInteger16(&buffer[0], bufLen - exOffset, &field->exType, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exLen, &exOffset);
if (field->exLen.data == 0u) {
*offset += exOffset;
return HITLS_SUCCESS;
}
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exKeyShareLen, &exOffset);
ParseHsExtArrayKeyShare(&buffer[exOffset], bufLen - exOffset, &field->exKeyShares,
field->exKeyShareLen.data, &exOffset);
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseHsSupportedVersion(const uint8_t *buffer, uint32_t bufLen,
FRAME_HsExtArray16 *field, uint32_t *offset)
{
uint32_t exOffset = 0;
field->exState = INITIAL_FIELD;
ParseFieldInteger16(&buffer[0], bufLen - exOffset, &field->exType, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exLen, &exOffset);
if (field->exLen.data == 0u) {
*offset += exOffset;
return HITLS_SUCCESS;
}
ParseFieldInteger8(&buffer[exOffset], bufLen - exOffset, &field->exDataLen, &exOffset);
ParseFieldArray16(&buffer[exOffset], bufLen - exOffset, &field->exData, field->exDataLen.data, &exOffset);
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseClientHelloMsg(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_ClientHelloMsg *clientHello, uint32_t *parseLen)
{
uint32_t offset = 0;
ParseFieldInteger16(&buffer[0], bufLen, &clientHello->version, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &clientHello->randomValue, HS_RANDOM_SIZE, &offset);
ParseFieldInteger8(&buffer[offset], bufLen - offset, &clientHello->sessionIdSize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &clientHello->sessionId,
clientHello->sessionIdSize.data, &offset);
if (IS_TRANSTYPE_DATAGRAM(frameType->transportType)) {
ParseFieldInteger8(&buffer[offset], bufLen - offset, &clientHello->cookiedLen, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &clientHello->cookie, clientHello->cookiedLen.data, &offset);
}
ParseFieldInteger16(&buffer[offset], bufLen - offset, &clientHello->cipherSuitesSize, &offset);
ParseFieldArray16(&buffer[offset], bufLen - offset, &clientHello->cipherSuites,
clientHello->cipherSuitesSize.data, &offset);
ParseFieldInteger8(&buffer[offset], bufLen - offset, &clientHello->compressionMethodsLen, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &clientHello->compressionMethods,
clientHello->compressionMethodsLen.data, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &clientHello->extensionLen, &offset);
clientHello->extensionState = INITIAL_FIELD;
/* Parsing extended fields */
while (offset < bufLen) {
FRAME_Integer tmpField = {0};
uint32_t tmpOffset = offset;
ParseFieldInteger16(&buffer[tmpOffset], bufLen - tmpOffset, &tmpField, &tmpOffset);
switch (tmpField.data) {
case HS_EX_TYPE_POINT_FORMATS:
ParseHsExtArray8(&buffer[offset], bufLen - offset, &clientHello->pointFormats, &offset);
break;
case HS_EX_TYPE_SUPPORTED_GROUPS:
ParseHsExtArray16(&buffer[offset], bufLen - offset, &clientHello->supportedGroups, &offset);
break;
case HS_EX_TYPE_SIGNATURE_ALGORITHMS:
ParseHsExtArray16(&buffer[offset], bufLen - offset, &clientHello->signatureAlgorithms, &offset);
break;
case HS_EX_TYPE_EXTENDED_MASTER_SECRET:
ParseHsExtArray8(&buffer[offset], bufLen - offset, &clientHello->extendedMasterSecret, &offset);
break;
case HS_EX_TYPE_RENEGOTIATION_INFO:
ParseHsExtArray8(&buffer[offset], bufLen - offset, &clientHello->secRenego, &offset);
break;
case HS_EX_TYPE_SESSION_TICKET:
ParseHsSessionTicketExtArray8(&buffer[offset], bufLen - offset, &clientHello->sessionTicket, &offset);
break;
case HS_EX_TYPE_SERVER_NAME:
ParseHsExtArrayForList(&buffer[offset], bufLen - offset, &clientHello->serverName, &offset);
break;
case HS_EX_TYPE_APP_LAYER_PROTOCOLS:
ParseHsExtArrayForList(&buffer[offset], bufLen - offset, &clientHello->alpn, &offset);
break;
case HS_EX_TYPE_KEY_SHARE:
ParseHsExtKeyShare(&buffer[offset], bufLen - offset, &clientHello->keyshares, &offset);
break;
case HS_EX_TYPE_PRE_SHARED_KEY:
ParseHsExtPsk(&buffer[offset], bufLen - offset, &clientHello->psks, &offset);
break;
case HS_EX_TYPE_PSK_KEY_EXCHANGE_MODES:
ParseHsExtArray8(&buffer[offset], bufLen - offset, &clientHello->pskModes, &offset);
break;
case HS_EX_TYPE_SUPPORTED_VERSIONS:
ParseHsSupportedVersion(&buffer[offset], bufLen - offset, &clientHello->supportedVersion, &offset);
break;
case HS_EX_TYPE_COOKIE:
ParseHsExtArrayForList(&buffer[offset], bufLen - offset, &clientHello->tls13Cookie, &offset);
break;
case HS_EX_TYPE_ENCRYPT_THEN_MAC:
ParseHsExtArray8(&buffer[offset], bufLen - offset, &clientHello->encryptThenMac, &offset);
break;
default: /* Unrecognized extension. Skip parsing the extension. */
ParseFieldInteger16(&buffer[tmpOffset], bufLen - tmpOffset, &tmpField, &tmpOffset);
tmpOffset += tmpField.data;
offset = tmpOffset;
break;
}
if (tmpOffset == offset) {
break;
}
}
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanClientHelloMsg(FRAME_ClientHelloMsg *clientHello)
{
BSL_SAL_FREE(clientHello->randomValue.data);
BSL_SAL_FREE(clientHello->sessionId.data);
BSL_SAL_FREE(clientHello->cookie.data);
BSL_SAL_FREE(clientHello->cipherSuites.data);
BSL_SAL_FREE(clientHello->compressionMethods.data);
BSL_SAL_FREE(clientHello->pointFormats.exData.data);
BSL_SAL_FREE(clientHello->supportedGroups.exData.data);
BSL_SAL_FREE(clientHello->signatureAlgorithms.exData.data);
BSL_SAL_FREE(clientHello->extendedMasterSecret.exData.data);
BSL_SAL_FREE(clientHello->secRenego.exData.data);
BSL_SAL_FREE(clientHello->sessionTicket.exData.data);
BSL_SAL_FREE(clientHello->serverName.exData.data);
BSL_SAL_FREE(clientHello->alpn.exData.data);
for (uint32_t i = 0; i < clientHello->keyshares.exKeyShares.size; i++) {
BSL_SAL_FREE(clientHello->keyshares.exKeyShares.data[i].keyExchange.data);
}
for (uint32_t i = 0; i < clientHello->psks.identities.size; i++) {
BSL_SAL_FREE(clientHello->psks.identities.data[i].identity.data);
}
for (uint32_t i = 0; i < clientHello->psks.binders.size; i++) {
BSL_SAL_FREE(clientHello->psks.binders.data[i].binder.data);
}
BSL_SAL_FREE(clientHello->keyshares.exKeyShares.data);
BSL_SAL_FREE(clientHello->psks.binders.data);
BSL_SAL_FREE(clientHello->psks.identities.data);
BSL_SAL_FREE(clientHello->supportedVersion.exData.data);
BSL_SAL_FREE(clientHello->tls13Cookie.exData.data);
BSL_SAL_FREE(clientHello->pskModes.exData.data);
BSL_SAL_FREE(clientHello->caList.list.data);
return;
}
static int32_t ParseHsExtUint16(const uint8_t *buffer, uint32_t bufLen, FRAME_HsExtUint16 *field, uint32_t *offset)
{
uint32_t exOffset = 0;
field->exState = INITIAL_FIELD;
ParseFieldInteger16(&buffer[0], bufLen, &field->exType, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exLen, &exOffset);
if (field->exLen.data == 0u) {
*offset += exOffset;
return HITLS_SUCCESS;
}
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->data, &exOffset);
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseHsExtServerKeyShare(const uint8_t *buffer, uint32_t bufLen,
FRAME_HsExtServerKeyShare *field, uint32_t *offset)
{
uint32_t exOffset = 0;
field->exState = INITIAL_FIELD;
ParseFieldInteger16(&buffer[0], bufLen, &field->exType, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exLen, &exOffset);
if (field->exLen.data == 0u) {
*offset += exOffset;
return HITLS_SUCCESS;
}
field->data.state = INITIAL_FIELD;
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->data.group, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->data.keyExchangeLen, &exOffset);
ParseFieldArray8(&buffer[exOffset], bufLen - exOffset, &field->data.keyExchange,
field->data.keyExchangeLen.data, &exOffset);
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseServerHelloMsg(const uint8_t *buffer, uint32_t bufLen, FRAME_ServerHelloMsg *serverHello,
uint32_t *parseLen)
{
uint32_t offset = 0;
ParseFieldInteger16(&buffer[0], bufLen, &serverHello->version, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &serverHello->randomValue, HS_RANDOM_SIZE, &offset);
ParseFieldInteger8(&buffer[offset], bufLen - offset, &serverHello->sessionIdSize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &serverHello->sessionId,
serverHello->sessionIdSize.data, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &serverHello->cipherSuite, &offset);
ParseFieldInteger8(&buffer[offset], bufLen - offset, &serverHello->compressionMethod, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &serverHello->extensionLen, &offset);
/* Parsing extended fields */
while (offset < bufLen) {
FRAME_Integer tmpField = {0};
uint32_t tmpOffset = offset;
ParseFieldInteger16(&buffer[tmpOffset], bufLen - tmpOffset, &tmpField, &tmpOffset);
switch (tmpField.data) {
case HS_EX_TYPE_POINT_FORMATS:
ParseHsExtArray8(&buffer[offset], bufLen - offset, &serverHello->pointFormats, &offset);
break;
case HS_EX_TYPE_EXTENDED_MASTER_SECRET:
ParseHsExtArray8(&buffer[offset], bufLen - offset, &serverHello->extendedMasterSecret, &offset);
break;
case HS_EX_TYPE_RENEGOTIATION_INFO:
ParseHsExtArray8(&buffer[offset], bufLen - offset, &serverHello->secRenego, &offset);
break;
case HS_EX_TYPE_SESSION_TICKET:
ParseHsSessionTicketExtArray8(&buffer[offset], bufLen - offset, &serverHello->sessionTicket, &offset);
break;
case HS_EX_TYPE_SERVER_NAME:
ParseHsExtArrayForList(&buffer[offset], bufLen - offset, &serverHello->serverName, &offset);
break;
case HS_EX_TYPE_APP_LAYER_PROTOCOLS:
ParseHsExtArrayForList(&buffer[offset], bufLen - offset, &serverHello->alpn, &offset);
break;
case HS_EX_TYPE_SUPPORTED_VERSIONS:
ParseHsExtUint16(&buffer[offset], bufLen - offset, &serverHello->supportedVersion, &offset);
break;
case HS_EX_TYPE_KEY_SHARE:
ParseHsExtServerKeyShare(&buffer[offset], bufLen - offset, &serverHello->keyShare, &offset);
break;
case HS_EX_TYPE_PRE_SHARED_KEY:
ParseHsExtUint16(&buffer[offset], bufLen - offset, &serverHello->pskSelectedIdentity, &offset);
break;
case HS_EX_TYPE_COOKIE:
ParseHsExtArray8(&buffer[offset], bufLen - offset, &serverHello->tls13Cookie, &offset);
break;
case HS_EX_TYPE_ENCRYPT_THEN_MAC:
ParseHsExtArray8(&buffer[offset], bufLen - offset, &serverHello->encryptThenMac, &offset);
break;
default: /* Unrecognized extension, return error */
*parseLen += offset;
return HITLS_PARSE_UNSUPPORTED_EXTENSION;
}
}
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanServerHelloMsg(FRAME_ServerHelloMsg *serverHello)
{
BSL_SAL_FREE(serverHello->randomValue.data);
BSL_SAL_FREE(serverHello->sessionId.data);
BSL_SAL_FREE(serverHello->pointFormats.exData.data);
BSL_SAL_FREE(serverHello->extendedMasterSecret.exData.data);
BSL_SAL_FREE(serverHello->secRenego.exData.data);
BSL_SAL_FREE(serverHello->sessionTicket.exData.data);
BSL_SAL_FREE(serverHello->serverName.exData.data);
BSL_SAL_FREE(serverHello->alpn.exData.data);
BSL_SAL_FREE(serverHello->keyShare.data.keyExchange.data);
BSL_SAL_FREE(serverHello->tls13Cookie.exData.data);
return;
}
static int32_t ParseCertificateMsg(
FRAME_Type *type, const uint8_t *buffer, uint32_t bufLen, FRAME_CertificateMsg *certificate, uint32_t *parseLen)
{
uint32_t offset = 0;
if (type->versionType == HITLS_VERSION_TLS13) {
ParseFieldInteger8(&buffer[0], bufLen, &certificate->certificateReqCtxSize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &certificate->certificateReqCtx,
certificate->certificateReqCtxSize.data, &offset);
}
ParseFieldInteger24(&buffer[offset], bufLen - offset, &certificate->certsLen, &offset);
if (certificate->certsLen.data == 0) {
*parseLen += offset;
return HITLS_SUCCESS;
}
FrameCertItem *certItem = NULL;
while (offset < bufLen) {
uint32_t tmpOffset = offset;
FrameCertItem *item = BSL_SAL_Calloc(1u, sizeof(FrameCertItem));
if (item == NULL) {
return HITLS_MEMALLOC_FAIL;
}
item->state = INITIAL_FIELD;
ParseFieldInteger24(&buffer[offset], bufLen - offset, &item->certLen, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &item->cert, item->certLen.data, &offset);
if (type->versionType == HITLS_VERSION_TLS13) {
ParseFieldInteger16(&buffer[offset], bufLen - offset, &item->extensionLen, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &item->extension, item->extensionLen.data, &offset);
}
if (certificate->certItem == NULL) {
certificate->certItem = item;
} else {
certItem->next = item;
}
certItem = item;
if (tmpOffset == offset) {
break;
}
}
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanCertificateMsg(FRAME_CertificateMsg *certificate)
{
BSL_SAL_FREE(certificate->certificateReqCtx.data);
FrameCertItem *certItem = certificate->certItem;
while (certItem != NULL) {
FrameCertItem *temp = certItem->next;
BSL_SAL_FREE(certItem->cert.data);
BSL_SAL_FREE(certItem->extension.data);
BSL_SAL_FREE(certItem);
certItem = temp;
}
certificate->certItem = NULL;
return;
}
static int32_t ParseServerKxEcdhMsg(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_ServerEcdh *ecdh, uint32_t *parseLen)
{
uint32_t offset = 0;
ParseFieldInteger8(&buffer[0], bufLen, &ecdh->curveType, &offset);
if (ecdh->curveType.data != HITLS_EC_CURVE_TYPE_NAMED_CURVE) {
return HITLS_PARSE_UNSUPPORT_KX_ALG;
}
ParseFieldInteger16(&buffer[offset], bufLen - offset, &ecdh->namedcurve, &offset);
ParseFieldInteger8(&buffer[offset], bufLen - offset, &ecdh->pubKeySize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &ecdh->pubKey, ecdh->pubKeySize.data, &offset);
if (((!IS_DTLS_VERSION(frameType->versionType)) && (frameType->versionType >= HITLS_VERSION_TLS12)) ||
((IS_DTLS_VERSION(frameType->versionType)) && (frameType->versionType <= HITLS_VERSION_DTLS12))) {
ParseFieldInteger16(&buffer[offset], bufLen - offset, &ecdh->signAlgorithm, &offset);
}
ParseFieldInteger16(&buffer[offset], bufLen - offset, &ecdh->signSize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &ecdh->signData, ecdh->signSize.data, &offset);
*parseLen += offset;
return HITLS_SUCCESS;
}
static int32_t ParseServerKxDhMsg(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_ServerDh *dh, uint32_t *parseLen)
{
uint32_t offset = 0;
ParseFieldInteger16(&buffer[0], bufLen, &dh->plen, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &dh->p, dh->plen.data, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &dh->glen, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &dh->g, dh->glen.data, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &dh->pubKeyLen, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &dh->pubKey, dh->pubKeyLen.data, &offset);
if (((!IS_DTLS_VERSION(frameType->versionType)) && (frameType->versionType >= HITLS_VERSION_TLS12)) ||
((IS_DTLS_VERSION(frameType->versionType)) && (frameType->versionType <= HITLS_VERSION_DTLS12))) {
ParseFieldInteger16(&buffer[offset], bufLen - offset, &dh->signAlgorithm, &offset);
}
ParseFieldInteger16(&buffer[offset], bufLen - offset, &dh->signSize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &dh->signData, dh->signSize.data, &offset);
*parseLen += offset;
return HITLS_SUCCESS;
}
static int32_t ParseServerKxEccMsg(const uint8_t *buffer, uint32_t bufLen,
FRAME_ServerEcdh *ecdh, uint32_t *parseLen)
{
uint32_t offset = 0;
ParseFieldInteger16(&buffer[offset], bufLen - offset, &ecdh->signSize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &ecdh->signData, ecdh->signSize.data, &offset);
*parseLen += offset;
return HITLS_SUCCESS;
}
static int32_t ParseServerKxMsg(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_ServerKeyExchangeMsg *serverKx, uint32_t *parseLen)
{
switch (frameType->keyExType) {
case HITLS_KEY_EXCH_ECDHE:
return ParseServerKxEcdhMsg(frameType, buffer, bufLen, &serverKx->keyEx.ecdh, parseLen);
case HITLS_KEY_EXCH_DHE:
return ParseServerKxDhMsg(frameType, buffer, bufLen, &serverKx->keyEx.dh, parseLen);
case HITLS_KEY_EXCH_ECC:
return ParseServerKxEccMsg(buffer, bufLen, &serverKx->keyEx.ecdh, parseLen);
default:
break;
}
return HITLS_PARSE_UNSUPPORT_KX_ALG;
}
static void CleanServerKxMsg(HITLS_KeyExchAlgo kexType, FRAME_ServerKeyExchangeMsg *serverKx)
{
FRAME_ServerEcdh *ecdh = &serverKx->keyEx.ecdh;
FRAME_ServerDh *dh = &serverKx->keyEx.dh;
switch (kexType) {
case HITLS_KEY_EXCH_ECDHE:
BSL_SAL_FREE(ecdh->pubKey.data);
BSL_SAL_FREE(ecdh->signData.data);
break;
case HITLS_KEY_EXCH_DHE:
BSL_SAL_FREE(dh->p.data);
BSL_SAL_FREE(dh->g.data);
BSL_SAL_FREE(dh->pubKey.data);
BSL_SAL_FREE(dh->signData.data);
break;
default:
break;
}
return;
}
static int32_t ParseCertReqMsgExBody(uint16_t extMsgType, const uint8_t *buffer, uint32_t bufLen,
FRAME_CertificateRequestMsg *certReq, uint32_t *parseLen)
{
uint32_t offset = 0;
switch (extMsgType) {
case HS_EX_TYPE_SIGNATURE_ALGORITHMS:
ParseFieldInteger16(&buffer[offset], bufLen - offset, &certReq->signatureAlgorithmsSize, &offset);
ParseFieldArray16(&buffer[offset], bufLen - offset, &certReq->signatureAlgorithms,
certReq->signatureAlgorithmsSize.data, &offset);
break;
default:
break;
}
*parseLen += offset;
return HITLS_SUCCESS;
}
static int32_t ParseCertReqMsg(
FRAME_Type *type, const uint8_t *buffer, uint32_t bufLen, FRAME_CertificateRequestMsg *certReq, uint32_t *parseLen)
{
uint32_t offset = 0;
certReq->state = INITIAL_FIELD;
if (type->versionType != HITLS_VERSION_TLS13) {
ParseFieldInteger8(&buffer[0], bufLen, &certReq->certTypesSize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &certReq->certTypes, certReq->certTypesSize.data, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &certReq->signatureAlgorithmsSize, &offset);
ParseFieldArray16(&buffer[offset], bufLen - offset, &certReq->signatureAlgorithms,
certReq->signatureAlgorithmsSize.data, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &certReq->distinguishedNamesSize, &offset);
if (certReq->distinguishedNamesSize.data != 0u) {
ParseFieldArray8(&buffer[offset], bufLen - offset, &certReq->distinguishedNames,
certReq->distinguishedNamesSize.data, &offset);
}
} else {
ParseFieldInteger8(&buffer[0], bufLen, &certReq->certificateReqCtxSize, &offset);
ParseFieldArray8(&buffer[offset],
bufLen - offset,
&certReq->certificateReqCtx,
certReq->certificateReqCtxSize.data,
&offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &certReq->exMsgLen, &offset);
while (offset < bufLen) {
uint32_t tmpOffset = offset;
FRAME_Integer extMsgType ;
FRAME_Integer extMsgLen ;
ParseFieldInteger16(&buffer[offset], bufLen - offset, &extMsgType, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &extMsgLen, &offset);
ParseCertReqMsgExBody(extMsgType.data, &buffer[offset], bufLen - offset, certReq, &offset);
if (offset == tmpOffset) {
break;
}
}
}
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanCertReqMsg(FRAME_CertificateRequestMsg *certReq)
{
BSL_SAL_FREE(certReq->certTypes.data);
BSL_SAL_FREE(certReq->signatureAlgorithms.data);
BSL_SAL_FREE(certReq->distinguishedNames.data);
BSL_SAL_FREE(certReq->certificateReqCtx.data);
return;
}
static int32_t ParseServerHelloDoneMsg(uint32_t bufLen)
{
if (bufLen != 0) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
return HITLS_SUCCESS;
}
static void CleanServerHelloDoneMsg(FRAME_ServerHelloDoneMsg *serverHelloDone)
{
/* The ServerHelloDone packet is an empty packet. If there is any constructed data, release it. */
BSL_SAL_FREE(serverHelloDone->extra.data);
return;
}
static int32_t ParseClientKxMsg(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_ClientKeyExchangeMsg *clientKx, uint32_t *parseLen)
{
uint32_t offset = 0;
switch (frameType->keyExType) {
case HITLS_KEY_EXCH_ECDHE:
/* Compatible with OpenSSL. Three bytes are added to the client key exchange. */
#ifdef HITLS_TLS_PROTO_TLCP11
if (frameType->versionType == HITLS_VERSION_TLCP_DTLCP11) {
// Curve type + Curve ID + Public key length
uint8_t minLen = sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint8_t);
if (bufLen < minLen) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
// Ignore the first three bytes.
offset += sizeof(uint8_t) + sizeof(uint16_t);
}
#endif
ParseFieldInteger8(&buffer[offset], bufLen - offset, &clientKx->pubKeySize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &clientKx->pubKey, clientKx->pubKeySize.data, &offset);
break;
case HITLS_KEY_EXCH_DHE:
case HITLS_KEY_EXCH_RSA:
ParseFieldInteger16(&buffer[offset], bufLen - offset, &clientKx->pubKeySize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &clientKx->pubKey, clientKx->pubKeySize.data, &offset);
break;
default:
return HITLS_PARSE_UNSUPPORT_KX_ALG;
}
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanClientKxMsg(FRAME_ClientKeyExchangeMsg *clientKx)
{
BSL_SAL_FREE(clientKx->pubKey.data);
return;
}
static int32_t ParseCertVerifyMsg(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_CertificateVerifyMsg *certVerify, uint32_t *parseLen)
{
uint32_t offset = 0;
if (((!IS_DTLS_VERSION(frameType->versionType)) && (frameType->versionType >= HITLS_VERSION_TLS12)) ||
((IS_DTLS_VERSION(frameType->versionType)) && (frameType->versionType <= HITLS_VERSION_DTLS12))) {
ParseFieldInteger16(&buffer[0], bufLen, &certVerify->signHashAlg, &offset);
}
ParseFieldInteger16(&buffer[offset], bufLen - offset, &certVerify->signSize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &certVerify->sign, certVerify->signSize.data, &offset);
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanCertVerifyMsg(FRAME_CertificateVerifyMsg *certVerify)
{
BSL_SAL_FREE(certVerify->sign.data);
return;
}
static int32_t ParseFinishedMsg(const uint8_t *buffer, uint32_t bufLen, FRAME_FinishedMsg *finished, uint32_t *parseLen)
{
uint32_t offset = 0;
ParseFieldArray8(buffer, bufLen, &finished->verifyData, bufLen, &offset);
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanFinishedMsg(FRAME_FinishedMsg *finished)
{
BSL_SAL_FREE(finished->verifyData.data);
return;
}
static int32_t ParseNewSessionTicket(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_NewSessionTicketMsg *sessionTicket, uint32_t *parseLen)
{
uint32_t offset = 0;
ParseFieldInteger32(&buffer[0], bufLen, &sessionTicket->ticketLifetime, &offset);
if (frameType->versionType != HITLS_VERSION_TLS13) {
ParseFieldInteger16(&buffer[offset], bufLen - offset, &sessionTicket->ticketSize, &offset);
ParseFieldArray8(
&buffer[offset], bufLen - offset, &sessionTicket->ticket, sessionTicket->ticketSize.data, &offset);
} else {
ParseFieldInteger32(&buffer[offset], bufLen - offset, &sessionTicket->ticketAgeAdd, &offset);
ParseFieldInteger8(&buffer[offset], bufLen - offset, &sessionTicket->ticketNonceSize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &sessionTicket->ticketNonce,
sessionTicket->ticketNonceSize.data, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &sessionTicket->ticketSize, &offset);
ParseFieldArray8(
&buffer[offset], bufLen - offset, &sessionTicket->ticket, sessionTicket->ticketSize.data, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &sessionTicket->extensionLen, &offset);
while (offset < bufLen) {
FRAME_Integer tmpField = {0};
uint32_t tmpOffset = offset;
ParseFieldInteger16(&buffer[tmpOffset], bufLen - tmpOffset, &tmpField, &tmpOffset);
switch (tmpField.data) {
default:
/* The extensions in the tls 1.3 new session ticket cannot be parsed currently. Skip this step. */
ParseFieldInteger16(&buffer[tmpOffset], bufLen - tmpOffset, &tmpField, &tmpOffset);
tmpOffset += tmpField.data;
offset = tmpOffset;
break;
}
}
}
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanNewSessionTicket(FRAME_NewSessionTicketMsg *sessionTicket)
{
BSL_SAL_FREE(sessionTicket->ticket.data);
BSL_SAL_FREE(sessionTicket->ticketNonce.data);
return;
}
static int32_t ParseHsMsg(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_HsMsg *hsMsg, uint32_t *parseLen)
{
uint32_t offset = 0;
ParseFieldInteger8(&buffer[0], bufLen, &hsMsg->type, &offset);
ParseFieldInteger24(&buffer[offset], bufLen - offset, &hsMsg->length, &offset);
if (IS_TRANSTYPE_DATAGRAM(frameType->transportType)) {
ParseFieldInteger16(&buffer[offset], bufLen - offset, &hsMsg->sequence, &offset);
ParseFieldInteger24(&buffer[offset], bufLen - offset, &hsMsg->fragmentOffset, &offset);
ParseFieldInteger24(&buffer[offset], bufLen - offset, &hsMsg->fragmentLength, &offset);
}
*parseLen += offset;
/* To ensure that the memory can be normally released after users modify hsMsg->type.data,
* assign a value to frameType. */
frameType->handshakeType = hsMsg->type.data;
switch (hsMsg->type.data) {
case CLIENT_HELLO:
return ParseClientHelloMsg(frameType, &buffer[offset], bufLen - offset, &hsMsg->body.clientHello, parseLen);
case SERVER_HELLO:
return ParseServerHelloMsg(&buffer[offset], bufLen - offset, &hsMsg->body.serverHello, parseLen);
case CERTIFICATE:
return ParseCertificateMsg(frameType, &buffer[offset], bufLen - offset, &hsMsg->body.certificate, parseLen);
case SERVER_KEY_EXCHANGE:
return ParseServerKxMsg(frameType, &buffer[offset], bufLen - offset, &hsMsg->body.serverKeyExchange,
parseLen);
case CERTIFICATE_REQUEST:
return ParseCertReqMsg(frameType, &buffer[offset], bufLen - offset, &hsMsg->body.certificateReq, parseLen);
case CLIENT_KEY_EXCHANGE:
return ParseClientKxMsg(frameType, &buffer[offset], bufLen - offset, &hsMsg->body.clientKeyExchange,
parseLen);
case CERTIFICATE_VERIFY:
return ParseCertVerifyMsg(frameType, &buffer[offset], bufLen - offset, &hsMsg->body.certificateVerify,
parseLen);
case FINISHED:
return ParseFinishedMsg(&buffer[offset], bufLen - offset, &hsMsg->body.finished, parseLen);
case SERVER_HELLO_DONE:
return ParseServerHelloDoneMsg(bufLen - offset);
case NEW_SESSION_TICKET:
return ParseNewSessionTicket(frameType, &buffer[offset], bufLen - offset, &hsMsg->body.newSessionTicket,
parseLen);
default:
break;
}
return HITLS_PARSE_UNSUPPORT_HANDSHAKE_MSG;
}
static int32_t ParseCcsMsg(const uint8_t *buffer, uint32_t bufLen, FRAME_CcsMsg *ccsMsg, uint32_t *parseLen)
{
/* The length of the CCS message is 1 byte. */
if (bufLen != 1u) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
uint32_t offset = 0;
ParseFieldInteger8(buffer, bufLen, &ccsMsg->ccsType, &offset);
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanCcsMsg(FRAME_CcsMsg *ccsMsg)
{
/* This field is used to construct abnormal packets. Data is not written during parsing. However,
* users may apply for memory. Therefore, this field needs to be released. */
BSL_SAL_FREE(ccsMsg->extra.data);
return;
}
static int32_t ParseAlertMsg(const uint8_t *buffer, uint32_t bufLen, FRAME_AlertMsg *alertMsg, uint32_t *parseLen)
{
/* The length of the alert message is 2 bytes. */
if (bufLen != 2u) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
uint32_t offset = 0;
ParseFieldInteger8(&buffer[0], bufLen, &alertMsg->alertLevel, &offset);
ParseFieldInteger8(&buffer[offset], bufLen - offset, &alertMsg->alertDescription, &offset);
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanAlertMsg(FRAME_AlertMsg *alertMsg)
{
/* This field is used to construct abnormal packets. Data is not written during parsing.
* However, users may apply for memory. Therefore, this field needs to be released. */
BSL_SAL_FREE(alertMsg->extra.data);
return;
}
static int32_t ParseAppMsg(const uint8_t *buffer, uint32_t bufLen, FRAME_AppMsg *appMsg, uint32_t *parseLen)
{
if (bufLen == 0u) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
uint32_t offset = 0;
ParseFieldArray8(buffer, bufLen, &appMsg->appData, bufLen, &offset);
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanAppMsg(FRAME_AppMsg *appMsg)
{
BSL_SAL_FREE(appMsg->appData.data);
return;
}
int32_t FRAME_ParseMsgHeader(
FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen, FRAME_Msg *msg, uint32_t *parseLen)
{
if ((frameType == NULL) || (buffer == NULL) || (msg == NULL) || (parseLen == NULL)) {
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t offset = 0;
ParseFieldInteger8(&buffer[0], bufLen, &msg->recType, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &msg->recVersion, &offset);
if (IS_TRANSTYPE_DATAGRAM(frameType->transportType)) {
ParseFieldInteger16(&buffer[offset], bufLen - offset, &msg->epoch, &offset);
ParseFieldInteger48(&buffer[offset], bufLen - offset, &msg->sequence, &offset);
}
ParseFieldInteger16(&buffer[offset], bufLen - offset, &msg->length, &offset);
if ((msg->length.data + offset) > bufLen) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
*parseLen = offset;
return HITLS_SUCCESS;
}
int32_t FRAME_ParseTLSRecordHeader(const uint8_t *buffer, uint32_t bufferLen, FRAME_Msg *msg, uint32_t *parsedLen)
{
if ((buffer == NULL) || (msg == NULL) || (parsedLen == NULL)) {
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t offset = 0;
// Parse the 0th byte of the buffer. The parsing result is stored in msg->recType, offset = 1.
ParseFieldInteger8(buffer, bufferLen, &msg->recType, &offset);
// Parse the first and second bytes of the buffer. The parsing result is stored in msg->recVersion, offset = 3.
ParseFieldInteger16(buffer + offset, bufferLen - offset, &msg->recVersion, &offset);
// Parse the third to fourth bytes of the buffer. The parsing result is stored in msg->length, and offset = 5.
ParseFieldInteger16(buffer + offset, bufferLen - offset, &msg->length, &offset);
// msg->length.data indicates the length of the parsed record body.
// In this case, the value of offset is the header length.
if ((msg->length.data + offset) > bufferLen) {
// The length of the entire message cannot be greater than bufLen.
return HITLS_PARSE_INVALID_MSG_LEN;
}
*parsedLen = offset;
return HITLS_SUCCESS;
}
// Parse the body of a non-handshake record.
int32_t FRAME_ParseTLSNonHsRecordBody(const uint8_t *buffer, uint32_t bufferLen, FRAME_Msg *msg, uint32_t *parseLen)
{
if ((buffer == NULL) || (msg == NULL) || (parseLen == NULL)) {
return HITLS_INTERNAL_EXCEPTION;
}
switch (msg->recType.data) {
case REC_TYPE_CHANGE_CIPHER_SPEC:
return ParseCcsMsg(buffer, bufferLen, &msg->body.ccsMsg, parseLen);
case REC_TYPE_ALERT:
return ParseAlertMsg(buffer, bufferLen, &msg->body.alertMsg, parseLen);
case REC_TYPE_APP:
return ParseAppMsg(buffer, bufferLen, &msg->body.appMsg, parseLen);
default:
break;
}
return HITLS_INTERNAL_EXCEPTION;
}
int32_t FRAME_ParseMsgBody(
FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen, FRAME_Msg *msg, uint32_t *parseLen)
{
if ((frameType == NULL) || (buffer == NULL) || (msg == NULL) || (parseLen == NULL)) {
return HITLS_INTERNAL_EXCEPTION;
}
/* To ensure that the memory can be normally released after users modify msg->recType.data,
* assign a value to frameType. */
frameType->recordType = msg->recType.data;
switch (msg->recType.data) {
case REC_TYPE_HANDSHAKE:
return ParseHsMsg(frameType, buffer, bufLen, &msg->body.hsMsg, parseLen);
case REC_TYPE_CHANGE_CIPHER_SPEC:
return ParseCcsMsg(buffer, bufLen, &msg->body.ccsMsg, parseLen);
case REC_TYPE_ALERT:
return ParseAlertMsg(buffer, bufLen, &msg->body.alertMsg, parseLen);
case REC_TYPE_APP:
return ParseAppMsg(buffer, bufLen, &msg->body.appMsg, parseLen);
default:
break;
}
return HITLS_INTERNAL_EXCEPTION;
}
int32_t FRAME_ParseMsg(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_Msg *msg, uint32_t *parseLen)
{
int32_t ret;
ret = FRAME_ParseMsgHeader(frameType, buffer, bufLen, msg, parseLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
return FRAME_ParseMsgBody(frameType, &buffer[*parseLen], msg->length.data, msg, parseLen);
}
int32_t FRAME_ParseTLSNonHsRecord(const uint8_t *buffer, uint32_t bufLen, FRAME_Msg *msg, uint32_t *parseLen)
{
int32_t ret;
uint32_t headerLen;
ret = FRAME_ParseTLSRecordHeader(buffer, bufLen, msg, parseLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
headerLen = *parseLen;
return FRAME_ParseTLSNonHsRecordBody(buffer + headerLen, msg->length.data, msg, parseLen);
}
int32_t FRAME_ParseHsRecord(
FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufferLen, FRAME_Msg *msg, uint32_t *parseLen)
{
int32_t ret;
uint32_t headerLen;
ret = FRAME_ParseMsgHeader(frameType, buffer, bufferLen, msg, parseLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
headerLen = *parseLen;
/* To ensure that the memory can be normally released after users modify msg->recType.data,
* assign a value to frameType. */
frameType->recordType = msg->recType.data;
if (msg->recType.data == REC_TYPE_HANDSHAKE) {
return ParseHsMsg(frameType, buffer + headerLen, msg->length.data, &msg->body.hsMsg, parseLen);
}
return HITLS_PARSE_UNSUPPORT_HANDSHAKE_MSG;
}
static void CleanParsedHsMsg(HS_MsgType handshakeType, HITLS_KeyExchAlgo kexType, FRAME_HsMsg *hsMsg)
{
switch (handshakeType) {
case CLIENT_HELLO:
return CleanClientHelloMsg(&hsMsg->body.clientHello);
case SERVER_HELLO:
return CleanServerHelloMsg(&hsMsg->body.serverHello);
case CERTIFICATE:
return CleanCertificateMsg(&hsMsg->body.certificate);
case SERVER_KEY_EXCHANGE:
return CleanServerKxMsg(kexType, &hsMsg->body.serverKeyExchange);
case CERTIFICATE_REQUEST:
return CleanCertReqMsg(&hsMsg->body.certificateReq);
case CLIENT_KEY_EXCHANGE:
return CleanClientKxMsg(&hsMsg->body.clientKeyExchange);
case CERTIFICATE_VERIFY:
return CleanCertVerifyMsg(&hsMsg->body.certificateVerify);
case FINISHED:
return CleanFinishedMsg(&hsMsg->body.finished);
case SERVER_HELLO_DONE:
return CleanServerHelloDoneMsg(&hsMsg->body.serverHelloDone);
case NEW_SESSION_TICKET:
return CleanNewSessionTicket(&hsMsg->body.newSessionTicket);
default:
break;
}
return;
}
static void CleanHsMsg(FRAME_Type *frameType, FRAME_HsMsg *hsMsg)
{
return CleanParsedHsMsg(frameType->handshakeType, frameType->keyExType, hsMsg);
}
void FRAME_CleanMsg(FRAME_Type *frameType, FRAME_Msg *msg)
{
if ((frameType == NULL) || (msg == NULL)) {
return;
}
switch (frameType->recordType) {
case REC_TYPE_HANDSHAKE:
CleanHsMsg(frameType, &msg->body.hsMsg);
break;
case REC_TYPE_CHANGE_CIPHER_SPEC:
CleanCcsMsg(&msg->body.ccsMsg);
break;
case REC_TYPE_ALERT:
CleanAlertMsg(&msg->body.alertMsg);
break;
case REC_TYPE_APP:
CleanAppMsg(&msg->body.appMsg);
break;
default:
break;
}
memset_s(msg, sizeof(FRAME_Msg), 0, sizeof(FRAME_Msg));
return;
}
void FRAME_CleanNonHsRecord(REC_Type recType, FRAME_Msg *msg)
{
if (msg == NULL) {
return;
}
switch (recType) {
case REC_TYPE_CHANGE_CIPHER_SPEC:
CleanCcsMsg(&msg->body.ccsMsg);
break;
case REC_TYPE_ALERT:
CleanAlertMsg(&msg->body.alertMsg);
break;
case REC_TYPE_APP:
CleanAppMsg(&msg->body.appMsg);
break;
default:
break;
}
memset_s(msg, sizeof(FRAME_Msg), 0, sizeof(FRAME_Msg));
} | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/msg/src/frame_parse_msg.c | C | unknown | 51,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.
*/
#include "securec.h"
#include "bsl_bytes.h"
#include "bsl_sal.h"
#include "hitls_error.h"
#include "hitls.h"
#include "tls.h"
#include "hs_ctx.h"
#include "pack_common.h"
#include "pack.h"
#include "frame_msg.h"
#include "pack_frame_msg.h"
#define RECORD_BUF_LEN (18 * 1024)
#define TEST_CERT_LEN_TAG_SIZE 3
TLS_Ctx *NewFrameTlsCtx(void)
{
TLS_Ctx *tlsCtx = (TLS_Ctx *)BSL_SAL_Calloc(1u, sizeof(HITLS_Ctx));
if (tlsCtx == NULL) {
return NULL;
}
tlsCtx->hsCtx = (HS_Ctx *)BSL_SAL_Calloc(1u, sizeof(HS_Ctx));
if (tlsCtx->hsCtx == NULL) {
BSL_SAL_FREE(tlsCtx);
return NULL;
}
tlsCtx->hsCtx->clientRandom = tlsCtx->negotiatedInfo.clientRandom;
tlsCtx->hsCtx->serverRandom = tlsCtx->negotiatedInfo.serverRandom;
return tlsCtx;
}
int32_t GenClientHelloMandatoryCtx(TLS_Ctx *tlsCtx, FRAME_Msg *msg)
{
ClientHelloMsg *clientHello = &msg->body.handshakeMsg.body.clientHello;
TLS_Config *tlsConfig = &tlsCtx->config.tlsConfig;
tlsConfig->maxVersion = clientHello->version;
int32_t ret = memcpy_s(tlsCtx->hsCtx->clientRandom, HS_RANDOM_SIZE, clientHello->randomValue, HS_RANDOM_SIZE);
if (ret != EOK) {
return HITLS_MEMCPY_FAIL;
}
if (clientHello->sessionIdSize > 0) {
#if defined(HITLS_TLS_FEATURE_SESSION) || defined(HITLS_TLS_PROTO_TLS13)
tlsCtx->hsCtx->sessionId = (uint8_t *)BSL_SAL_Dump(clientHello->sessionId, clientHello->sessionIdSize);
if (tlsCtx->hsCtx->sessionId == NULL) {
return HITLS_MEMALLOC_FAIL;
}
tlsCtx->hsCtx->sessionIdSize = clientHello->sessionIdSize;
#endif
}
#ifdef HITLS_TLS_PROTO_DTLS12
if (IS_SUPPORT_DATAGRAM(tlsConfig->originVersionMask) && clientHello->cookieLen > 0) {
tlsCtx->negotiatedInfo.cookieSize = clientHello->cookieLen;
tlsCtx->negotiatedInfo.cookie = (uint8_t *)BSL_SAL_Dump(clientHello->cookie, clientHello->cookieLen);
if (tlsCtx->negotiatedInfo.cookie == NULL) {
return HITLS_MEMALLOC_FAIL;
}
}
#endif
tlsConfig->cipherSuitesSize = clientHello->cipherSuitesSize;
uint32_t suitsLen = clientHello->cipherSuitesSize * sizeof(uint16_t);
tlsConfig->cipherSuites = (uint16_t *)BSL_SAL_Dump(clientHello->cipherSuites, suitsLen);
if (tlsConfig->cipherSuites == NULL) {
return HITLS_MEMALLOC_FAIL;
}
return HITLS_SUCCESS;
}
int32_t GenClientHelloExtensionCtx(TLS_Ctx *tlsCtx, FRAME_Msg *msg)
{
ClientHelloMsg *clientHello = &msg->body.handshakeMsg.body.clientHello;
TLS_Config *tlsConfig = &tlsCtx->config.tlsConfig;
tlsConfig->isSupportExtendMasterSecret = clientHello->extension.flag.haveExtendedMasterSecret;
tlsConfig->signAlgorithmsSize = clientHello->extension.content.signatureAlgorithmsSize;
if (tlsConfig->signAlgorithmsSize > 0) {
uint32_t signAlgorithmsLen = tlsConfig->signAlgorithmsSize * sizeof(uint16_t);
tlsConfig->signAlgorithms = (uint16_t *)BSL_SAL_Dump(clientHello->extension.content.signatureAlgorithms,
signAlgorithmsLen);
if (tlsConfig->signAlgorithms == NULL) {
return HITLS_MEMALLOC_FAIL;
}
}
tlsConfig->groupsSize = clientHello->extension.content.supportedGroupsSize;
if (tlsConfig->groupsSize > 0) {
uint32_t groupsLen = tlsConfig->groupsSize * sizeof(uint16_t);
tlsConfig->groups = (uint16_t *)BSL_SAL_Dump(clientHello->extension.content.supportedGroups, groupsLen);
if (tlsConfig->groups == NULL) {
return HITLS_MEMALLOC_FAIL;
}
}
tlsConfig->pointFormatsSize = clientHello->extension.content.pointFormatsSize;
if (tlsConfig->pointFormatsSize > 0) {
uint32_t pointFormatsLen = tlsConfig->pointFormatsSize * sizeof(uint8_t);
tlsConfig->pointFormats = (uint8_t *)BSL_SAL_Dump(clientHello->extension.content.pointFormats, pointFormatsLen);
if (tlsConfig->pointFormats == NULL) {
return HITLS_MEMALLOC_FAIL;
}
}
return HITLS_SUCCESS;
}
int32_t PackClientHelloMsg(FRAME_Msg *msg)
{
TLS_Ctx *tlsCtx = NewFrameTlsCtx();
if (tlsCtx == NULL) {
return HITLS_MEMCPY_FAIL;
}
int32_t ret = GenClientHelloMandatoryCtx(tlsCtx, msg);
if (ret != HITLS_SUCCESS) {
goto EXIT;
}
// extended information
ret = GenClientHelloExtensionCtx(tlsCtx, msg);
if (ret != HITLS_SUCCESS) {
goto EXIT;
}
ret = HS_PackMsg(tlsCtx, CLIENT_HELLO);
if (memcpy_s(&msg->buffer[msg->len], REC_MAX_PLAIN_LENGTH, tlsCtx->hsCtx->msgBuf, tlsCtx->hsCtx->msgLen) != EOK) {
return HITLS_MEMCPY_FAIL;
}
msg->len += tlsCtx->hsCtx->msgLen;
EXIT:
HITLS_Free(tlsCtx);
return ret;
}
int32_t PackServerHelloMsg(FRAME_Msg *msg)
{
TLS_Ctx *tlsCtx = NewFrameTlsCtx();
if (tlsCtx == NULL) {
return HITLS_MEMCPY_FAIL;
}
ServerHelloMsg *serverHello = &msg->body.handshakeMsg.body.serverHello;
tlsCtx->negotiatedInfo.version = serverHello->version;
int32_t ret = 0;
ret = memcpy_s(tlsCtx->hsCtx->serverRandom, HS_RANDOM_SIZE, serverHello->randomValue, HS_RANDOM_SIZE);
if (ret != EOK) {
goto EXIT;
}
if (serverHello->sessionIdSize > 0) { // SessionId
#if defined(HITLS_TLS_FEATURE_SESSION) || defined(HITLS_TLS_PROTO_TLS13)
tlsCtx->hsCtx->sessionId = (uint8_t *)BSL_SAL_Dump(serverHello->sessionId, serverHello->sessionIdSize);
if (tlsCtx->hsCtx->sessionId == NULL) {
ret = HITLS_MEMALLOC_FAIL;
goto EXIT;
}
tlsCtx->hsCtx->sessionIdSize = serverHello->sessionIdSize;
#endif
}
tlsCtx->negotiatedInfo.cipherSuiteInfo.cipherSuite = serverHello->cipherSuite;
tlsCtx->negotiatedInfo.isExtendedMasterSecret = serverHello->haveExtendedMasterSecret;
ret = HS_PackMsg(tlsCtx, SERVER_HELLO);
if (memcpy_s(&msg->buffer[msg->len], REC_MAX_PLAIN_LENGTH, tlsCtx->hsCtx->msgBuf, tlsCtx->hsCtx->msgLen) != EOK) {
return HITLS_MEMCPY_FAIL;
}
msg->len += tlsCtx->hsCtx->msgLen;
EXIT:
HITLS_Free(tlsCtx);
return ret;
}
int32_t PackCertificateMsg(FRAME_Msg *msg)
{
CertificateMsg *certificate = &msg->body.handshakeMsg.body.certificate;
uint32_t allCertsLen = 0; // Total length of all certificates
uint32_t offset = msg->len + DTLS_HS_MSG_HEADER_SIZE; // Reserved packet header
// Indicates the offset of the total length of the certificate chain.
uint32_t certsLenOffset = offset;
offset += TEST_CERT_LEN_TAG_SIZE; // Total length of the reserved certificate chain
CERT_Item *cur = certificate->cert;
while (cur != NULL) {
BSL_Uint24ToByte(cur->dataSize, &msg->buffer[offset]);
offset += TEST_CERT_LEN_TAG_SIZE;
int32_t ret = memcpy_s(&msg->buffer[offset], RECORD_BUF_LEN - offset, cur->data, cur->dataSize);
if (ret != EOK) {
return HITLS_MEMCPY_FAIL;
}
offset += cur->dataSize;
allCertsLen += TEST_CERT_LEN_TAG_SIZE + cur->dataSize;
cur = cur->next;
}
// Indicates the total length of the certificate chain.
BSL_Uint24ToByte(allCertsLen, &msg->buffer[certsLenOffset]);
/* Assemble the packet header. */
const uint32_t sequence = 1;
const uint32_t bodyLen = TEST_CERT_LEN_TAG_SIZE + allCertsLen;
PackDtlsMsgHeader(CERTIFICATE, sequence, bodyLen, &msg->buffer[msg->len]);
msg->len += DTLS_HS_MSG_HEADER_SIZE + bodyLen;
return HITLS_SUCCESS;
}
int32_t PackServerKxMsg(FRAME_Msg *msg)
{
ServerKeyExchangeMsg *serverKx = &msg->body.handshakeMsg.body.serverKeyExchange;
uint32_t offset = msg->len + DTLS_HS_MSG_HEADER_SIZE; // Reserved packet header
/* Curve Type and Curve ID */
msg->buffer[offset] = (uint8_t)(serverKx->keyEx.ecdh.ecPara.type);
offset += sizeof(uint8_t);
BSL_Uint16ToByte((uint16_t)(serverKx->keyEx.ecdh.ecPara.param.namedcurve), &msg->buffer[offset]);
offset += sizeof(uint16_t);
/* Public key length and public key content */
msg->buffer[offset] = (uint8_t)serverKx->keyEx.ecdh.pubKeySize;
offset += sizeof(uint8_t);
int32_t ret = memcpy_s(&msg->buffer[offset], RECORD_BUF_LEN - offset,
serverKx->keyEx.ecdh.pubKey, serverKx->keyEx.ecdh.pubKeySize);
if (ret != EOK) {
return HITLS_MEMCPY_FAIL;
}
offset += serverKx->keyEx.ecdh.pubKeySize;
/* signature algorithm */
BSL_Uint16ToByte(serverKx->keyEx.ecdh.signAlgorithm, &msg->buffer[offset]);
offset += sizeof(uint16_t);
/* Signature Length */
BSL_Uint16ToByte(serverKx->keyEx.ecdh.signSize, &msg->buffer[offset]);
offset += sizeof(uint16_t);
ret = memcpy_s(&msg->buffer[offset], RECORD_BUF_LEN - offset,
serverKx->keyEx.ecdh.signData, serverKx->keyEx.ecdh.signSize);
if (ret != EOK) {
return HITLS_MEMCPY_FAIL;
}
offset += serverKx->keyEx.ecdh.signSize;
/* Assemble the packet header. */
const uint32_t sequence = msg->body.handshakeMsg.sequence;
const uint32_t bodyLen = sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint8_t) + serverKx->keyEx.ecdh.pubKeySize +
sizeof(uint16_t) + sizeof(uint16_t) + serverKx->keyEx.ecdh.signSize;
PackDtlsMsgHeader(SERVER_KEY_EXCHANGE, sequence, bodyLen, &msg->buffer[msg->len]);
msg->len += DTLS_HS_MSG_HEADER_SIZE + bodyLen;
return HITLS_SUCCESS;
}
int32_t PackServerHelloDoneMsg(FRAME_Msg *msg)
{
/* Assemble the packet header. */
const uint32_t sequence = msg->body.handshakeMsg.sequence;
const uint32_t bodyLen = 0;
PackDtlsMsgHeader(SERVER_HELLO_DONE, sequence, bodyLen, &msg->buffer[msg->len]);
msg->len += DTLS_HS_MSG_HEADER_SIZE + bodyLen;
return HITLS_SUCCESS;
}
int32_t PackClientKxMsg(FRAME_Msg *msg)
{
ClientKeyExchangeMsg *clientKx = &msg->body.handshakeMsg.body.clientKeyExchange;
uint32_t offset = msg->len + DTLS_HS_MSG_HEADER_SIZE; // Reserved packet header
msg->buffer[offset] = (uint8_t)clientKx->dataSize;
offset += sizeof(uint8_t);
int32_t ret = memcpy_s(&msg->buffer[offset], RECORD_BUF_LEN - offset, clientKx->data, clientKx->dataSize);
if (ret != EOK) {
return HITLS_MEMCPY_FAIL;
}
/* Assemble the packet header. */
const uint32_t sequence = msg->body.handshakeMsg.sequence;
const uint32_t bodyLen = clientKx->dataSize + sizeof(uint8_t);
PackDtlsMsgHeader(CLIENT_KEY_EXCHANGE, sequence, bodyLen, &msg->buffer[msg->len]);
msg->len += DTLS_HS_MSG_HEADER_SIZE + bodyLen;
return HITLS_SUCCESS;
}
int32_t PackFinishMsg(FRAME_Msg *msg)
{
TLS_Ctx *tlsCtx = NewFrameTlsCtx();
if (tlsCtx == NULL) {
return HITLS_MEMCPY_FAIL;
}
FinishedMsg *finished = &msg->body.handshakeMsg.body.finished;
int32_t ret = 0;
tlsCtx->hsCtx->verifyCtx = (VerifyCtx*)BSL_SAL_Calloc(1u, sizeof(VerifyCtx));
if (tlsCtx->hsCtx->verifyCtx == NULL) {
ret = HITLS_MEMALLOC_FAIL;
goto EXIT;
}
tlsCtx->hsCtx->verifyCtx->verifyDataSize = finished->verifyDataSize;
ret = memcpy_s(tlsCtx->hsCtx->verifyCtx->verifyData, MAX_SIGN_SIZE,
finished->verifyData, finished->verifyDataSize);
if (ret != EOK) {
goto EXIT;
}
ret = HS_PackMsg(tlsCtx, FINISHED);
if (memcpy_s(&msg->buffer[msg->len], REC_MAX_PLAIN_LENGTH, tlsCtx->hsCtx->msgBuf, tlsCtx->hsCtx->msgLen) != EOK) {
return HITLS_MEMCPY_FAIL;
}
msg->len += tlsCtx->hsCtx->msgLen;
EXIT:
HITLS_Free(tlsCtx);
return ret;
}
int32_t PackHandShakeMsg(FRAME_Msg *msg)
{
HS_MsgType type = msg->body.handshakeMsg.type;
uint32_t ret = HITLS_SUCCESS;
switch (type) {
case CLIENT_HELLO:
ret = PackClientHelloMsg(msg);
break;
case SERVER_HELLO:
ret = PackServerHelloMsg(msg);
break;
case CERTIFICATE:
ret = PackCertificateMsg(msg);
break;
case SERVER_KEY_EXCHANGE:
ret = PackServerKxMsg(msg);
break;
case SERVER_HELLO_DONE:
ret = PackServerHelloDoneMsg(msg);
break;
case CLIENT_KEY_EXCHANGE:
ret = PackClientKxMsg(msg);
break;
case FINISHED:
ret = PackFinishMsg(msg);
break;
default:
ret = HITLS_PACK_UNSUPPORT_HANDSHAKE_MSG;
}
return ret;
}
int32_t PackCCSMsg(FRAME_Msg *msg)
{
FRAME_CcsMsg *ccsMsg = &msg->body.ccsMsg;
uint32_t offset = msg->len;
msg->buffer[offset] = ccsMsg->type;
msg->len += sizeof(uint8_t);
return HITLS_SUCCESS;
}
int32_t PackAlertMsg(FRAME_Msg *msg)
{
FRAME_AlertMsg *alertMsg = &msg->body.alertMsg;
uint32_t offset = msg->len;
msg->buffer[offset] = alertMsg->level;
offset += sizeof(uint8_t);
msg->buffer[offset] = alertMsg->description;
msg->len += sizeof(uint8_t) + sizeof(uint8_t);
return HITLS_SUCCESS;
}
int32_t PackAppData(FRAME_Msg *msg)
{
FRAME_AppMsg *appMsg = &msg->body.appMsg;
uint32_t offset = msg->len;
BSL_Uint32ToByte(appMsg->len, &msg->buffer[offset]);
offset += sizeof(uint32_t);
int32_t ret = memcpy_s(&msg->buffer[offset], RECORD_BUF_LEN - offset, appMsg->buffer, appMsg->len);
if (ret != EOK) {
return HITLS_MEMCPY_FAIL;
}
msg->len += sizeof(uint32_t) + appMsg->len;
return HITLS_SUCCESS;
}
// Pack header
int32_t PackRecordHeader(FRAME_Msg *msg)
{
uint32_t offset = 0;
msg->buffer[offset] = msg->type;
offset += sizeof(uint8_t);
BSL_Uint16ToByte(msg->version, &msg->buffer[offset]);
offset += sizeof(uint16_t);
#ifdef HITLS_TLS_PROTO_DTLS12
if (IS_TRANSTYPE_DATAGRAM(msg->transportType)) {
BSL_Uint64ToByte(msg->epochSeq, &msg->buffer[offset]);
offset += sizeof(uint64_t);
}
#endif
BSL_Uint16ToByte(msg->bodyLen, &msg->buffer[offset]);
offset += sizeof(uint16_t);
msg->len = offset;
return HITLS_SUCCESS;
}
int32_t PackFrameMsg(FRAME_Msg *msg)
{
// Apply for an 18 KB buffer for storing the current message.
msg->buffer = (uint8_t *)BSL_SAL_Calloc(1u, RECORD_BUF_LEN);
if (msg->buffer == NULL) {
return HITLS_MEMALLOC_FAIL;
}
msg->len = RECORD_BUF_LEN; // The length must be the same as the length of the applied 18 KB buffer.
// pack Header
PackRecordHeader(msg);
// pack Body
uint32_t ret = HITLS_SUCCESS;
switch (msg->type) {
case REC_TYPE_HANDSHAKE:
ret = PackHandShakeMsg(msg);
break;
case REC_TYPE_CHANGE_CIPHER_SPEC:
ret = PackCCSMsg(msg);
break;
case REC_TYPE_ALERT:
ret = PackAlertMsg(msg);
break;
case REC_TYPE_APP:
ret = PackAppData(msg);
break;
default:
break;
}
return ret;
} | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/msg/src/pack_frame_msg.c | C | unknown | 15,421 |
/*
* 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 "securec.h"
#include "bsl_bytes.h"
#include "bsl_sal.h"
#include "hitls_error.h"
#include "tls.h"
#include "conn_init.h"
#include "hs_ctx.h"
#include "parse.h"
#include "conn_init.h"
#include "frame_tls.h"
#include "frame_msg.h"
#include "parser_frame_msg.h"
void SendAlertStake(const TLS_Ctx *ctx, ALERT_Level level, ALERT_Description description)
{
(void)ctx;
(void)level;
(void)description;
return;
}
int32_t ParserRecordHeader(FRAME_Msg *frameMsg, const uint8_t *buffer, uint32_t len, uint32_t *parserLen)
{
(void)len;
uint32_t bufOffset = 0;
frameMsg->type = buffer[bufOffset];
bufOffset += sizeof(uint8_t);
frameMsg->version = BSL_ByteToUint16(&buffer[bufOffset]);
bufOffset += sizeof(uint16_t);
#ifdef HITLS_TLS_PROTO_DTLS12
if (IS_TRANSTYPE_DATAGRAM(frameMsg->transportType)) {
frameMsg->epochSeq = BSL_ByteToUint64(&buffer[bufOffset]);
bufOffset += sizeof(uint64_t);
}
#endif
frameMsg->bodyLen = BSL_ByteToUint16(&buffer[bufOffset]);
bufOffset += sizeof(uint16_t);
*parserLen = bufOffset;
return HITLS_SUCCESS;
}
int32_t ParserHandShakeMsg(const FRAME_LinkObj *linkObj, FRAME_Msg *frameMsg,
const uint8_t *buffer, uint32_t len, uint32_t *parserLen)
{
int32_t ret;
HS_MsgInfo hsMsgInfo = {0};
HITLS_Ctx *sslCtx = FRAME_GetTlsCtx(linkObj);
SendAlertCallback tmpAlertCallback = sslCtx->method.sendAlert;
sslCtx->method.sendAlert = SendAlertStake;
CONN_Init(sslCtx);
ret = HS_ParseMsgHeader(sslCtx, buffer, len, &hsMsgInfo);
if (ret != HITLS_SUCCESS) {
sslCtx->method.sendAlert = tmpAlertCallback;
return ret;
}
hsMsgInfo.rawMsg = buffer;
ret = HS_ParseMsg(sslCtx, &hsMsgInfo, &frameMsg->body.handshakeMsg);
if (ret != HITLS_SUCCESS) {
sslCtx->method.sendAlert = tmpAlertCallback;
return ret;
}
sslCtx->method.sendAlert = tmpAlertCallback;
*parserLen += hsMsgInfo.length;
return HITLS_SUCCESS;
}
int32_t ParserCCSMsg(FRAME_Msg *frameMsg, const uint8_t *buffer, uint32_t len, uint32_t *parserLen)
{
(void)len;
frameMsg->body.ccsMsg.type = buffer[0];
*parserLen += sizeof(uint8_t);
return HITLS_SUCCESS;
}
int32_t ParserAlertMsg(FRAME_Msg *frameMsg, const uint8_t *buffer, uint32_t len, uint32_t *parserLen)
{
(void)len;
uint32_t bufOffset = 0;
frameMsg->body.alertMsg.level = buffer[bufOffset];
bufOffset += sizeof(uint8_t);
frameMsg->body.alertMsg.description = buffer[bufOffset];
bufOffset += sizeof(uint8_t);
*parserLen += bufOffset;
return HITLS_SUCCESS;
}
int32_t ParserAppMsg(FRAME_Msg *frameMsg, const uint8_t *buffer, uint32_t len, uint32_t *parserLen)
{
(void)len;
uint32_t bufOffset = 0;
uint32_t userDataLen = BSL_ByteToUint32(&buffer[bufOffset]);
frameMsg->body.appMsg.len = userDataLen;
bufOffset += sizeof(uint32_t);
BSL_SAL_FREE(frameMsg->body.appMsg.buffer);
frameMsg->body.appMsg.buffer = BSL_SAL_Dump(&buffer[bufOffset], userDataLen);
if (frameMsg->body.appMsg.buffer == NULL) {
return HITLS_MEMALLOC_FAIL;
}
bufOffset += userDataLen;
*parserLen += bufOffset;
return HITLS_SUCCESS;
}
int32_t ParserRecordBody(const FRAME_LinkObj *linkObj, FRAME_Msg *frameMsg,
const uint8_t *buffer, uint32_t len, uint32_t *parserLen)
{
switch (frameMsg->type) {
case REC_TYPE_HANDSHAKE:
return ParserHandShakeMsg(linkObj, frameMsg, buffer, len, parserLen);
case REC_TYPE_CHANGE_CIPHER_SPEC:
return ParserCCSMsg(frameMsg, buffer, len, parserLen);
case REC_TYPE_ALERT:
return ParserAlertMsg(frameMsg, buffer, len, parserLen);
case REC_TYPE_APP:
return ParserAppMsg(frameMsg, buffer, len, parserLen);
default:
break;
}
return HITLS_SUCCESS;
}
int32_t ParserTotalRecord(const FRAME_LinkObj *linkObj, FRAME_Msg *frameMsg,
const uint8_t *buffer, uint32_t len, uint32_t *parserLen)
{
int32_t ret = ParserRecordHeader(frameMsg, buffer, len, parserLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
return ParserRecordBody(linkObj, frameMsg, &buffer[*parserLen], len - *parserLen, parserLen);
}
void CleanRecordBody(FRAME_Msg *frameMsg)
{
if (frameMsg->type == REC_TYPE_HANDSHAKE) {
HS_CleanMsg(&frameMsg->body.handshakeMsg);
} else if (frameMsg->type == REC_TYPE_APP) {
BSL_SAL_FREE(frameMsg->body.appMsg.buffer);
}
BSL_SAL_FREE(frameMsg->buffer);
}
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/msg/src/parser_frame_msg.c | C | unknown | 5,078 |
/*
* 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.
*/
#ifndef HANDLE_CMD_H
#define HANDLE_CMD_H
#include <stdint.h>
#include "hlt_type.h"
#include "channel_res.h"
#ifdef __cplusplus
extern "C" {
#endif
#define MAX_CMD_ID_LEN (15)
#define MAX_CMD_FUNCID_LEN (64)
#define MAX_CMD_PARAS_NUM (100)
typedef struct {
uint8_t parasNum;
char id[MAX_CMD_ID_LEN];
char funcId[MAX_CMD_FUNCID_LEN];
char paras[MAX_CMD_PARAS_NUM][CONTROL_CHANNEL_MAX_MSG_LEN];
char result[CONTROL_CHANNEL_MAX_MSG_LEN];
} CmdData;
/**
* @brief Expected result value
*/
int ExpectResult(CmdData *expectCmdData);
/**
* @brief Waiting for the result of the peer end
*/
int WaitResultFromPeer(CmdData *expectCmdData);
/**
* @brief Resolve instructions from a string
*/
int ParseCmdFromStr(char *str, CmdData *cmdData);
/**
* @brief Parse the instruction from the buffer.
*/
int ParseCmdFromBuf(ControlChannelBuf *dataBuf, CmdData *cmdData);
/**
* @brief Execute the corresponding command.
*/
int ExecuteCmd(CmdData *cmdData);
/**
* @brief Obtain the CTX configuration content from the character string parsing.
*/
int ParseCtxConfigFromString(char (*string)[CONTROL_CHANNEL_MAX_MSG_LEN], HLT_Ctx_Config *ctxConfig);
#ifdef __cplusplus
}
#endif
#endif // HANDLE_CMD_H | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/process/include/handle_cmd.h | C | unknown | 1,759 |
/*
* 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.
*/
#ifndef PROCESS_H
#define PROCESS_H
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include "hlt_type.h"
#ifdef __cplusplus
extern "C" {
#endif
#define DOMAIN_PATH_LEN (128)
#define TLS_RES_MAX_NUM (64)
typedef struct ProcessSt {
TLS_TYPE tlsType; // Identifies whether the HiTLS interface is used.
char srcDomainPath[DOMAIN_PATH_LEN];
char peerDomainPath[DOMAIN_PATH_LEN]; // This field is used only by remote processes.
int controlChannelFd; // This field is used only by the local process.
int remoteFlag; // Indicates whether the process is a remote process. The value 1 indicates a remote process.
int connFd; // FD used by the TLS link
int connType; // Enumerated value of HILT_TransportType, which is the communication protocol type used by the
// TLS link.
int connPort;
struct sockaddr_in sockAddr;
void* tlsResArray[TLS_RES_MAX_NUM]; // Stores ctx SSL resources.
int tlsResNum; // Number of created TLS resources
void* hltTlsResArray[TLS_RES_MAX_NUM]; // Stores the HLT_Tls_Res resource. This resource is used only
// by the local process.
int hltTlsResNum; // Number of created HLT_Tls_Res resources.
} Process;
/**
* @brief Initializes the global table used to represent command IDs.
*/
void InitCmdIndex(void);
/**
* @brief Initializing Process Resources
*/
int InitProcess(void);
/**
* @brief Obtaining Process Resources
*/
Process *GetProcess(void);
/**
* @brief Obtain the process from the linked list.
*/
Process *GetProcessFromList(void);
/**
* @brief Release the linked list of the storage process.
*/
void FreeProcessResList(void);
/**
* @brief Release process resources.
*/
void FreeProcess(void);
#ifdef __cplusplus
}
#endif
#endif // PROCESS_H | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/process/include/process.h | C | unknown | 2,364 |
/*
* 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 <unistd.h>
#include <stdbool.h>
#include <semaphore.h>
#include "hlt_type.h"
#include "securec.h"
#include "logger.h"
#include "rpc_func.h"
#include "channel_res.h"
#include "handle_cmd.h"
#define SUCCESS 0
#define ERROR (-1)
#define ASSERT_RETURN(condition, log) \
do { \
if (!(condition)) { \
LOG_ERROR(log); \
return ERROR; \
} \
} while (0)
int ExpectResult(CmdData *expectCmdData)
{
int ret, id;
char *endPtr = NULL;
CmdData cmdData;
ControlChannelRes *channelRes;
channelRes = GetControlChannelRes();
OsLock(channelRes->rcvBufferLock);
id = (int)strtol(expectCmdData->id, &endPtr, 0) % MAX_RCV_BUFFER_NUM;
// Check whether the corresponding buffer contains content.
if (strlen(channelRes->rcvBuffer[id]) == 0) {
OsUnLock(channelRes->rcvBufferLock);
return ERROR;
}
// Parsing the CMD
ret = ParseCmdFromStr(channelRes->rcvBuffer[id], &cmdData);
if (ret != SUCCESS) {
LOG_ERROR("ParseCmdFromStr ERROR");
OsUnLock(channelRes->rcvBufferLock);
return ERROR;
}
if ((strncmp(expectCmdData->id, cmdData.id, strlen(cmdData.id)) == 0) &&
(strncmp(expectCmdData->funcId, cmdData.funcId, strlen(cmdData.funcId)) == 0)) {
ret = memcpy_s(expectCmdData->paras, sizeof(expectCmdData->paras), cmdData.paras, sizeof(cmdData.paras));
if (ret != EOK) {
LOG_ERROR("memcpy_s ERROR");
OsUnLock(channelRes->rcvBufferLock);
return ERROR;
}
(void)memset_s(channelRes->rcvBuffer[id], CONTROL_CHANNEL_MAX_MSG_LEN, 0, CONTROL_CHANNEL_MAX_MSG_LEN);
OsUnLock(channelRes->rcvBufferLock);
return SUCCESS;
}
OsUnLock(channelRes->rcvBufferLock);
LOG_ERROR("strncmp ERROR [expectCmdData->id=%s, cmdData.id = %s, expectCmdData->funcId = %s, cmdData.funcId = %s]",
expectCmdData->id, cmdData.id, expectCmdData->funcId, cmdData.funcId);
return ERROR;
}
int WaitResultFromPeer(CmdData *expectCmdData)
{
int ret;
int timeout = TIME_OUT_SEC;
if (getenv("SSL_TIMEOUT") != NULL) {
timeout = atoi(getenv("SSL_TIMEOUT"));
}
timeout *= 2;
time_t start = time(NULL);
do {
ret = ExpectResult(expectCmdData);
usleep(1000); // Waiting for 1000 subtleties
} while ((ret != SUCCESS) && (time(NULL) - start < timeout));
ASSERT_RETURN(ret == SUCCESS, "ExpectResult Error");
return SUCCESS;
}
int ParseCmdFromStr(char *str, CmdData *cmdData)
{
int ret, count, strBufLen;
char *token = NULL;
char *rest = NULL;
char *strBuf = NULL;
(void)memset_s(cmdData, sizeof(CmdData), 0, sizeof(CmdData));
strBufLen = strlen(str) + 1;
strBuf = (char*)malloc(strBufLen);
ASSERT_RETURN(strBuf != NULL, "Malloc Error");
(void)memset_s(strBuf, strBufLen, 0, strBufLen);
ret = memcpy_s(strBuf, strBufLen, str, strlen(str));
if (ret != EOK) {
LOG_ERROR("memcpy_s Error");
goto ERR;
}
/*
The command message structure is as follows:
ID | FUNC | PARAS1 | PARAS2 |......
Fields are separated by vertical bars (|).
*/
// Get ID
token = strtok_s(strBuf, "|", &rest);
ret = strcpy_s(cmdData->id, sizeof(cmdData->id), token); // Get Id
if (ret != EOK) {
LOG_ERROR("strcpy_s Error");
goto ERR;
}
// Get FUNC.
token = strtok_s(NULL, "|", &rest);
ret = strcpy_s(cmdData->funcId, sizeof(cmdData->funcId), token); // Get FunId
if (ret != EOK) {
LOG_ERROR("strcpy_s Error");
goto ERR;
}
// Obtaining Parameters
token = strtok_s(NULL, "|", &rest);
count = 0;
for (; token != NULL; token = strtok_s(NULL, "|", &rest)) {
// Maximum length of argument is CONTROL_CHANNEL_MAX_MSG_LEN
ret = strcpy_s(cmdData->paras[count], sizeof(cmdData->paras[0]), token);
int offset = 0;
while (rest[offset] == '|') {
count++;
offset++;
}
count++;
if (ret != EOK) {
break;
}
}
if (ret != EOK) {
LOG_ERROR("strcpy_s error");
goto ERR;
}
cmdData->parasNum = count;
free(strBuf);
return SUCCESS;
ERR:
free(strBuf);
return ERROR;
}
int ParseCmdFromBuf(ControlChannelBuf *dataBuf, CmdData *cmdData)
{
return ParseCmdFromStr(dataBuf->data, cmdData);
}
int ExecuteCmd(CmdData *cmdData)
{
int ret;
RpcFunList *rcpFuncList = GetRpcFuncList();
int funcNum = GetRpcFuncNum();
ret = ERROR;
for (int i = 0; i < funcNum; i++) {
if (strncmp(rcpFuncList[i].funcId, cmdData->funcId, strlen(cmdData->funcId)) == 0) {
ret = rcpFuncList[i].hfunc(cmdData);
return ret;
}
}
LOG_ERROR("Not Find FuncId");
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ERROR);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
return ret;
}
int ParseCtxConfigFromString(char (*string)[CONTROL_CHANNEL_MAX_MSG_LEN], HLT_Ctx_Config *ctxConfig)
{
int ret;
/*
The message structure is as follows:
minVersion | maxVersion |cipherSuites |CA |......
Fields are separated by vertical bars (|).
*/
int index = 1;
// minimum version number
// The first parameter indicates the minimum version number.
ctxConfig->minVersion = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx minVersion is %u", ctxConfig->minVersion);
// Maximum version number
// The second parameter indicates the maximum version number.
ctxConfig->maxVersion = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx maxVersion is %u", ctxConfig->maxVersion);
// Obtaining the Algorithm Suite
// The third parameter indicates the algorithm suite.
ret = strcpy_s(ctxConfig->cipherSuites, sizeof(ctxConfig->cipherSuites), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx cipherSuites is %s", ctxConfig->cipherSuites);
// The fourth parameter indicates the algorithm suite.
ret = strcpy_s(ctxConfig->tls13CipherSuites, sizeof(ctxConfig->tls13CipherSuites), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx tls13cipherSuites is %s", ctxConfig->tls13CipherSuites);
// ECC Point Format Configuration for Asymmetric Algorithms
// The fifth parameter indicates the dot format.
ret = strcpy_s(ctxConfig->pointFormats, sizeof(ctxConfig->pointFormats), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx pointFormats is %s", ctxConfig->pointFormats);
// Obtaining a Group
// The sixth parameter indicates a group.
ret = strcpy_s(ctxConfig->groups, sizeof(ctxConfig->groups), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx groups is %s", ctxConfig->groups);
// Obtaining a Signature
// The seventh parameter indicates the signature.
ret = strcpy_s(ctxConfig->signAlgorithms, sizeof(ctxConfig->signAlgorithms), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx signAlgorithms is %s", ctxConfig->signAlgorithms);
// Whether to support renegotiation
// The eighth parameter indicates whether renegotiation is supported.
ctxConfig->isSupportRenegotiation = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
LOG_DEBUG("Remote Process Set Ctx isSupportRenegotiation is %d", ctxConfig->isSupportRenegotiation);
// Indicates whether to verify the client.
// The tenth parameter indicates whether to verify the client.
ctxConfig->isSupportClientVerify = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
LOG_DEBUG("Remote Process Set Ctx isSupportClientVerify is %d", ctxConfig->isSupportClientVerify);
// Indicates whether the client can send an empty certificate chain.
// The eleventh parameter indicates whether the client can send an empty certificate chain.
ctxConfig->isSupportNoClientCert = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
LOG_DEBUG("Remote Process Set Ctx isSupportNoClientCert is %d", ctxConfig->isSupportNoClientCert);
// Indicates whether extended master keys are supported.
// The twelfth parameter indicates whether the extended master key is supported.
ctxConfig->isSupportExtendMasterSecret = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
LOG_DEBUG("Remote Process Set Ctx isSupportExtendMasterSecret is %d", ctxConfig->isSupportExtendMasterSecret);
// device certificate
// The thirteenth parameter indicates the location of the device certificate.
ret = strcpy_s(ctxConfig->eeCert, sizeof(ctxConfig->eeCert), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx EE is %s", ctxConfig->eeCert);
// private key
// The fourteenth parameter indicates the location of the private key.
ret = strcpy_s(ctxConfig->privKey, sizeof(ctxConfig->privKey), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx privKey is %s", ctxConfig->privKey);
// private key password
// The fifteenth parameter indicates the password of the private key.
ret = strcpy_s(ctxConfig->password, sizeof(ctxConfig->password), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx password is %s", ctxConfig->password);
// CA certificate
// The 16th parameter indicates the CA certificate.
ret = strcpy_s(ctxConfig->caCert, sizeof(ctxConfig->caCert), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx caCert is %s", ctxConfig->caCert);
// Chain certificate
// The 17th parameter indicates the certificate chain.
ret = strcpy_s(ctxConfig->chainCert, sizeof(ctxConfig->chainCert), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx chainCert is %s", ctxConfig->chainCert);
// signature certificate
LOG_DEBUG("Remote Process Set Ctx signCert is %s", string[index]);
// The eighteenth parameter indicates the position of the signature certificate.
ret = strcpy_s(ctxConfig->signCert, sizeof(ctxConfig->signCert), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
// private key for signature
LOG_DEBUG("Remote Process Set Ctx signPrivKey is %s", string[index]);
// The 19th parameter indicates the location of the signature private key.
ret = strcpy_s(ctxConfig->signPrivKey, sizeof(ctxConfig->signPrivKey), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
// psk
ret = strcpy_s(ctxConfig->psk, sizeof(ctxConfig->psk), string[index++]); // 21st parameter psk
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx psk is %s", ctxConfig->psk);
// Indicates whether to support session tickets.
// Indicates whether to enable the sessionTicket function. The value is a decimal number.
ctxConfig->isSupportSessionTicket = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx isSupportSessionTicket is %d", ctxConfig->isSupportSessionTicket);
// Setting the Session Storage Mode
// The 23rd parameter is used to set the session storage mode. The value is a decimal number.
ctxConfig->setSessionCache = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx SessionCache is %d", ctxConfig->setSessionCache);
// Setting the ticket key cb
// 24th parameter ticket key cb
ret = strcpy_s(ctxConfig->ticketKeyCb, sizeof(ctxConfig->ticketKeyCb), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx ticketKeyCb is %s", ctxConfig->ticketKeyCb);
// Indicates whether isFlightTransmitEnable is supported. The 25th parameter indicates whether to send handshake
// messages by flight. The value is converted into a decimal number.
ctxConfig->isFlightTransmitEnable = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
LOG_DEBUG("Remote Process Set Ctx isFlightTransmitEnable is %d", ctxConfig->isFlightTransmitEnable);
// Setting the server name
ret = strcpy_s(ctxConfig->serverName, sizeof(ctxConfig->serverName), string[index++]); // Parameter 26
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx ServerName is %s", ctxConfig->serverName);
// Setting the server name cb
// 27th parameter server name cb
ret = strcpy_s(ctxConfig->sniDealCb, sizeof(ctxConfig->sniDealCb), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx ServerNameCb is %s", ctxConfig->sniDealCb);
// Setting the server name arg
// 28th parameter server name arg cb
ret = strcpy_s(ctxConfig->sniArg, sizeof(ctxConfig->sniArg), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx ServerNameArg is %s", ctxConfig->sniArg);
// Setting the ALPN
ret = strcpy_s(ctxConfig->alpnList, sizeof(ctxConfig->alpnList), string[index++]); // 29th parameter
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx alpnList is %s", ctxConfig->alpnList);
// Setting the ALPN cb
ret = strcpy_s(ctxConfig->alpnSelectCb, sizeof(ctxConfig->alpnSelectCb), string[index++]); // 30th parameter
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx alpnSelectCb is %s", ctxConfig->alpnSelectCb);
// Setting the ALPN data
ret = strcpy_s(ctxConfig->alpnUserData, sizeof(ctxConfig->alpnUserData), string[index++]); // 31th parameter
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx alpnUserData is %s", ctxConfig->alpnUserData);
// Sets the security level. The parameter indicates that the security strength of the key meets the security level
// requirements and is converted into a decimal number.
ctxConfig->securitylevel = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx SecurityLevel is %d", ctxConfig->securitylevel);
// Indicates whether the DH key length follows the certificate. The parameter indicates whether the DH key length
// follows the certificate, which is converted into a decimal number.
ctxConfig->isSupportDhAuto = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx issupportDhauto is %d", ctxConfig->isSupportDhAuto);
// Sets the TLS1.3 key exchange mode. The parameter indicates the TLS1.3 key exchange mode,
// which is converted into a decimal number.
ctxConfig->keyExchMode = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx keyExchMode is %u", ctxConfig->keyExchMode);
// The parameter indicates the SupportType callback type, which converts characters into decimal numbers.
ctxConfig->SupportType = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx SupportType is %d", ctxConfig->SupportType);
ctxConfig->isSupportPostHandshakeAuth = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
ctxConfig->readAhead = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx readAhead is %u", ctxConfig->readAhead);
// Sets whether to verify the keyusage in the certificate. The keyusage is converted into a decimal number.
ctxConfig->needCheckKeyUsage = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
LOG_DEBUG("Remote Process Set Ctx needCheckKeyUsage is %d", ctxConfig->needCheckKeyUsage);
// Set whether to continue the handshake when the verification of peer certificate fails
ctxConfig->isSupportVerifyNone = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
LOG_DEBUG("Remote Process Set Ctx isSupportVerifyNone is %d", ctxConfig->isSupportVerifyNone);
// Whether allow a renegotiation initiated by the client
ctxConfig->allowClientRenegotiate = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
LOG_DEBUG("Remote Process Set Ctx allowClientRenegotiate is %d", ctxConfig->allowClientRenegotiate);
// Set the empty record number.
ctxConfig->emptyRecordsNum = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx emptyRecordsNum is %u", ctxConfig->emptyRecordsNum);
// Whether allow legacy renegotiation
ctxConfig->allowLegacyRenegotiate = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
LOG_DEBUG("Remote Process Set Ctx allowLegacyRenegotiate is %d", ctxConfig->allowLegacyRenegotiate);
// Indicates whether encrypt then mac are supported.
ctxConfig->isEncryptThenMac = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
LOG_DEBUG("Remote Process Set Ctx isEncryptThenMac is %d", ctxConfig->isEncryptThenMac);
// set the features supported by modesupport, The value is a decimal number.
ctxConfig->modeSupport = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx modeSupport is %d", ctxConfig->modeSupport);
ctxConfig->isMiddleBoxCompat = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx MiddleBoxCompat is %d", ctxConfig->isMiddleBoxCompat);
// set the attrName
ret = strcpy_s(ctxConfig->attrName, sizeof(ctxConfig->attrName), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx attrName is %s", ctxConfig->attrName);
// Setting the info cb
ctxConfig->infoCb = NULL; // The pointer cannot be transferred. Set this parameter to null.
return SUCCESS;
}
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/process/src/handle_cmd.c | C | unknown | 18,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.
*/
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/syscall.h>
#include <libgen.h>
#include "lock.h"
#include "hlt.h"
#include "logger.h"
#include "tls_res.h"
#include "channel_res.h"
#include "control_channel.h"
#include "rpc_func.h"
#include "hitls.h"
#include "hitls_config.h"
#include "process.h"
#define SUCCESS 0
#define ERROR (-1)
#define CMD_MAX_LEN (512)
#define DOMAIN_PATH_LEN (128)
#define START_PROCESS_CMD "./process %d ./%s_%d ./%s %d > ./%s_%d.log &"
#define ASSERT_RETURN(condition, log) \
do { \
if (!(condition)) { \
LOG_ERROR(log); \
return ERROR; \
} \
} while (0)
typedef struct ProcessRes {
Process *process;
struct ProcessRes *next;
} ProcessRes;
typedef struct ProcessList {
ProcessRes *processRes;
uint8_t num;
} ProcessList;
static ProcessList g_processList;
static Process *g_process = NULL;
static int g_processIndex = 0;
// Initialization process linked list, which is used only in the Local Process process and is used to save the Remote
// Process.
int InitProcessList(void)
{
g_processList.processRes = (ProcessRes*)malloc(sizeof(ProcessRes));
ASSERT_RETURN(g_processList.processRes != NULL, "Malloc ProcessRes Error");
memset_s(g_processList.processRes, sizeof(ProcessRes), 0, sizeof(ProcessRes));
g_processList.num = 0;
return SUCCESS;
}
// Inserts a process to a linked list. Currently, only remote processes are stored.
int InsertProcessToList(Process *tmpProcess)
{
ProcessRes *frontProcessRes = g_processList.processRes;
ProcessRes *nextProcessRes = NULL;
ProcessRes *tmpProcessRes;
ASSERT_RETURN(tmpProcess != NULL, "TmpProcess is NULL");
// Find the last process resource. The obtained frontProcessRes is the last process resource.
nextProcessRes = frontProcessRes->next;
while (nextProcessRes != NULL) {
frontProcessRes = nextProcessRes;
nextProcessRes = frontProcessRes->next;
}
// Applying for Process Resources
tmpProcessRes = (ProcessRes*)malloc(sizeof(ProcessRes));
ASSERT_RETURN(tmpProcessRes != NULL, "Malloc ProcessRes Error");
tmpProcessRes->process = tmpProcess;
tmpProcessRes->next = NULL;
frontProcessRes->next = tmpProcessRes;
g_processList.num++;
return SUCCESS;
}
Process *GetProcessFromList(void)
{
ProcessRes *headProcessRes = g_processList.processRes;
ProcessRes *firstProcessRes, *nextProcessRes;
Process* resultProcess;
if (g_processList.num == 0) {
return NULL;
}
// Find the last element
firstProcessRes = headProcessRes->next;
nextProcessRes = firstProcessRes;
while ((nextProcessRes != NULL) && (nextProcessRes->next != NULL)) {
firstProcessRes = nextProcessRes;
nextProcessRes = firstProcessRes->next;
}
resultProcess = firstProcessRes->process;
firstProcessRes->next = NULL;
g_processList.num--;
return resultProcess;
}
void FreeProcessResList(void)
{
ProcessRes *frontProcessRes = g_processList.processRes;
ProcessRes *nextProcessRes = NULL;
ProcessRes *tmpProcessRes = NULL;
nextProcessRes = frontProcessRes->next;
while (nextProcessRes != NULL) {
tmpProcessRes = nextProcessRes->next;
free(nextProcessRes);
nextProcessRes = tmpProcessRes;
}
free(g_processList.processRes);
memset_s(&g_processList, sizeof(g_processList), 0, sizeof(g_processList));
return;
}
int InitProcess(void)
{
g_process= (Process*)malloc(sizeof(Process));
ASSERT_RETURN(g_process != NULL, "Malloc ProcessRes Error");
(void)memset_s(g_process, sizeof(Process), 0, sizeof(Process));
return SUCCESS;
}
Process *GetProcess(void)
{
return g_process;
}
void FreeProcess(void)
{
if (g_process != NULL) {
free(g_process);
g_process = NULL;
}
return;
}
void MonitorControlChannel(void)
{
fd_set fdSet;
char *endPtr = NULL;
int ret, fdMax, index;
ControlChannelBuf dataBuf;
ControlChannelRes *channelInfo;
channelInfo = GetControlChannelRes();
int32_t fd = channelInfo->sockFd;
fdMax = fd + 1;
struct timeval stTimeOut = {0};
while (!channelInfo->isExit) {
stTimeOut.tv_sec = 1;
stTimeOut.tv_usec = 0;
FD_ZERO(&fdSet);
FD_SET(fd, &fdSet);
ret = select(fdMax, &fdSet, NULL, NULL, &stTimeOut);
if (ret <= 0) {
LOG_ERROR("Select Error");
continue;
}
if (FD_ISSET(fd, &fdSet)) {
ret = ControlChannelRead(fd, &dataBuf);
if (ret != SUCCESS) {
LOG_ERROR("ControlChannelRead Error");
continue;
}
CmdData cmdData = {0};
ret = ParseCmdFromStr(dataBuf.data, &cmdData);
index = (int)strtol(cmdData.id, &endPtr, 0) % MAX_RCV_BUFFER_NUM;
ret = PushResultToChannelIdBuffer(channelInfo, dataBuf.data, index);
if (ret != SUCCESS) {
LOG_ERROR("PushResultToChannelRcvBuffer Error");
return;
}
LOG_DEBUG("Local Process Rcv is %s", dataBuf.data);
} else {
LOG_ERROR("FD_ISSET Error");
}
}
}
HLT_Process *InitSrcProcess(TLS_TYPE tlsType, char *srcDomainPath)
{
int ret, srcPathLen;
ControlChannelRes *channelInfo;
char srcControlDomainPath[DOMAIN_PATH_LEN] = {0};
HLT_Process *process;
// Check whether the call is the first time.
process = GetProcess();
if (process != NULL) {
LOG_ERROR("Repeat Init LocalProcess Is Not Support");
return NULL;
}
// The printf output buffer is not set.
setbuf(stdout, NULL);
// Initializes the command statistics global variable, which is required only by the local process.
InitCmdIndex();
srcPathLen = strlen(srcDomainPath);
if (srcPathLen == 0) {
LOG_ERROR("srcDomainPath is NULL");
return NULL;
}
ret = sprintf_s(srcControlDomainPath, DOMAIN_PATH_LEN, "%s.%u.sock", basename(srcDomainPath), getpid());
ret = InitProcess();
if (ret != SUCCESS) {
LOG_ERROR("InitProcess Error");
return NULL;
}
process = GetProcess();
if (HLT_LibraryInit(tlsType) != SUCCESS) {
LOG_ERROR("HLT_TlsRegCallback ERROR is %d", ret);
goto ERR;
}
// Initialize the process resource linked list, which is used to store remote process resources.
ret = InitProcessList();
if (ret != SUCCESS) {
LOG_ERROR("InitProcessList ERROR");
goto ERR;
}
// Initializes the CTX SSL resource linked list.
ret = InitTlsResList();
if (ret != SUCCESS) {
LOG_ERROR("InitTlsResList ERROR");
goto ERR;
}
// Initialize the control link.
ret = InitControlChannelRes(srcControlDomainPath, strlen(srcControlDomainPath), NULL, 0);
if (ret != SUCCESS) {
LOG_ERROR("InitControlChannelRes ERROR");
goto ERR;
}
channelInfo = GetControlChannelRes();
// Create control link UDP domain socket
ret = ControlChannelInit(channelInfo);
if (ret != SUCCESS) {
LOG_ERROR("ControlChannelInit ERROR");
goto ERR;
}
// Start a thread to listen to the control link. The link is used to receive the results returned by other processes
pthread_t tId;
channelInfo->isExit = false;
if (pthread_create(&tId, NULL, (void*)MonitorControlChannel, NULL) != 0) {
LOG_ERROR("Create MonitorControlChannel Thread Error ...");
goto ERR;
}
channelInfo->tid = tId;
// Populate Process Information
process->tlsType = tlsType;
process->controlChannelFd = channelInfo->sockFd;
process->remoteFlag = 0;
process->tlsResNum = 0;
process->hltTlsResNum = 0;
process->connType = NONE_TYPE;
process->connFd = 0;
ret = memcpy_s(process->srcDomainPath, DOMAIN_PATH_LEN, srcControlDomainPath, strlen(srcControlDomainPath));
if (ret != EOK) {
LOG_ERROR("memcpy_s process->srcDomainPath ERROR");
goto ERR;
}
LOG_DEBUG("Init Local Process Successful");
return (HLT_Process*)process;
ERR:
free(process);
return NULL;
}
HLT_Process *InitPeerProcess(TLS_TYPE tlsType, HILT_TransportType connType, int port, bool isBlock)
{
// peerDomainPath address, which is the IP address of the monitoring process.
// Creating a Process
int ret, peerPathLen, tryNum;
char startCmd[CMD_MAX_LEN] = {0};
HLT_Process *localProcess;
HLT_Process *process = NULL;
localProcess = GetProcess();
if (localProcess == NULL) {
LOG_ERROR("Must Call HLT_InitLocalProcess First");
return NULL;
}
peerPathLen = strlen(localProcess->srcDomainPath);
if (peerPathLen == 0) {
LOG_ERROR("peerDomainPath is NULL");
return NULL;
}
process = (HLT_Process*)malloc(sizeof(HLT_Process));
if (process == NULL) {
LOG_ERROR("Malloc Process is NULL");
return NULL;
}
(void)memset_s(process, sizeof(HLT_Process), 0, sizeof(HLT_Process));
pid_t localpid = getpid();
ret = sprintf_s(startCmd,
CMD_MAX_LEN,
START_PROCESS_CMD,
tlsType,
localProcess->srcDomainPath,
g_processIndex,
localProcess->srcDomainPath,
localpid,
localProcess->srcDomainPath,
g_processIndex);
if (ret == 0) {
LOG_ERROR("sprintf_s Error");
free(process);
return NULL;
}
LOG_DEBUG("Exect Cmd is %s", startCmd);
ret = system(startCmd);
if (ret == ERROR) {
LOG_ERROR("System Error");
free(process);
return NULL;
}
// After the remote process is started successfully, the remote process is stored in the linked list.
InsertProcessToList(process);
// The message is received, indicating that the peer end is in the receiveable state.
CmdData expectCmdData = {0};
(void)sprintf_s(expectCmdData.id, sizeof(expectCmdData.id), "0");
(void)sprintf_s(expectCmdData.funcId, sizeof(expectCmdData.funcId), "HEART");
tryNum = 0;
do {
ret = WaitResultFromPeer(&expectCmdData);
tryNum++;
} while ((ret == ERROR) && (tryNum < 2)); // Retry once
if (ret == ERROR) {
LOG_ERROR("WaitResultFromPeer Error");
goto ERR;
}
// Populate Process Information
process->connType = NONE_TYPE;
process->connFd = 0;
process->tlsType = tlsType;
process->remoteFlag = 1;
ret = sprintf_s(process->srcDomainPath, DOMAIN_PATH_LEN, "%s_%d", localProcess->srcDomainPath, g_processIndex);
if (ret <= 0) {
LOG_ERROR("sprintf_s Error");
goto ERR;
}
// Creating a Data Link
if (connType != NONE_TYPE) {
DataChannelParam channelParam;
HLT_FD sockFd = {0};
channelParam.port = port;
channelParam.type = connType;
channelParam.isBlock = isBlock; // The SCTP link is set to non-block. Otherwise, the SCTP link may be suspended.
sockFd = HLT_CreateDataChannel(process, localProcess, channelParam);
localProcess->connType = connType;
localProcess->connFd = sockFd.peerFd;
localProcess->sockAddr = sockFd.sockAddr;
process->connType = connType;
process->connFd = sockFd.srcFd;
process->connPort = sockFd.connPort;
if ((sockFd.srcFd <= 0) || (sockFd.peerFd <= 0)) {
LOG_ERROR("Create CHANNEL ERROR");
goto ERR;
}
}
g_processIndex++;
return (HLT_Process*)process;
ERR:
// You do not need to release the process. If you can go to this point,
// the process is successfully created and inserted into the table.
// The process resource is released in the HLT_FreeAllProcess function.
// If the remote process is released in advance, the remote process may be successfully started but cannot be exited
g_processIndex++;
return NULL;
}
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/process/src/process.c | C | unknown | 12,643 |
/*
* 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.
*/
#ifndef CHANNEL_RES_H
#define CHANNEL_RES_H
#include <stdio.h>
#include <stdint.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <stdbool.h>
#include <fcntl.h>
#include "lock.h"
#ifdef __cplusplus
extern "C" {
#endif
#define CONTROL_CHANNEL_MAX_MSG_LEN (20 * 1024)
#define DOMAIN_PATH_LEN (128)
#define MAX_SEND_BUFFER_NUM (100)
#define MAX_RCV_BUFFER_NUM (100)
typedef struct {
uint8_t *data;
uint32_t dataLen;
} DataBuf;
typedef struct {
char data[CONTROL_CHANNEL_MAX_MSG_LEN];
uint32_t dataLen;
} ControlChannelBuf;
typedef struct {
char srcDomainPath[DOMAIN_PATH_LEN];
char peerDomainPath[DOMAIN_PATH_LEN];
struct sockaddr_un srcAddr;
struct sockaddr_un peerAddr;
int32_t sockFd;
char sendBuffer[MAX_SEND_BUFFER_NUM][CONTROL_CHANNEL_MAX_MSG_LEN];
char rcvBuffer[MAX_RCV_BUFFER_NUM][CONTROL_CHANNEL_MAX_MSG_LEN];
uint8_t sendBufferNum;
Lock *sendBufferLock;
uint8_t rcvBufferNum;
Lock *rcvBufferLock;
pthread_t tid;
bool isExit;
} ControlChannelRes;
/**
* @brief Control Link Resource Initialization
*/
int InitControlChannelRes(char *srcDomainPath, int srcDomainPathLen, char *peerDomainPath, int peerDomainPathLen);
/**
* @brief Release control link resources.
*/
void FreeControlChannelRes(void);
/**
* @brief Obtaining Control Link Resources
*/
ControlChannelRes* GetControlChannelRes(void);
/**
* @brief Writes data to the control link
*/
int PushResultToChannelSendBuffer(ControlChannelRes *channelInfo, char *result);
/**
* @brief Read data from the control link
*/
int PushResultToChannelRcvBuffer(ControlChannelRes *channelInfo, char *result);
/**
* @brief Writes data to the control link by ID
*/
int PushResultToChannelIdBuffer(ControlChannelRes *channelInfo, char *result, int id);
#ifdef __cplusplus
}
#endif
#endif // CHANNEL_RES_H
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/resource/include/channel_res.h | C | unknown | 2,431 |
/*
* 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.
*/
#ifndef TLS_RES_H
#define TLS_RES_H
#include <stdint.h>
#include "lock.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct Res {
void *tlsRes; // Indicates the CTX or SSL resource.
int ctxId; // This field is used only in sslList, indicating the ctx from which the SSL is generated.
struct Res *next;
uint8_t id; // Indicates the sequence number of a resource, that is, the number of times that the resource
// is created. The value starts from 0.
} Res;
typedef struct {
Res *res;
uint8_t num;
Lock *resListLock;
} ResList;
/**
* @brief Initializing the TLS Resource Linked List
*/
int InitTlsResList(void);
/**
* @brief Releasing the TLS Resource Linked List
*/
void FreeTlsResList(void);
/**
* @brief Releases CTX and SSL resources in the linked list based on CTX resources.
*/
int FreeResFromSsl(const void *ctx);
/**
* @brief Insert CTX resources into the linked list.
*/
int InsertCtxToList(void *ctx);
/**
* @brief Insert SSL resources into the linked list.
*/
int InsertSslToList(void* ctx, void *ssl);
/**
* @brief Obtains the CTX linked list from the linked list.
*/
ResList* GetCtxList(void);
/**
* @brief Obtains the SSL linked list from the linked list.
*/
ResList* GetSslList(void);
/**
* @brief Obtain the CTX from the CTX linked list based on the ID.
*/
int GetCtxIdFromSsl(const void* tls);
/**
* @brief Obtains the TLS RES in the linked list.
*/
Res* GetResFromTlsResList(ResList *resList, const void* tlsRes);
/**
* @brief Obtains TLS RES from the linked list based on the ID.
*/
void* GetTlsResFromId(ResList *resList, int id);
#ifdef __cplusplus
}
#endif
#endif // TLS_RES_H
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/resource/include/tls_res.h | C | unknown | 2,216 |
/*
* 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 <sys/time.h>
#include "logger.h"
#include "securec.h"
#include "lock.h"
#include "channel_res.h"
#define SUCCESS 0
#define ERROR (-1)
static ControlChannelRes g_channelRes;
static int SetControlChannelRes(ControlChannelRes *channelInfo, char *srcDomainPath, char *peerDomainPath)
{
int ret;
// Translate the source address.
ret = memset_s(&(channelInfo->srcAddr), sizeof(struct sockaddr_un), 0, sizeof(struct sockaddr_un));
if (ret != EOK) {
LOG_ERROR("memset_s Error\n");
return ERROR;
}
ret = memcpy_s(channelInfo->srcDomainPath, DOMAIN_PATH_LEN, srcDomainPath, strlen(srcDomainPath));
if (ret != EOK) {
LOG_ERROR("memcpy_s Error\n");
return ERROR;
}
channelInfo->srcAddr.sun_family = AF_UNIX;
ret = strcpy_s(channelInfo->srcAddr.sun_path, strlen(srcDomainPath) + 1, srcDomainPath);
if (ret != EOK) {
LOG_ERROR("strcpy_s Error");
return ERROR;
}
ret = memset_s(channelInfo->peerDomainPath, sizeof(channelInfo->peerDomainPath),
0, sizeof(channelInfo->peerDomainPath));
if (ret != EOK) {
LOG_ERROR("memset_s Error\n");
return ERROR;
}
if (peerDomainPath != NULL) {
ret = memcpy_s(channelInfo->peerDomainPath, DOMAIN_PATH_LEN, peerDomainPath, strlen(peerDomainPath));
if (ret != EOK) {
LOG_ERROR("memcpy_s Error\n");
return ERROR;
}
channelInfo->peerAddr.sun_family = AF_UNIX;
ret = strcpy_s(channelInfo->peerAddr.sun_path, strlen(peerDomainPath) + 1, peerDomainPath);
if (ret != EOK) {
LOG_ERROR("strcpy_s Error");
return ERROR;
}
}
return SUCCESS;
}
int InitControlChannelRes(char *srcDomainPath, int srcDomainPathLen, char *peerDomainPath, int peerDomainPathLen)
{
int ret;
if ((srcDomainPathLen <= 0) && (peerDomainPathLen <= 0)) {
LOG_ERROR("srcDomainPathLen or peerDomainPathLen is 0");
return ERROR;
}
ret = memset_s(&g_channelRes, sizeof(ControlChannelRes), 0, sizeof(ControlChannelRes));
if (ret != EOK) {
return ERROR;
}
// Initializing the Send Buffer Lock
g_channelRes.sendBufferLock = OsLockNew();
if (g_channelRes.sendBufferLock == NULL) {
LOG_ERROR("OsLockNew Error");
return ERROR;
}
// Initialize the receive buffer lock.
g_channelRes.rcvBufferLock = OsLockNew();
if (g_channelRes.rcvBufferLock == NULL) {
LOG_ERROR("OsLockNew Error");
return ERROR;
}
// Initializes the communication address used for UDP Domain Socket communication.
return SetControlChannelRes(&g_channelRes, srcDomainPath, peerDomainPath);
}
ControlChannelRes *GetControlChannelRes(void)
{
return &g_channelRes;
}
int PushResultToChannelSendBuffer(ControlChannelRes *channelInfo, char *result)
{
int ret;
OsLock(channelInfo->sendBufferLock);
if (channelInfo->sendBufferNum == MAX_SEND_BUFFER_NUM) {
LOG_ERROR("Channel Send Buffer Is Full, Please Try Again");
OsUnLock(channelInfo->sendBufferLock);
return 1; // The value 1 indicates that the current buffer is full and needs to be retried.
}
(void)memset_s(channelInfo->sendBuffer + channelInfo->sendBufferNum,
CONTROL_CHANNEL_MAX_MSG_LEN, 0, CONTROL_CHANNEL_MAX_MSG_LEN);
ret = memcpy_s(channelInfo->sendBuffer + channelInfo->sendBufferNum,
CONTROL_CHANNEL_MAX_MSG_LEN, result, strlen(result));
if (ret != EOK) {
LOG_ERROR("memcpy_s Error");
OsUnLock(channelInfo->sendBufferLock);
return ERROR;
}
channelInfo->sendBufferNum++;
channelInfo->sendBufferNum %= MAX_SEND_BUFFER_NUM;
OsUnLock(channelInfo->sendBufferLock);
return SUCCESS;
}
int PushResultToChannelRcvBuffer(ControlChannelRes *channelInfo, char *result)
{
int ret;
OsLock(channelInfo->rcvBufferLock);
if (channelInfo->rcvBufferNum == MAX_RCV_BUFFER_NUM) {
LOG_ERROR("Channel Send Buffer Is Full, Please Try Again");
OsUnLock(channelInfo->rcvBufferLock);
return 1; // The value 1 indicates that the current buffer is full and needs to be retried.
}
(void)memset_s(channelInfo->rcvBuffer + channelInfo->rcvBufferNum,
CONTROL_CHANNEL_MAX_MSG_LEN, 0, CONTROL_CHANNEL_MAX_MSG_LEN);
ret = memcpy_s(channelInfo->rcvBuffer + channelInfo->rcvBufferNum,
CONTROL_CHANNEL_MAX_MSG_LEN, result, strlen(result));
if (ret != EOK) {
LOG_ERROR("memcpy_s Error");
OsUnLock(channelInfo->rcvBufferLock);
return ERROR;
}
channelInfo->rcvBufferNum++;
channelInfo->rcvBufferNum %= MAX_RCV_BUFFER_NUM;
OsUnLock(channelInfo->rcvBufferLock);
return SUCCESS;
}
int PushResultToChannelIdBuffer(ControlChannelRes *channelInfo, char *result, int id)
{
int ret;
OsLock(channelInfo->rcvBufferLock);
(void)memset_s(channelInfo->rcvBuffer + (id % MAX_RCV_BUFFER_NUM),
CONTROL_CHANNEL_MAX_MSG_LEN, 0, CONTROL_CHANNEL_MAX_MSG_LEN);
ret = memcpy_s(channelInfo->rcvBuffer + (id % MAX_RCV_BUFFER_NUM),
CONTROL_CHANNEL_MAX_MSG_LEN, result, strlen(result));
if (ret != EOK) {
LOG_ERROR("memcpy_s Error");
OsUnLock(channelInfo->rcvBufferLock);
return ERROR;
}
OsUnLock(channelInfo->rcvBufferLock);
return SUCCESS;
}
void FreeControlChannelRes(void)
{
if (g_channelRes.tid != 0) {
g_channelRes.isExit = true;
pthread_join(g_channelRes.tid, NULL);
}
OsLockDestroy(g_channelRes.sendBufferLock);
OsLockDestroy(g_channelRes.rcvBufferLock);
memset_s(&g_channelRes, sizeof(g_channelRes), 0, sizeof(g_channelRes));
return;
}
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/resource/src/channel_res.c | C | unknown | 6,327 |
/*
* 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 <stdio.h>
#include <stdint.h>
#include "securec.h"
#include "lock.h"
#include "logger.h"
#include "hitls_func.h"
#include "process.h"
#include "tls_res.h"
#define SUCCESS 0
#define ERROR (-1)
ResList g_ctxList;
ResList g_sslList;
int InitTlsResList(void)
{
// Initializes the CTX resource management linked list.
(void)memset_s(&g_ctxList, sizeof(ResList), 0, sizeof(ResList));
g_ctxList.resListLock = OsLockNew();
if (g_ctxList.resListLock == NULL) {
LOG_ERROR("OsLockNew Error");
return ERROR;
}
// Indicates the head element in the linked list, which does not store any resource.
g_ctxList.res = (Res *)malloc(sizeof(Res));
if (g_ctxList.res == NULL) {
OsLockDestroy(g_ctxList.resListLock);
return ERROR;
}
(void)memset_s(g_ctxList.res, sizeof(Res), 0, sizeof(Res));
g_ctxList.num = 0;
// Initializing the SSL Resource Management Linked List
(void)memset_s(&g_sslList, sizeof(ResList), 0, sizeof(ResList));
g_sslList.resListLock = OsLockNew();
if (g_sslList.resListLock == NULL) {
LOG_ERROR("OsLockNew Error");
free(g_ctxList.res);
OsLockDestroy(g_ctxList.resListLock);
g_ctxList.resListLock = NULL;
return ERROR;
}
// Indicates the head element in the linked list, which does not store any resource.
g_sslList.res = (Res *)malloc(sizeof(Res));
if (g_sslList.res == NULL) {
free(g_ctxList.res);
OsLockDestroy(g_ctxList.resListLock);
OsLockDestroy(g_sslList.resListLock);
return ERROR;
}
(void)memset_s(g_sslList.res, sizeof(Res), 0, sizeof(Res));
g_sslList.num = 0;
return SUCCESS;
}
int InsertResToList(ResList *resList, Res tempRes)
{
int id;
Res *curRes = NULL;
Res *res = (Res*)malloc(sizeof(Res));
if (res == NULL) {
return ERROR;
}
memset_s(res, sizeof(Res), 0, sizeof(Res));
// Insert in the lock
OsLock(resList->resListLock);
id = resList->num;
res->ctxId = tempRes.ctxId;
res->tlsRes = tempRes.tlsRes;
res->next = NULL;
res->id = id;
// In the linked list, the first element is NULL by default and is used as the start element.
curRes = resList->res->next;
// When the first element is empty
if (curRes == NULL) {
resList->res->next = res;
resList->num++;
OsUnLock(resList->resListLock);
return id;
}
// Find the tail element
while (curRes->next != NULL) {
curRes = curRes->next;
}
curRes->next = res;
resList->num++;
OsUnLock(resList->resListLock);
return id;
}
int InsertCtxToList(void *tlsRes)
{
ResList *resList = GetCtxList();
Res ctxRes = {0};
ctxRes.tlsRes = tlsRes;
ctxRes.ctxId = -1; // This field is used only in the SSL linked list.
return InsertResToList(resList, ctxRes);
}
static int GetTlsIdFromResList(ResList *resList, const void *tls)
{
Res *tlsRes = GetResFromTlsResList(resList, tls);
if (tlsRes == NULL) {
LOG_ERROR("GetResFromTlsResList ERROR");
return ERROR;
}
// Indicates the serial number of a resource.
return tlsRes->id;
}
int InsertSslToList(void *ctx, void *ssl)
{
int ctxId;
Res sslRes = {0};
ResList *ctxList = GetCtxList();
ResList *sslList = GetSslList();
ctxId = GetTlsIdFromResList(ctxList, ctx);
if (ctxId == ERROR) {
LOG_ERROR("GetTlsIdFromResList Error");
return ERROR;
}
sslRes.tlsRes = ssl;
sslRes.ctxId = ctxId; // This field is used only in the SSL linked list and indicates the CTX that is created.
return InsertResToList(sslList, sslRes);
}
ResList *GetCtxList(void)
{
return &g_ctxList;
}
ResList *GetSslList(void)
{
return &g_sslList;
}
Res *GetResFromTlsResList(ResList *resList, const void *tlsRes)
{
Res *tmpRes = NULL;
OsLock(resList->resListLock);
// In the linked list, the first element is NULL by default and is used as the start element.
tmpRes = resList->res->next;
while (tmpRes != NULL) {
if (tmpRes->tlsRes == tlsRes) {
OsUnLock(resList->resListLock);
return tmpRes;
}
tmpRes = tmpRes->next;
}
OsUnLock(resList->resListLock);
return NULL;
}
static Res *GetResFromId(ResList *resList, int id)
{
Res *tmpRes = NULL;
OsLock(resList->resListLock);
// In the linked list, the first element is NULL by default and is used as the start element.
tmpRes = resList->res->next;
while (tmpRes != NULL) {
if (tmpRes->id == id) {
OsUnLock(resList->resListLock);
return tmpRes;
}
tmpRes = tmpRes->next;
}
OsUnLock(resList->resListLock);
return NULL;
}
void *GetTlsResFromId(ResList *resList, int id)
{
Res *res = GetResFromId(resList, id);
if (res == NULL) {
LOG_ERROR("GetResFromId error");
return NULL;
}
return res->tlsRes;
}
int GetCtxIdFromSsl(const void *tls)
{
ResList *sslList = GetSslList();
Res *tmpRes = GetResFromTlsResList(sslList, tls);
if (tmpRes == NULL) {
LOG_ERROR("GetResFromTlsResList ERROR");
return ERROR;
}
// CTX ID corresponding to SSL
return tmpRes->ctxId;
}
static void *GetLastResFromList(ResList *resList)
{
Res *headRes = resList->res;
Res *frontRes = NULL;
Res *nextRes = NULL;
if (resList->num == 0) {
return NULL;
}
frontRes = headRes->next;
nextRes = frontRes;
// Find the last element
while ((nextRes != NULL) && (nextRes->tlsRes != NULL)) {
frontRes = nextRes;
nextRes = frontRes->next;
}
resList->num--;
return frontRes;
}
void FreeResList(ResList *resList)
{
Res *curRes = NULL;
Res *tmpRes = NULL;
OsLock(resList->resListLock);
curRes = resList->res->next;
while (curRes != NULL) {
tmpRes = curRes->next;
free(curRes);
curRes = tmpRes;
}
OsUnLock(resList->resListLock);
free(resList->res);
OsLockDestroy(resList->resListLock);
}
void FreeCtx(TLS_TYPE tlsType, Res *ctxRes)
{
switch (tlsType) {
case HITLS:
HitlsFreeCtx(ctxRes->tlsRes);
break;
default:
/* Unknown type */
return;
}
ctxRes->tlsRes = NULL;
return;
}
void FreeSsl(TLS_TYPE tlsType, Res *sslRes)
{
switch (tlsType) {
case HITLS:
HitlsFreeSsl(sslRes->tlsRes);
break;
default:
/* Unknown type */
return;
}
sslRes->tlsRes = NULL;
return;
}
void FreeTlsResList(void)
{
Process *process = GetProcess();
TLS_TYPE type = process->tlsType;
// Clearing CTX Resources
ResList *ctxList = GetCtxList();
void *resCtx = GetLastResFromList(ctxList);
while (resCtx != NULL) {
FreeCtx(type, resCtx);
resCtx = GetLastResFromList(ctxList);
}
FreeResList(ctxList);
// Clearing SSL Resources
ResList *sslList = GetSslList();
void *sslRes = GetLastResFromList(sslList);
while (sslRes != NULL) {
FreeSsl(type, sslRes);
sslRes = GetLastResFromList(sslList);
}
FreeResList(sslList);
return;
}
int FreeResFromSsl(const void *ctx)
{
Process *process = GetProcess();
TLS_TYPE type = process->tlsType;
ResList *sslList = GetSslList();
Res *preRes = NULL;
Res *curRes = NULL;
Res *nextRes = NULL;
OsLock(sslList->resListLock);
preRes = sslList->res;
curRes = sslList->res->next;
while (curRes != NULL) {
if (curRes->tlsRes == ctx) {
nextRes = curRes->next;
FreeSsl(type, curRes);
FreeCtx(type, curRes);
free(curRes);
preRes->next = nextRes;
sslList->num--;
OsUnLock(sslList->resListLock);
return SUCCESS;
}
preRes = curRes;
curRes = curRes->next;
}
OsUnLock(sslList->resListLock);
return ERROR;
} | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/resource/src/tls_res.c | C | unknown | 8,569 |
/*
* 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.
*/
#ifndef COMMON_FUNC_H
#define COMMON_FUNC_H
#include <stdatomic.h>
#include "hlt_type.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef enum {
EE_CERT,
PRIVE_KEY,
CA_CERT,
CHAIN_CERT
} CERT_TYPE;
typedef struct {
atomic_int mallocCnt;
atomic_int freeCnt;
atomic_int mallocSize;
atomic_int freeSize;
atomic_int maxMemSize;
} MemCnt;
/**
* @brief Load a certificate from a file.
*/
int LoadCertFromFile(void *ctx, char *pCert, CERT_TYPE certType);
/**
* @brief Memory application that contains the count
*/
void *CountMalloc(uint32_t len);
/**
* @brief Memory release that contains the count
*/
void CountFree(void *addr);
/**
* @brief Clear the memory count.
*/
void ClearMemCntData(void);
/**
* @brief Obtain the memory count.
*/
MemCnt *GetMemCntData(void);
int32_t ExampleSetPsk(char *psk);
uint32_t ExampleClientCb(HITLS_Ctx *ctx, const uint8_t *hint, uint8_t *identity, uint32_t maxIdentityLen,
uint8_t *psk, uint32_t maxPskLen);
uint32_t ExampleServerCb(HITLS_Ctx *ctx, const uint8_t *identity, uint8_t *psk, uint32_t maxPskLen);
int32_t ExampleTicketKeySuccessCb(uint8_t *keyName, uint32_t keyNameSize, void *cipher, uint8_t isEncrypt);
int32_t ExampleTicketKeyRenewCb(uint8_t *keyName, uint32_t keyNameSize, void *cipher, uint8_t isEncrypt);
void *GetTicketKeyCb(char *str);
void *GetExtensionCb(const char *str);
void *GetExampleData(const char *str);
#ifdef __cplusplus
}
#endif
#endif // COMMON_FUNC_H | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/rpc/include/common_func.h | C | unknown | 2,011 |
/*
* 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.
*/
#ifndef HITLS_FUNC_H
#define HITLS_FUNC_H
#include "hitls_config.h"
#include "bsl_uio.h"
#include "hlt_type.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Hitls initialization
*/
int HitlsInit(void);
/**
* @brief HiTLS Create connection management resources.
*/
void* HitlsNewCtx(TLS_VERSION tlsVersion);
HITLS_Config *HitlsProviderNewCtx(char *providerPath, char (*providerNames)[MAX_PROVIDER_NAME_LEN], int *providerLibFmts,
int providerCnt, char *attrName, TLS_VERSION tlsVersion);
/**
* @brief HiTLS Releases connection management resources.
*/
void HitlsFreeCtx(void *ctx);
/**
* @brief HiTLS Setting connection information
*/
int HitlsSetCtx(HITLS_Config *config, HLT_Ctx_Config *ctxConfig);
/**
* @brief HiTLS Creating an SSL resource
*/
void* HitlsNewSsl(void *ctx);
/**
* @brief HiTLS Releases SSL resources.
*/
void HitlsFreeSsl(void *ssl);
/**
* @brief HiTLS Set TLS information.
*/
int HitlsSetSsl(void *ssl, HLT_Ssl_Config *sslConfig);
/**
* @brief HiTLS waits for a TLS connection.
*/
void *HitlsAccept(void *ssl);
/**
* @brief The HiTLS initiates a TLS connection.
*/
int HitlsConnect(void *ssl);
/**
* @brief HiTLS writes data through the TLS connection.
*/
int HitlsWrite(void *ssl, uint8_t *data, uint32_t dataLen);
/**
* @brief HiTLS reads data through the TLS connection.
*/
int HitlsRead(void *ssl, uint8_t *data, uint32_t bufSize, uint32_t *readLen);
/**
* @brief HiTLS Disables the TLS connection.
*/
int HitlsClose(void *ssl);
/**
* @brief HiTLS supports renegotiation through TLS connection.
*/
int HitlsRenegotiate(void *ssl);
int HitlsSetMtu(void *ssl, uint16_t mtu);
int HitlsSetSession(void *ssl, void *session);
int HitlsSessionReused(void *ssl);
void *HitlsGet1Session(void *ssl);
int HitlsSessionHasTicket(void *session);
int HitlsSessionIsResumable(void *session);
void HitlsFreeSession(void *session);
int HitlsGetErrorCode(void *ssl);
/**
* @brief Obtaining method based on the connection type
*/
BSL_UIO_Method *GetDefaultMethod(BSL_UIO_TransportType type);
#ifdef __cplusplus
}
#endif
#endif // HITLS_FUNC_H
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/rpc/include/hitls_func.h | C | unknown | 2,622 |
/*
* 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.
*/
#ifndef RPC_FUNC_H
#define RPC_FUNC_H
#include <pthread.h>
#include "handle_cmd.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
char *funcId;
int (*hfunc)(CmdData *cmdData);
} RpcFunList;
/**
* @brief Obtain the list of registered functions.
*/
RpcFunList* GetRpcFuncList(void);
/**
* @brief Obtain the number of registered functions.
*/
int GetRpcFuncNum(void);
/**
* @brief Invoke the RPC to create CTX resources.
*/
int RpcTlsNewCtx(CmdData*);
/**
* @brief Invoke the RPC to create CTX resources with provider.
*/
int RpcProviderTlsNewCtx(CmdData *cmdData);
/**
* @brief Invoke the RPC to set the CTX information.
*/
int RpcTlsSetCtx(CmdData*);
/**
* @brief Invoke the RPC to create an SSL resource.
*/
int RpcTlsNewSsl(CmdData*);
/**
* @brief Invoke the RPC to set the SSL information.
*/
int RpcTlsSetSsl(CmdData*);
/**
* @brief The RPC invokes the TLS connection to be listened on.
*/
int RpcTlsListen(CmdData *cmdData);
/**
* @brief Invoke the RPC to wait for the TLS connection.
*/
int RpcTlsAccept(CmdData*);
/**
* @brief Invoke the RPC interface for TLS connection.
*/
int RpcTlsConnect(CmdData*);
/**
* @brief Invoke the RPC to read data through TLS.
*/
int RpcTlsRead(CmdData *cmdData);
/**
* @brief Invoke the RPC to write data through TLS.
*/
int RpcTlsWrite(CmdData *cmdData);
/**
* @brief Invoke the RPC interface to enable renegotiation.
*/
int RpcTlsRenegotiate(CmdData *cmdData);
/**
* @brief The RPC call is used to enable the pha.
*/
int RpcTlsVerifyClientPostHandshake(CmdData *cmdData);
/**
* @brief The RPC exits the process
*/
int RpcProcessExit(CmdData*);
/**
* @brief RPC bound port
*/
int RunDataChannelBind(void *param);
/**
* @brief RPC listening data connection
*/
int RpcDataChannelAccept(CmdData*);
/**
* @brief The RPC data initiates a connection.
*/
int RpcDataChannelConnect(CmdData *cmdData);
/**
* @brief RPC listens on a certain type of data connection.
*/
int RunDataChannelAccept(void *param);
/**
* @brief RPC bound port
*/
int RpcDataChannelBind(CmdData *cmdData);
/**
* @brief RPC registration hook
*/
int RpcTlsRegCallback(CmdData *cmdData);
/**
* @brief RPC Obtain the SSL connection status.
*/
int RpcTlsGetStatus(CmdData *cmdData);
/**
* @brief RPC Obtain the flag of the alert message.
*/
int RpcTlsGetAlertFlag(CmdData *cmdData);
/**
* @brief RPC Obtain the level of the alert message.
*/
int RpcTlsGetAlertLevel(CmdData *cmdData);
/**
* @brief RPC Obtain the description of the alert message.
*/
int RpcTlsGetAlertDescription(CmdData *cmdData);
/**
* @brief RPC Disable the TLS connection.
*/
int RpcTlsClose(CmdData *cmdData);
/**
* @brief RPC Release the CTX and SSL contexts.
*/
int RpcFreeResFormSsl(CmdData *cmdData);
int RpcCloseFd(CmdData *cmdData);
int RpcTlsSetMtu(CmdData *cmdData);
int RpcTlsGetErrorCode(CmdData *cmdData);
#ifdef __cplusplus
}
#endif
#endif // RPC_FUNC_H
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/rpc/include/rpc_func.h | C | unknown | 3,438 |
/*
* 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 <malloc.h>
#include <stdatomic.h>
#include "securec.h"
#include "hitls_crypt_type.h"
#include "hitls_session.h"
#include "logger.h"
#include "bsl_sal.h"
#include "hitls_error.h"
#include "hitls_sni.h"
#include "sni.h"
#include "hitls_alpn.h"
#include "hitls_type.h"
#include "common_func.h"
#define SUCCESS 0
#define ERROR (-1)
#define MAX_CERT_PATH_LENGTH (128)
#define SINGLE_CERT_LEN (120)
#define KEY_NAME_SIZE 16
#define IV_SIZE 16
#define KEY_SIZE 32
#define RENEGOTIATE_FAIL 1
static uint8_t g_keyName[KEY_NAME_SIZE] = {
0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A
};
static uint8_t g_key[KEY_SIZE] = {
0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A,
0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A
};
static uint8_t g_iv[IV_SIZE] = {
0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A
};
typedef struct {
char *name;
void *cb;
} ExampleCb;
typedef struct {
char *name;
void *(*data)(void);
} ExampleData;
#define ASSERT_RETURN(condition, log) \
do { \
if (!(condition)) { \
LOG_ERROR(log); \
return ERROR; \
} \
} while (0)
static char g_localIdentity[PSK_MAX_LEN] = "Client_identity";
static char g_localPsk[PSK_MAX_LEN] = "1A1A1A1A1A";
int32_t ExampleSetPsk(char *psk)
{
if (psk == NULL) {
LOG_DEBUG("input error.");
return -1;
}
(void)memset_s(g_localPsk, PSK_MAX_LEN, 0, PSK_MAX_LEN);
if (strcpy_s(g_localPsk, PSK_MAX_LEN, psk) != EOK) {
LOG_DEBUG("ExampleSetPsk failed.");
return -1;
}
return 0;
}
int32_t ExampleHexStr2BufHelper(const uint8_t *input, uint32_t inLen, uint8_t *out, uint32_t outLen, uint32_t *usedLen)
{
(void)inLen;
(void)outLen;
char indexH[2] = {0};
char indexL[2] = {0};
const uint8_t *curr = NULL;
uint8_t *outIndex = NULL;
int32_t high, low;
if ((input == NULL) || (out == NULL) || (usedLen == NULL)) {
return -1;
}
for (curr = input, outIndex = out; *curr;) {
indexH[0] = *curr++;
indexL[0] = *curr++;
if (indexL[0] == '\0') {
return -1;
}
high = (int32_t)strtol(indexH, NULL, 16); // Converting char to Hexadecimal numbers
low = (int32_t)strtol(indexL, NULL, 16); // Converting char to Hexadecimal numbers
if (high < 0 || low < 0) {
return -1;
}
*outIndex++ = (uint8_t)((high << 4) | low); // The upper four bits of the are shifted to the left
}
*usedLen = outIndex - out;
return 0;
}
uint32_t ExampleClientCb(HITLS_Ctx *ctx, const uint8_t *hint, uint8_t *identity, uint32_t maxIdentityLen, uint8_t *psk,
uint32_t maxPskLen)
{
(void)ctx;
(void)hint;
int32_t ret;
uint8_t pskTrans[PSK_MAX_LEN] = {0};
uint32_t pskTransUsedLen = 0u;
ret = ExampleHexStr2BufHelper((uint8_t *)g_localPsk, sizeof(g_localPsk), pskTrans, PSK_MAX_LEN, &pskTransUsedLen);
if (ret != 0) {
return 0;
}
/* strlen(g_localIdentity) + 1 copy terminator */
if (memcpy_s(identity, maxIdentityLen, g_localIdentity, strlen(g_localIdentity) + 1) != EOK) {
return 0;
}
if (memcpy_s(psk, maxPskLen, pskTrans, pskTransUsedLen) != EOK) {
return 0;
}
return pskTransUsedLen;
}
uint32_t ExampleServerCb(HITLS_Ctx *ctx, const uint8_t *identity, uint8_t *psk, uint32_t maxPskLen)
{
(void)ctx;
if (identity == NULL || strcmp((const char *)identity, g_localIdentity) != 0) {
return 0;
}
int32_t ret;
uint8_t pskTrans[PSK_MAX_LEN] = {0};
uint32_t pskTransUsedLen = 0u;
ret = ExampleHexStr2BufHelper((uint8_t *)g_localPsk, sizeof(g_localPsk), pskTrans, PSK_MAX_LEN, &pskTransUsedLen);
if (ret != 0) {
return 0;
}
if (memcpy_s(psk, maxPskLen, pskTrans, pskTransUsedLen) != EOK) {
return 0;
}
return pskTransUsedLen;
}
static void SetCipherInfo(void *cipher)
{
HITLS_CipherParameters *cipherPara = cipher;
cipherPara->type = HITLS_CBC_CIPHER;
cipherPara->algo = HITLS_CIPHER_AES_256_CBC;
cipherPara->key = g_key;
cipherPara->keyLen = sizeof(g_key);
cipherPara->hmacKey = g_key;
cipherPara->hmacKeyLen = sizeof(g_key);
cipherPara->iv = g_iv;
cipherPara->ivLen = sizeof(g_iv);
return;
}
int32_t ExampleTicketKeySuccessCb(uint8_t *keyName, uint32_t keyNameSize, void *cipher, uint8_t isEncrypt)
{
if (isEncrypt) {
if (memcpy_s(keyName, keyNameSize, g_keyName, KEY_NAME_SIZE) != EOK) {
return HITLS_TICKET_KEY_RET_FAIL;
}
SetCipherInfo(cipher);
return HITLS_TICKET_KEY_RET_SUCCESS;
}
if (memcmp(keyName, g_keyName, KEY_NAME_SIZE) != 0) {
return HITLS_TICKET_KEY_RET_FAIL;
}
SetCipherInfo(cipher);
return HITLS_TICKET_KEY_RET_SUCCESS;
}
int32_t ExampleTicketKeyRenewCb(uint8_t *keyName, uint32_t keyNameSize, void *cipher, uint8_t isEncrypt)
{
if (isEncrypt) {
if (memcpy_s(keyName, keyNameSize, g_keyName, KEY_NAME_SIZE) != EOK) {
return HITLS_TICKET_KEY_RET_FAIL;
}
SetCipherInfo(cipher);
return HITLS_TICKET_KEY_RET_SUCCESS_RENEW;
}
if (memcmp(keyName, g_keyName, KEY_NAME_SIZE) != 0) {
return HITLS_TICKET_KEY_RET_FAIL;
}
SetCipherInfo(cipher);
return HITLS_TICKET_KEY_RET_SUCCESS_RENEW;
}
int32_t ExampleTicketKeyAlertCb(uint8_t *keyName, uint32_t keyNameSize, HITLS_CipherParameters *cipher,
uint8_t isEncrypt)
{
if (isEncrypt) {
(void)memcpy_s(keyName, keyNameSize, g_keyName, KEY_NAME_SIZE);
SetCipherInfo(cipher);
return HITLS_TICKET_KEY_RET_SUCCESS_RENEW;
} else {
return HITLS_TICKET_KEY_RET_NEED_ALERT;
}
}
int32_t ExampleTicketKeyFailCb(uint8_t *keyName, uint32_t keyNameSize, HITLS_CipherParameters *cipher,
uint8_t isEncrypt)
{
if (isEncrypt) {
(void)memcpy_s(keyName, keyNameSize, g_keyName, KEY_NAME_SIZE);
SetCipherInfo(cipher);
return HITLS_TICKET_KEY_RET_SUCCESS_RENEW;
}
SetCipherInfo(cipher);
return HITLS_TICKET_KEY_RET_FAIL;
}
int32_t ExampleServerNameCb(HITLS_Ctx *ctx, int *alert, void *arg)
{
(void)ctx;
(void)arg;
*alert = HITLS_ACCEPT_SNI_ERR_OK;
return HITLS_ACCEPT_SNI_ERR_OK;
}
int32_t ExampleServerNameCbNOACK(HITLS_Ctx *ctx, int *alert, void *arg)
{
(void)ctx;
(void)alert;
(void)arg;
return HITLS_ACCEPT_SNI_ERR_NOACK;
}
int32_t ExampleServerNameCbALERT(HITLS_Ctx *ctx, int *alert, void *arg)
{
(void)ctx;
(void)alert;
(void)arg;
return HITLS_ACCEPT_SNI_ERR_ALERT_FATAL;
}
SNI_Arg *g_sniArg;
void *ExampleServerNameArg(void)
{
return g_sniArg;
}
static char *g_alpnhttp = "http";
int32_t ExampleAlpnParseProtocolList1(uint8_t *out, uint8_t *outLen, uint8_t *in, uint8_t inLen)
{
if (out == NULL || outLen == NULL || in == NULL) {
return HITLS_NULL_INPUT;
}
if (inLen == 0) {
return HITLS_CONFIG_INVALID_LENGTH;
}
uint8_t i = 0u;
uint8_t commaNum = 0u;
uint8_t startPos = 0u;
for (i = 0u; i <= inLen; ++i) {
if (i == inLen || in[i] == ',') {
if (i == startPos) {
++startPos;
++commaNum;
continue;
}
out[startPos - commaNum] = (uint8_t)(i - startPos);
startPos = i + 1;
} else {
out[i + 1 - commaNum] = in[i];
}
}
*outLen = inLen + 1 - commaNum;
return HITLS_SUCCESS;
}
int32_t ExampleAlpnCb(HITLS_Ctx *ctx, char **selectedProto, uint8_t *selectedProtoSize, char *clientAlpnList,
uint32_t clientAlpnListSize, void *userData)
{
(void)ctx;
(void)userData;
if (clientAlpnListSize >= 5 && memcmp(clientAlpnList + 1, "http", 4) == 0) {
*selectedProto = clientAlpnList + 1;
*selectedProtoSize = 4;
return HITLS_ALPN_ERR_OK;
} else if (clientAlpnListSize >= 4 && memcmp(clientAlpnList + 1, "ftp", 3) == 0) {
*selectedProto = g_alpnhttp;
*selectedProtoSize = 4;
return HITLS_ALPN_ERR_OK;
} else if (clientAlpnListSize >= 4 && memcmp(clientAlpnList + 1, "mml", 3) == 0) {
*selectedProto = g_alpnhttp;
*selectedProtoSize = 4;
return HITLS_ALPN_ERR_ALERT_FATAL;
} else if (clientAlpnListSize >= 4 && memcmp(clientAlpnList + 1, "www", 3) == 0) {
*selectedProto = g_alpnhttp;
*selectedProtoSize = 4;
return HITLS_ALPN_ERR_OK;
} else {
return HITLS_ALPN_ERR_NOACK;
}
}
int32_t AlpnCbWARN1(HITLS_Ctx *ctx, uint8_t **selectedProto, uint8_t *selectedProtoSize, uint8_t *clientAlpnList,
uint32_t clientAlpnListSize, void *userData)
{
(void)ctx;
(void)selectedProto;
(void)selectedProtoSize;
(void)clientAlpnList;
(void)clientAlpnListSize;
(void)userData;
return HITLS_ALPN_ERR_ALERT_WARNING;
}
int32_t AlpnCbALERT1(HITLS_Ctx *ctx, uint8_t **selectedProto, uint8_t *selectedProtoSize, uint8_t *clientAlpnList,
uint32_t clientAlpnListSize, void *userData)
{
(void)ctx;
(void)selectedProto;
(void)selectedProtoSize;
(void)clientAlpnList;
(void)clientAlpnListSize;
(void)userData;
return HITLS_ALPN_ERR_ALERT_FATAL;
}
void *ExampleAlpnData(void)
{
// Return the alpnData address.
return "audata";
}
void *GetTicketKeyCb(char *str)
{
const ExampleCb cbList[] = {
{"ExampleTicketKeySuccessCb", ExampleTicketKeySuccessCb},
{"ExampleTicketKeyRenewCb", ExampleTicketKeyRenewCb},
{"ExampleTicketKeyAlertCb", ExampleTicketKeyAlertCb},
{"ExampleTicketKeyFailCb", ExampleTicketKeyFailCb},
};
int len = sizeof(cbList) / sizeof(cbList[0]);
for (int i = 0; i < len; i++) {
if (strcmp(str, cbList[i].name) == 0) {
return cbList[i].cb;
}
}
return NULL;
}
static void ExampleKeyLogCb(HITLS_Ctx *ctx, const char *out)
{
(void)ctx; // Unused parameter
char *fileName = "FileKeyLog.txt";
char *fileEndStr = "\n";
FILE *fp = fopen(fileName, "a+");
if (fp == NULL) {
return;
}
fwrite(out, sizeof(char), strlen(out), fp);
fwrite((char*)fileEndStr, sizeof(char), strlen(fileEndStr), fp);
fclose(fp);
}
void *GetExtensionCb(const char *str)
{
const ExampleCb cbList[] = {
{"ExampleSNICb", ExampleServerNameCb},
{"ExampleAlpnCb", ExampleAlpnCb},
{"ExampleAlpnWarnCb", AlpnCbWARN1},
{"ExampleAlpAlertCb", AlpnCbALERT1},
{"ExampleSNICbnoack", ExampleServerNameCbNOACK},
{"ExampleSNICbAlert", ExampleServerNameCbALERT},
{"ExampleKeyLogCb", ExampleKeyLogCb},
};
int len = sizeof(cbList) / sizeof(cbList[0]);
for (int i = 0; i < len; i++) {
if (strcmp(str, cbList[i].name) == 0) {
return cbList[i].cb;
}
}
return NULL;
}
void *GetExampleData(const char *str)
{
const ExampleData cbList[] = {
{"ExampleSNIArg", ExampleServerNameArg},
{"ExampleAlpnData", ExampleAlpnData},
};
int len = sizeof(cbList) / sizeof(cbList[0]);
for (int i = 0; i < len; i++) {
if (strcmp(str, cbList[i].name) == 0) {
return cbList[i].data();
}
}
return NULL;
}
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/rpc/src/common_func.c | C | unknown | 12,103 |
/*
* 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 "hitls_build.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include "uio_base.h"
#include "bsl_sal.h"
#include "sal_net.h"
#include "hitls.h"
#include "hitls_cert_type.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "hitls_psk.h"
#include "hitls_session.h"
#include "hitls_debug.h"
#include "hitls_sni.h"
#include "hitls_alpn.h"
#include "hitls_security.h"
#include "hitls_crypt_init.h"
#include "tls.h"
#include "hlt_type.h"
#include "logger.h"
#include "tls_res.h"
#include "cert_callback.h"
#include "sctp_channel.h"
#include "tcp_channel.h"
#include "udp_channel.h"
#include "common_func.h"
#include "crypt_eal_rand.h"
#include "crypt_algid.h"
#include "channel_res.h"
#include "crypt_eal_provider.h"
#define SUCCESS 0
#define ERROR (-1)
#define FUNC_TIME_OUT_SEC 120
#define ASSERT_RETURN(condition, log) \
do { \
if (!(condition)) { \
LOG_ERROR(log); \
return ERROR; \
} \
} while (0)
typedef struct {
char *name;
uint16_t configValue;
} HitlsConfig;
typedef enum {
CIPHER,
GROUPS,
SIGNATURE,
POINTFORMAT,
} HitlsConfigType;
static const HitlsConfig g_cipherSuiteList[] = {
{"HITLS_RSA_WITH_AES_128_CBC_SHA", HITLS_RSA_WITH_AES_128_CBC_SHA},
{"HITLS_DHE_DSS_WITH_AES_128_CBC_SHA", HITLS_DHE_DSS_WITH_AES_128_CBC_SHA},
{"HITLS_DHE_RSA_WITH_AES_128_CBC_SHA", HITLS_DHE_RSA_WITH_AES_128_CBC_SHA},
{"HITLS_RSA_WITH_AES_256_CBC_SHA", HITLS_RSA_WITH_AES_256_CBC_SHA},
{"HITLS_DHE_DSS_WITH_AES_256_CBC_SHA", HITLS_DHE_DSS_WITH_AES_256_CBC_SHA},
{"HITLS_DHE_RSA_WITH_AES_256_CBC_SHA", HITLS_DHE_RSA_WITH_AES_256_CBC_SHA},
{"HITLS_RSA_WITH_AES_128_CBC_SHA256", HITLS_RSA_WITH_AES_128_CBC_SHA256},
{"HITLS_RSA_WITH_AES_256_CBC_SHA256", HITLS_RSA_WITH_AES_256_CBC_SHA256},
{"HITLS_DHE_DSS_WITH_AES_128_CBC_SHA256", HITLS_DHE_DSS_WITH_AES_128_CBC_SHA256},
{"HITLS_DHE_RSA_WITH_AES_128_CBC_SHA256", HITLS_DHE_RSA_WITH_AES_128_CBC_SHA256},
{"HITLS_DHE_DSS_WITH_AES_256_CBC_SHA256", HITLS_DHE_DSS_WITH_AES_256_CBC_SHA256},
{"HITLS_DHE_RSA_WITH_AES_256_CBC_SHA256", HITLS_DHE_RSA_WITH_AES_256_CBC_SHA256},
{"HITLS_RSA_WITH_AES_128_GCM_SHA256", HITLS_RSA_WITH_AES_128_GCM_SHA256},
{"HITLS_RSA_WITH_AES_256_GCM_SHA384", HITLS_RSA_WITH_AES_256_GCM_SHA384},
{"HITLS_DHE_RSA_WITH_AES_128_GCM_SHA256", HITLS_DHE_RSA_WITH_AES_128_GCM_SHA256},
{"HITLS_DHE_RSA_WITH_AES_256_GCM_SHA384", HITLS_DHE_RSA_WITH_AES_256_GCM_SHA384},
{"HITLS_DHE_DSS_WITH_AES_128_GCM_SHA256", HITLS_DHE_DSS_WITH_AES_128_GCM_SHA256},
{"HITLS_DHE_DSS_WITH_AES_256_GCM_SHA384", HITLS_DHE_DSS_WITH_AES_256_GCM_SHA384},
{"HITLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA", HITLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA},
{"HITLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA", HITLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA},
{"HITLS_ECDHE_RSA_WITH_AES_128_CBC_SHA", HITLS_ECDHE_RSA_WITH_AES_128_CBC_SHA},
{"HITLS_ECDHE_RSA_WITH_AES_256_CBC_SHA", HITLS_ECDHE_RSA_WITH_AES_256_CBC_SHA},
{"HITLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256", HITLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256},
{"HITLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384", HITLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384},
{"HITLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256", HITLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256},
{"HITLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384", HITLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384},
{"HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256", HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256},
{"HITLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384", HITLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384},
{"HITLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256", HITLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256},
{"HITLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384", HITLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384},
{"HITLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256", HITLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256},
{"HITLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256", HITLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256},
{"HITLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256", HITLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256},
{"HITLS_AES_128_GCM_SHA256", HITLS_AES_128_GCM_SHA256},
{"HITLS_AES_256_GCM_SHA384", HITLS_AES_256_GCM_SHA384},
{"HITLS_CHACHA20_POLY1305_SHA256", HITLS_CHACHA20_POLY1305_SHA256},
{"HITLS_AES_128_CCM_SHA256", HITLS_AES_128_CCM_SHA256},
{"HITLS_AES_128_CCM_8_SHA256", HITLS_AES_128_CCM_8_SHA256},
{"HITLS_ECDHE_ECDSA_WITH_AES_128_CCM", HITLS_ECDHE_ECDSA_WITH_AES_128_CCM},
{"HITLS_ECDHE_ECDSA_WITH_AES_256_CCM", HITLS_ECDHE_ECDSA_WITH_AES_256_CCM},
{"HITLS_DHE_RSA_WITH_AES_128_CCM", HITLS_DHE_RSA_WITH_AES_128_CCM},
{"HITLS_DHE_RSA_WITH_AES_256_CCM", HITLS_DHE_RSA_WITH_AES_256_CCM},
{"HITLS_RSA_WITH_AES_256_CCM", HITLS_RSA_WITH_AES_256_CCM},
{"HITLS_RSA_WITH_AES_256_CCM_8", HITLS_RSA_WITH_AES_256_CCM_8},
{"HITLS_RSA_WITH_AES_128_CCM", HITLS_RSA_WITH_AES_128_CCM},
{"HITLS_RSA_WITH_AES_128_CCM_8", HITLS_RSA_WITH_AES_128_CCM_8},
/* psk cipher suite */
{"HITLS_PSK_WITH_AES_128_CBC_SHA", HITLS_PSK_WITH_AES_128_CBC_SHA},
{"HITLS_PSK_WITH_AES_256_CBC_SHA", HITLS_PSK_WITH_AES_256_CBC_SHA},
{"HITLS_DHE_PSK_WITH_AES_128_CBC_SHA", HITLS_DHE_PSK_WITH_AES_128_CBC_SHA},
{"HITLS_DHE_PSK_WITH_AES_256_CBC_SHA", HITLS_DHE_PSK_WITH_AES_256_CBC_SHA},
{"HITLS_RSA_PSK_WITH_AES_128_CBC_SHA", HITLS_RSA_PSK_WITH_AES_128_CBC_SHA},
{"HITLS_RSA_PSK_WITH_AES_256_CBC_SHA", HITLS_RSA_PSK_WITH_AES_256_CBC_SHA},
{"HITLS_PSK_WITH_AES_128_GCM_SHA256", HITLS_PSK_WITH_AES_128_GCM_SHA256},
{"HITLS_PSK_WITH_AES_256_GCM_SHA384", HITLS_PSK_WITH_AES_256_GCM_SHA384},
{"HITLS_DHE_PSK_WITH_AES_128_GCM_SHA256", HITLS_DHE_PSK_WITH_AES_128_GCM_SHA256},
{"HITLS_DHE_PSK_WITH_AES_256_GCM_SHA384", HITLS_DHE_PSK_WITH_AES_256_GCM_SHA384},
{"HITLS_RSA_PSK_WITH_AES_128_GCM_SHA256", HITLS_RSA_PSK_WITH_AES_128_GCM_SHA256},
{"HITLS_RSA_PSK_WITH_AES_256_GCM_SHA384", HITLS_RSA_PSK_WITH_AES_256_GCM_SHA384},
{"HITLS_PSK_WITH_AES_128_CBC_SHA256", HITLS_PSK_WITH_AES_128_CBC_SHA256},
{"HITLS_PSK_WITH_AES_256_CBC_SHA384", HITLS_PSK_WITH_AES_256_CBC_SHA384},
{"HITLS_DHE_PSK_WITH_AES_128_CBC_SHA256", HITLS_DHE_PSK_WITH_AES_128_CBC_SHA256},
{"HITLS_DHE_PSK_WITH_AES_256_CBC_SHA384", HITLS_DHE_PSK_WITH_AES_256_CBC_SHA384},
{"HITLS_RSA_PSK_WITH_AES_128_CBC_SHA256", HITLS_RSA_PSK_WITH_AES_128_CBC_SHA256},
{"HITLS_RSA_PSK_WITH_AES_256_CBC_SHA384", HITLS_RSA_PSK_WITH_AES_256_CBC_SHA384},
{"HITLS_ECDHE_PSK_WITH_AES_128_CBC_SHA", HITLS_ECDHE_PSK_WITH_AES_128_CBC_SHA},
{"HITLS_ECDHE_PSK_WITH_AES_256_CBC_SHA", HITLS_ECDHE_PSK_WITH_AES_256_CBC_SHA},
{"HITLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256", HITLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256},
{"HITLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384", HITLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384},
{"HITLS_PSK_WITH_CHACHA20_POLY1305_SHA256", HITLS_PSK_WITH_CHACHA20_POLY1305_SHA256},
{"HITLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256", HITLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256},
{"HITLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256", HITLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256},
{"HITLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256", HITLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256},
{"HITLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256", HITLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256},
{"HITLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384", HITLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384},
{"HITLS_DHE_PSK_WITH_AES_128_CCM", HITLS_DHE_PSK_WITH_AES_128_CCM},
{"HITLS_DHE_PSK_WITH_AES_256_CCM", HITLS_DHE_PSK_WITH_AES_256_CCM},
{"HITLS_PSK_WITH_AES_256_CCM", HITLS_PSK_WITH_AES_256_CCM},
{"HITLS_ECDHE_PSK_WITH_AES_128_CCM_SHA256", HITLS_ECDHE_PSK_WITH_AES_128_CCM_SHA256},
/* Anonymous ciphersuite */
{"HITLS_DH_ANON_WITH_AES_256_CBC_SHA", HITLS_DH_ANON_WITH_AES_256_CBC_SHA},
{"HITLS_DH_ANON_WITH_AES_128_CBC_SHA", HITLS_DH_ANON_WITH_AES_128_CBC_SHA},
{"HITLS_DH_ANON_WITH_AES_128_CBC_SHA256", HITLS_DH_ANON_WITH_AES_128_CBC_SHA256},
{"HITLS_DH_ANON_WITH_AES_256_CBC_SHA256", HITLS_DH_ANON_WITH_AES_256_CBC_SHA256},
{"HITLS_DH_ANON_WITH_AES_128_GCM_SHA256", HITLS_DH_ANON_WITH_AES_128_GCM_SHA256},
{"HITLS_DH_ANON_WITH_AES_256_GCM_SHA384", HITLS_DH_ANON_WITH_AES_256_GCM_SHA384},
{"HITLS_ECDH_ANON_WITH_AES_128_CBC_SHA", HITLS_ECDH_ANON_WITH_AES_128_CBC_SHA},
{"HITLS_ECDH_ANON_WITH_AES_256_CBC_SHA", HITLS_ECDH_ANON_WITH_AES_256_CBC_SHA},
{"HITLS_ECDHE_SM4_CBC_SM3", HITLS_ECDHE_SM4_CBC_SM3},
{"HITLS_ECC_SM4_CBC_SM3", HITLS_ECC_SM4_CBC_SM3},
{"HITLS_ECDHE_SM4_GCM_SM3", HITLS_ECDHE_SM4_GCM_SM3},
{"HITLS_ECC_SM4_GCM_SM3", HITLS_ECC_SM4_GCM_SM3},
/* error ciphersuite */
{"HITLS_INVALID_CIPHER_TC01", 0xFFFF},
{"HITLS_INVALID_CIPHER_TC02", 0xFFFE},
};
static const HitlsConfig g_groupList[] = {
{"HITLS_EC_GROUP_BRAINPOOLP256R1", HITLS_EC_GROUP_BRAINPOOLP256R1},
{"HITLS_EC_GROUP_BRAINPOOLP384R1", HITLS_EC_GROUP_BRAINPOOLP384R1},
{"HITLS_EC_GROUP_BRAINPOOLP512R1", HITLS_EC_GROUP_BRAINPOOLP512R1},
{"HITLS_EC_GROUP_SECP256R1", HITLS_EC_GROUP_SECP256R1},
{"HITLS_EC_GROUP_SECP384R1", HITLS_EC_GROUP_SECP384R1},
{"HITLS_EC_GROUP_SECP521R1", HITLS_EC_GROUP_SECP521R1},
{"HITLS_EC_GROUP_CURVE25519", HITLS_EC_GROUP_CURVE25519},
{"HITLS_EC_GROUP_SM2", HITLS_EC_GROUP_SM2},
{"HITLS_INVALID_GROUP_TC01", 0xFF},
{"HITLS_INVALID_GROUP_TC02", 0xFE},
{"HITLS_FF_DHE_2048", HITLS_FF_DHE_2048},
{"HITLS_FF_DHE_3072", HITLS_FF_DHE_3072},
{"HITLS_FF_DHE_4096", HITLS_FF_DHE_4096},
{"HITLS_FF_DHE_6144", HITLS_FF_DHE_6144},
{"HITLS_FF_DHE_8192", HITLS_FF_DHE_8192},
{"SecP256r1MLKEM768", 4587}, // for new kem group
{"X25519MLKEM768", 4588}, // for new kem group
{"SecP384r1MLKEM1024", 4589}, // for new kem group
{"test_new_group", 477}, // for new group
{"test_new_group_kem", 478}, // NEW_KEM_ALGID
{"test_new_group_with_new_key_type", 479}, // NEW_PKEY_ALGID
};
static const HitlsConfig g_signatureList[] = {
{"CERT_SIG_SCHEME_RSA_PKCS1_SHA1", CERT_SIG_SCHEME_RSA_PKCS1_SHA1},
{"CERT_SIG_SCHEME_ECDSA_SHA1", CERT_SIG_SCHEME_ECDSA_SHA1},
{"CERT_SIG_SCHEME_ECDSA_SHA224", CERT_SIG_SCHEME_ECDSA_SHA224},
{"CERT_SIG_SCHEME_RSA_PKCS1_SHA224", CERT_SIG_SCHEME_RSA_PKCS1_SHA224},
{"CERT_SIG_SCHEME_RSA_PKCS1_SHA256", CERT_SIG_SCHEME_RSA_PKCS1_SHA256},
{"CERT_SIG_SCHEME_RSA_PKCS1_SHA384", CERT_SIG_SCHEME_RSA_PKCS1_SHA384},
{"CERT_SIG_SCHEME_RSA_PKCS1_SHA512", CERT_SIG_SCHEME_RSA_PKCS1_SHA512},
{"CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256", CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256},
{"CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384", CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384},
{"CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512", CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512},
{"CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA256", CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA256},
{"CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA384", CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA384},
{"CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA512", CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA512},
{"CERT_SIG_SCHEME_ED25519", CERT_SIG_SCHEME_ED25519},
{"CERT_SIG_SCHEME_ED448", CERT_SIG_SCHEME_ED448},
{"CERT_SIG_SCHEME_DSA_SHA1", CERT_SIG_SCHEME_DSA_SHA1},
{"CERT_SIG_SCHEME_DSA_SHA224", CERT_SIG_SCHEME_DSA_SHA224},
{"CERT_SIG_SCHEME_DSA_SHA256", CERT_SIG_SCHEME_DSA_SHA256},
{"CERT_SIG_SCHEME_DSA_SHA384", CERT_SIG_SCHEME_DSA_SHA384},
{"CERT_SIG_SCHEME_DSA_SHA512", CERT_SIG_SCHEME_DSA_SHA512},
{"CERT_SIG_SCHEME_SM2_SM3", CERT_SIG_SCHEME_SM2_SM3},
{"CERT_SIG_SCHEME_RSA_PSS_PSS_SHA256", CERT_SIG_SCHEME_RSA_PSS_PSS_SHA256},
{"CERT_SIG_SCHEME_RSA_PSS_PSS_SHA384", CERT_SIG_SCHEME_RSA_PSS_PSS_SHA384},
{"CERT_SIG_SCHEME_RSA_PSS_PSS_SHA512", CERT_SIG_SCHEME_RSA_PSS_PSS_SHA512},
{"HITLS_INVALID_SIG_TC01", 0xFFFF},
{"HITLS_INVALID_SIG_TC02", 0xFFFE},
{"test_new_sign_alg_name", 23333},
{"test_new_sign_alg_name_with_new_key_type", 24444},
};
static const HitlsConfig g_eccFormatList[] = {
{"HITLS_POINT_FORMAT_UNCOMPRESSED", HITLS_POINT_FORMAT_UNCOMPRESSED},
{"HITLS_INVALID_FORMAT_TC01", 0xFF},
{"HITLS_INVALID_FORMAT_TC02", 0xFE},
};
#ifdef HITLS_TLS_MAINTAIN_KEYLOG
static void KetLogPrint(HITLS_Ctx *ctx, const char *out)
{
(void)ctx;
char *fileName = "FileKeyLog.txt";
char *fileEndStr = "\n";
char *p = getenv("HITLSKEYLOGFILE");
if (p == NULL) {
return;
}
FILE *fp = fopen(fileName, "a+");
if (fp == NULL) {
return;
}
fwrite(out, sizeof(char), strlen(out), fp);
fwrite((char *)fileEndStr, sizeof(char), strlen(fileEndStr), fp);
fclose(fp);
}
#endif
int HitlsInit(void)
{
int ret;
ret = RegMemCallback(MEM_CALLBACK_DEFAULT);
ret |= RegCertCallback(CERT_CALLBACK_DEFAULT);
#ifdef HITLS_TLS_FEATURE_PROVIDER
CRYPT_EAL_ProviderRandInitCtx(NULL, CRYPT_RAND_SHA256, "provider=default", NULL, 0, NULL);
#else
CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0);
HITLS_CryptMethodInit();
#endif
return ret;
}
#ifdef HITLS_TLS_FEATURE_PROVIDER
static HITLS_Lib_Ctx *InitProviderLibCtx(char *providerPath, char (*providerNames)[MAX_PROVIDER_NAME_LEN],
int *providerLibFmts, int providerCnt)
{
int ret;
HITLS_Lib_Ctx *libCtx = CRYPT_EAL_LibCtxNew();
if (libCtx == NULL) {
LOG_ERROR("CRYPT_EAL_LibCtxNew Error");
return NULL;
}
if (providerPath != NULL && strlen(providerPath) > 0) {
ret = CRYPT_EAL_ProviderSetLoadPath(libCtx, providerPath);
if (ret != EOK) {
CRYPT_EAL_LibCtxFree(libCtx);
LOG_ERROR("CRYPT_EAL_ProviderSetLoadPath Error");
return NULL;
}
}
for (int i = 0; i < providerCnt; i++) {
ret = CRYPT_EAL_ProviderLoad(libCtx, (BSL_SAL_LibFmtCmd)providerLibFmts[i], providerNames[i], NULL, NULL);
if (ret != EOK) {
CRYPT_EAL_LibCtxFree(libCtx);
LOG_ERROR("CRYPT_EAL_ProviderLoad Error");
return NULL;
}
char attrName[512] = {0};
memcpy_s(attrName, sizeof(attrName), "provider?", strlen("provider?"));
memcpy_s(attrName + strlen("provider?"), sizeof(attrName) - strlen("provider?"), providerNames[i],
strlen(providerNames[i]));
CRYPT_EAL_ProviderRandInitCtx(libCtx, CRYPT_RAND_SHA256, attrName, NULL, 0, NULL);
}
return libCtx;
}
HITLS_Config *HitlsProviderNewCtx(char *providerPath, char (*providerNames)[MAX_PROVIDER_NAME_LEN], int *providerLibFmts,
int providerCnt, char *attrName, TLS_VERSION tlsVersion)
{
char *tmpAttrName = NULL;
if (attrName != NULL && strlen(attrName) > 0) {
tmpAttrName = attrName;
}
HITLS_Config *hitlsConfig = NULL;
HITLS_Lib_Ctx *libCtx = NULL;
if (providerCnt > 0) {
libCtx = InitProviderLibCtx(providerPath, providerNames, providerLibFmts, providerCnt);
if (libCtx == NULL) {
LOG_ERROR("InitProviderLibCtx Error");
return NULL;
}
}
switch (tlsVersion) {
case DTLS1_2:
LOG_DEBUG("HiTLS New DTLS1_2 Ctx");
hitlsConfig = HITLS_CFG_ProviderNewDTLS12Config(libCtx, tmpAttrName);
break;
case TLS1_2:
LOG_DEBUG("HiTLS New TLS1_2 Ctx");
hitlsConfig = HITLS_CFG_ProviderNewTLS12Config(libCtx, tmpAttrName);
break;
case TLS1_3:
LOG_DEBUG("HiTLS New TLS1_3 Ctx");
hitlsConfig = HITLS_CFG_ProviderNewTLS13Config(libCtx, tmpAttrName);
break;
case TLS_ALL:
LOG_DEBUG("HiTLS New TLS_ALL Ctx");
hitlsConfig = HITLS_CFG_ProviderNewTLSConfig(libCtx, tmpAttrName);
break;
#ifdef HITLS_TLS_PROTO_TLCP11
case TLCP1_1:
LOG_DEBUG("HiTLS New TLCP1_1 Ctx");
hitlsConfig = HITLS_CFG_ProviderNewTLCPConfig(libCtx, tmpAttrName);
break;
#endif
#ifdef HITLS_TLS_PROTO_DTLCP11
case DTLCP1_1:
LOG_DEBUG("HiTLS New DTLCP1_1 Ctx");
hitlsConfig = HITLS_CFG_ProviderNewDTLCPConfig(libCtx, tmpAttrName);
break;
#endif
default:
/* Unknown protocol type */
break;
}
if (hitlsConfig == NULL) {
CRYPT_EAL_LibCtxFree(libCtx);
LOG_ERROR("HITLS Not Support This TlsVersion's ID %d", tlsVersion);
}
#ifdef HITLS_TLS_FEATURE_SECURITY
// Setting the security level
HITLS_CFG_SetSecurityLevel(hitlsConfig, HITLS_SECURITY_LEVEL_ZERO);
#endif /* HITLS_TLS_FEATURE_SECURITY */
return hitlsConfig;
}
#endif
HITLS_Config *HitlsNewCtx(TLS_VERSION tlsVersion)
{
HITLS_Config *hitlsConfig = NULL;
switch (tlsVersion) {
#ifdef HITLS_TLS_PROTO_DTLS12
case DTLS1_2:
LOG_DEBUG("HiTLS New DTLS1_2 Ctx");
hitlsConfig = HITLS_CFG_NewDTLS12Config();
break;
#endif
#ifdef HITLS_TLS_PROTO_TLS12
case TLS1_2:
LOG_DEBUG("HiTLS New TLS1_2 Ctx");
hitlsConfig = HITLS_CFG_NewTLS12Config();
break;
#endif
#ifdef HITLS_TLS_PROTO_TLS13
case TLS1_3:
LOG_DEBUG("HiTLS New TLS1_3 Ctx");
hitlsConfig = HITLS_CFG_NewTLS13Config();
break;
#endif
#ifdef HITLS_TLS_PROTO_ALL
case TLS_ALL:
LOG_DEBUG("HiTLS New TLS_ALL Ctx");
hitlsConfig = HITLS_CFG_NewTLSConfig();
break;
#endif
#ifdef HITLS_TLS_PROTO_TLCP11
case TLCP1_1:
LOG_DEBUG("HiTLS New TLCP1_1 Ctx");
hitlsConfig = HITLS_CFG_NewTLCPConfig();
break;
#endif
#ifdef HITLS_TLS_PROTO_DTLCP11
case DTLCP1_1:
LOG_DEBUG("HiTLS New DTLCP1_1 Ctx");
hitlsConfig = HITLS_CFG_NewDTLCPConfig();
break;
#endif
default:
/* Unknown protocol type */
break;
}
if (hitlsConfig == NULL) {
LOG_ERROR("HITLS Not Support This TlsVersion's ID %d", tlsVersion);
}
#ifdef HITLS_TLS_FEATURE_SECURITY
// Setting the security level
HITLS_CFG_SetSecurityLevel(hitlsConfig, HITLS_SECURITY_LEVEL_ZERO);
#endif /* HITLS_TLS_FEATURE_SECURITY */
return hitlsConfig;
}
void HitlsFreeCtx(void *ctx)
{
if (ctx == NULL) {
return;
}
HITLS_CFG_FreeConfig(ctx);
}
static int32_t GetConfigVauleFromStr(const HitlsConfig *hitlsConfigList, uint32_t configSize, const char *cipherName)
{
for (uint32_t i = 0; i < configSize; i++) {
if (strcmp(cipherName, hitlsConfigList[i].name) != 0) {
continue;
}
return hitlsConfigList[i].configValue;
}
return ERROR; // The cipher suite does not exist.
}
static int8_t HitlsSetConfig(const HitlsConfig *hitlsConfigList, int configListSize, void *ctx,
char *name, HitlsConfigType type)
{
int ret = 0;
char configArray[MAX_CIPHERSUITES_LEN] = {0}; // A maximum of 512 characters are supported.
char *token, *rest;
int32_t configValue;
uint16_t configValueArray[20] = {0}; // Currently, a maximum of 20 cipher suites are supported.
uint32_t configSize = 0;
ret = memcpy_s(configArray, sizeof(configArray), name, strlen(name));
ASSERT_RETURN(ret == EOK, "Memcpy Error");
configSize = 0;
token = strtok_s(configArray, ":", &rest);
do {
// Currently, a maximum of 20 cipher suites are supported.
ASSERT_RETURN(configSize < 20, "Max Support Set 20 Config");
configValue = GetConfigVauleFromStr(hitlsConfigList, configListSize, token);
ASSERT_RETURN(configValue != ERROR, "GetConfigVauleFromStr Error");
configValueArray[configSize] = (uint16_t)configValue;
token = strtok_s(NULL, ":", &rest);
configSize++;
} while (token != NULL);
switch (type) {
case CIPHER:
ret = HITLS_CFG_SetCipherSuites(ctx, configValueArray, configSize);
break;
case GROUPS:
ret = HITLS_CFG_SetGroups(ctx, configValueArray, configSize);
break;
case SIGNATURE:
ret = HITLS_CFG_SetSignature(ctx, configValueArray, configSize);
break;
case POINTFORMAT:
{
uint8_t pointformatArray[20] = {0};
for (uint32_t i = 0; i < configSize; i++) {
pointformatArray[i] = configValueArray[i];
}
ret = HITLS_CFG_SetEcPointFormats(ctx, pointformatArray, configSize);
break;
}
default:
ret = ERROR;
}
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetXXX Error");
return SUCCESS;
}
int HitlsSetCtx(HITLS_Config *outCfg, HLT_Ctx_Config *inCtxCfg)
{
int ret = 0;
#ifdef HITLS_TLS_FEATURE_SESSION
if (inCtxCfg->setSessionCache >= 0) {
LOG_DEBUG("HiTLS Set SessionCache is %d", inCtxCfg->setSessionCache);
HITLS_CFG_SetSessionCacheMode(outCfg, inCtxCfg->setSessionCache);
}
#endif
#ifdef HITLS_TLS_PROTO_ALL
// Set the protocol version.
if ((inCtxCfg->minVersion != 0) && (inCtxCfg->maxVersion != 0)) {
LOG_DEBUG("HiTLS Set minVersion is %u maxVersion is %u", inCtxCfg->minVersion, inCtxCfg->maxVersion);
ret = HITLS_CFG_SetVersion(outCfg, inCtxCfg->minVersion, inCtxCfg->maxVersion);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetVersion Error ERROR");
}
#endif
if (inCtxCfg->SupportType == SERVER_CFG_SET_TRUE) {
HITLS_CFG_SetCipherServerPreference(outCfg, true);
}
if (inCtxCfg->SupportType == SERVER_CFG_SET_FALSE) {
HITLS_CFG_SetCipherServerPreference(outCfg, false);
}
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
// Setting Renegotiation
LOG_DEBUG("HiTLS Set Support Renegotiation is %d", inCtxCfg->isSupportRenegotiation);
ret = HITLS_CFG_SetRenegotiationSupport(outCfg, inCtxCfg->isSupportRenegotiation);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetRenegotiationSupport ERROR");
// Whether allow a renegotiation initiated by the client
LOG_DEBUG("HiTLS Set allow Client Renegotiate is %d", inCtxCfg->allowClientRenegotiate);
ret = HITLS_CFG_SetClientRenegotiateSupport(outCfg, inCtxCfg->allowClientRenegotiate);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetClientRenegotiateSupport ERROR");
#endif
#ifdef HITLS_TLS_FEATURE_CERT_MODE
// Whether to enable dual-ended verification
LOG_DEBUG("HiTLS Set Support Client Verify is %d", inCtxCfg->isSupportClientVerify);
ret = HITLS_CFG_SetClientVerifySupport(outCfg, inCtxCfg->isSupportClientVerify);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetClientVerifySupport ERROR");
LOG_DEBUG("HiTLS Set readAhead is %d", inCtxCfg->readAhead);
ret = HITLS_CFG_SetReadAhead(outCfg, inCtxCfg->readAhead);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetReadAhead ERROR");
// Indicates whether to allow empty certificate list on the client.
LOG_DEBUG("HiTLS Set Support Not Client Cert is %d", inCtxCfg->isSupportNoClientCert);
ret = HITLS_CFG_SetNoClientCertSupport(outCfg, inCtxCfg->isSupportNoClientCert);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetNoClientCertSupport ERROR");
#endif
#ifdef HITLS_TLS_FEATURE_PHA
// Whether to enable pha
LOG_DEBUG("HiTLS Set Support pha is %d", inCtxCfg->isSupportPostHandshakeAuth);
ret = HITLS_CFG_SetPostHandshakeAuthSupport(outCfg, inCtxCfg->isSupportPostHandshakeAuth);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetPostHandshakeAuth ERROR");
#endif
// Indicates whether extended master keys are supported.
LOG_DEBUG("HiTLS Set Support Extend Master Secret is %d", inCtxCfg->isSupportExtendMasterSecret);
ret = HITLS_CFG_SetExtenedMasterSecretSupport(outCfg, inCtxCfg->isSupportExtendMasterSecret);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetExtenedMasterSecretSupport ERROR");
#ifdef HITLS_TLS_CONFIG_KEY_USAGE
// Support CloseCheckKeyUsage
LOG_DEBUG("HiTLS Set CloseCheckKeyUsage is false");
ret = HITLS_CFG_SetCheckKeyUsage(outCfg, inCtxCfg->needCheckKeyUsage);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetCheckKeyUsage ERROR");
#endif
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
// Indicates whether to support sessionTicket.
LOG_DEBUG("HiTLS Set Support SessionTicket is %d", inCtxCfg->isSupportSessionTicket);
ret = HITLS_CFG_SetSessionTicketSupport(outCfg, inCtxCfg->isSupportSessionTicket);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetSessionTicketSupport ERROR");
#endif
#ifdef HITLS_TLS_SUITE_CIPHER_CBC
// Whether encrypt-then-mac is supported
LOG_DEBUG("HiTLS Set Support EncryptThenMac is %d", inCtxCfg->isEncryptThenMac);
ret = HITLS_CFG_SetEncryptThenMac(outCfg, (uint32_t)inCtxCfg->isEncryptThenMac);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetEncryptThenMac ERROR");
#endif
// ECC Point Format Configuration for Asymmetric Algorithms
if (strncmp("NULL", inCtxCfg->pointFormats, strlen(inCtxCfg->pointFormats)) != 0) {
LOG_DEBUG("HiTLS Set PoinFormats is %s", inCtxCfg->pointFormats);
int configListSize = sizeof(g_eccFormatList) / sizeof(g_eccFormatList[0]);
ret = HitlsSetConfig(g_eccFormatList, configListSize, outCfg, inCtxCfg->pointFormats, POINTFORMAT);
ASSERT_RETURN(ret == SUCCESS, "ECC Format ERROR");
}
// Loading cipher suites
if (strncmp("NULL", inCtxCfg->cipherSuites, strlen(inCtxCfg->cipherSuites)) != 0) {
LOG_DEBUG("HiTLS Set CipherSuites is %s", inCtxCfg->cipherSuites);
int configListSize = sizeof(g_cipherSuiteList) / sizeof(g_cipherSuiteList[0]);
ret = HitlsSetConfig(g_cipherSuiteList, configListSize, outCfg, inCtxCfg->cipherSuites, CIPHER);
ASSERT_RETURN(ret == SUCCESS, "Hitls Set Cipher ERROR");
}
// set groups
if (strncmp("NULL", inCtxCfg->groups, strlen(inCtxCfg->groups)) != 0) {
LOG_DEBUG("HiTLS Set Groups is %s", inCtxCfg->groups);
int configListSize = sizeof(g_groupList) / sizeof(g_groupList[0]);
ret = HitlsSetConfig(g_groupList, configListSize, outCfg, inCtxCfg->groups, GROUPS);
ASSERT_RETURN(ret == SUCCESS, "Hitls Set Group ERROR");
}
// signature algorithm
if (strncmp("NULL", inCtxCfg->signAlgorithms, strlen(inCtxCfg->signAlgorithms)) != 0) {
LOG_DEBUG("HiTLS Set SignAlgorithms is %s", inCtxCfg->signAlgorithms);
int configListSize = sizeof(g_signatureList) / sizeof(g_signatureList[0]);
ret = HitlsSetConfig(g_signatureList, configListSize, outCfg, inCtxCfg->signAlgorithms, SIGNATURE);
ASSERT_RETURN(ret == SUCCESS, "Hitls Set Signature ERROR");
}
#ifdef HITLS_TLS_FEATURE_SNI
// sni
if (strncmp("NULL", inCtxCfg->serverName, strlen(inCtxCfg->serverName)) != 0) {
LOG_DEBUG("HiTLS Set ServerName is %s", inCtxCfg->serverName);
ret = HITLS_CFG_SetServerName(outCfg, (uint8_t *)inCtxCfg->serverName, strlen(inCtxCfg->serverName));
ASSERT_RETURN(ret == SUCCESS, "Hitls Set ServerName ERROR");
}
// Register the server_name function callback.
if (strncmp("NULL", inCtxCfg->sniDealCb, strlen(inCtxCfg->sniDealCb)) != 0) {
LOG_DEBUG("HiTLS Set server_name callback is %s", inCtxCfg->sniDealCb);
ret = HITLS_CFG_SetServerNameCb(outCfg, GetExtensionCb(inCtxCfg->sniDealCb));
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetServerNameCb Fail");
}
// Register values related to server_name.
if (strncmp("NULL", inCtxCfg->sniArg, strlen(inCtxCfg->sniArg)) != 0) {
LOG_DEBUG("HiTLS Set sniArg");
ret = HITLS_CFG_SetServerNameArg(outCfg, GetExampleData(inCtxCfg->sniArg));
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetServerNameArg Fail");
}
#endif
#ifdef HITLS_TLS_FEATURE_ALPN
// alpn
if (strncmp("NULL", inCtxCfg->alpnList, strlen(inCtxCfg->alpnList)) != 0) {
LOG_DEBUG("HiTLS Set alpnList is %s", inCtxCfg->alpnList);
ret = HITLS_CFG_SetAlpnProtos(outCfg, (const uint8_t *)inCtxCfg->alpnList, strlen(inCtxCfg->alpnList));
ASSERT_RETURN(ret == SUCCESS, "Hitls Set alpnList ERROR");
}
// Sets the ALPN selection callback on the server.
if (strncmp("NULL", inCtxCfg->alpnSelectCb, strlen(inCtxCfg->alpnSelectCb)) != 0) {
LOG_DEBUG("HiTLS Set ALPN callback is %s", inCtxCfg->alpnSelectCb);
ret = HITLS_CFG_SetAlpnProtosSelectCb(
outCfg, GetExtensionCb(inCtxCfg->alpnSelectCb), GetExampleData(inCtxCfg->alpnUserData));
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetAlpnProtosSelectCb Fail");
}
#endif
// Loading Certificates
ret = HiTLS_X509_LoadCertAndKey(outCfg, inCtxCfg->caCert, inCtxCfg->chainCert,
inCtxCfg->eeCert, inCtxCfg->signCert, inCtxCfg->privKey, inCtxCfg->signPrivKey);
ASSERT_RETURN(ret == SUCCESS, "Load cert Fail");
#ifdef HITLS_TLS_FEATURE_PSK
if (strncmp("NULL", inCtxCfg->psk, strlen(inCtxCfg->psk)) != 0) {
ret = ExampleSetPsk(inCtxCfg->psk);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetPskClientCallback Fail");
ret = HITLS_CFG_SetPskClientCallback(outCfg, ExampleClientCb);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetPskClientCallback Fail");
ret = HITLS_CFG_SetPskServerCallback(outCfg, ExampleServerCb);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetPskServerCallback Fail");
}
#endif
#if defined(HITLS_TLS_FEATURE_SESSION_TICKET)
if (strncmp("NULL", inCtxCfg->ticketKeyCb, strlen(inCtxCfg->ticketKeyCb)) != 0) {
LOG_DEBUG("HiTLS Set Ticker key callback is %s", inCtxCfg->ticketKeyCb);
ret = HITLS_CFG_SetTicketKeyCallback(outCfg, GetTicketKeyCb(inCtxCfg->ticketKeyCb));
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetTicketKeyCallback Fail");
}
#endif
#ifdef HITLS_TLS_FEATURE_INDICATOR
// Load link setup callback
if (inCtxCfg->infoCb != NULL) {
LOG_DEBUG("HiTLS Set info callback");
ret = HITLS_CFG_SetInfoCb(outCfg, inCtxCfg->infoCb);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetInfoCb Fail");
}
if (inCtxCfg->msgCb != NULL) {
LOG_DEBUG("HiTLS Set msg callback");
ret = HITLS_CFG_SetMsgCb(outCfg, inCtxCfg->msgCb);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetMsgCb Fail");
}
if (inCtxCfg->msgArg != NULL) {
LOG_DEBUG("HiTLS Set msgArg");
ret = HITLS_CFG_SetMsgCbArg(outCfg, inCtxCfg->msgArg);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetMsgCbArg Fail");
}
#ifdef HITLS_TLS_FEATURE_CERT_CB
if (inCtxCfg->certCb != NULL && inCtxCfg->certArg != NULL) {
LOG_DEBUG("HiTLS Set cert callback");
ret = HITLS_CFG_SetCertCb(outCfg, inCtxCfg->certCb, inCtxCfg->certArg);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetCertCb Fail");
}
#endif
#ifdef HITLS_TLS_FEATURE_CLIENT_HELLO_CB
if (inCtxCfg->clientHelloCb != NULL && inCtxCfg->clientHelloArg != NULL) {
LOG_DEBUG("HiTLS Set clientHello callback");
ret = HITLS_CFG_SetClientHelloCb(outCfg, inCtxCfg->clientHelloCb, inCtxCfg->clientHelloArg);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetClientHelloCb Fail");
}
#endif
#endif
#ifdef HITLS_TLS_FEATURE_FLIGHT
// Sets whether to enable the function of sending handshake messages by flight.
LOG_DEBUG("HiTLS Set Support isFlightTransmitEnable is %d", inCtxCfg->isFlightTransmitEnable);
ret = HITLS_CFG_SetFlightTransmitSwitch(outCfg, inCtxCfg->isFlightTransmitEnable);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetFlightTransmitSwitch ERROR");
#endif
#ifdef HITLS_TLS_FEATURE_SECURITY
// Setting the security level
LOG_DEBUG("HiTLS Set SecurityLevel is %d", inCtxCfg->securitylevel);
ret = HITLS_CFG_SetSecurityLevel(outCfg, inCtxCfg->securitylevel);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetSecurityLevel ERROR");
#endif
#ifdef HITLS_TLS_CONFIG_MANUAL_DH
// Indicates whether the DH key length can be followed by the certificate.
LOG_DEBUG("HiTLS Set Support DHAuto is %d", inCtxCfg->isSupportDhAuto);
ret = HITLS_CFG_SetDhAutoSupport(outCfg, inCtxCfg->isSupportDhAuto);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetDhAutoSupport ERROR");
#endif
#ifdef HITLS_TLS_PROTO_TLS13
// TLS1.3 key exchange mode
if (outCfg->maxVersion == HITLS_VERSION_TLS13) {
LOG_DEBUG("HiTLS Set keyExchMode is %u", inCtxCfg->keyExchMode);
ret = HITLS_CFG_SetKeyExchMode(outCfg, inCtxCfg->keyExchMode);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetKeyExchMode ERROR");
}
#endif
#ifdef HITLS_TLS_FEATURE_CERT_MODE
// Set whether to enable isSupportVerifyNone;
LOG_DEBUG("HiTLS Set Support pha is %d", inCtxCfg->isSupportVerifyNone);
ret = HITLS_CFG_SetVerifyNoneSupport(outCfg, inCtxCfg->isSupportVerifyNone);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetVerifyNoneSupport ERROR");
#endif
LOG_DEBUG("HiTLS Set Empty Record Number is %u", inCtxCfg->emptyRecordsNum);
ret = HITLS_CFG_SetEmptyRecordsNum(outCfg, inCtxCfg->emptyRecordsNum);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetEmptyRecordsNum ERROR");
#ifdef HITLS_TLS_FEATURE_MODE
// HiTLS Set ModeSupport
LOG_DEBUG("HiTLS Set ModeSupport is %u", inCtxCfg->modeSupport);
ret = HITLS_CFG_SetModeSupport(outCfg, inCtxCfg->modeSupport);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetModeSupport ERROR");
#endif
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
LOG_DEBUG("HiTLS Set allow Legacy Renegotiate is %d", inCtxCfg->allowLegacyRenegotiate);
ret = HITLS_CFG_SetLegacyRenegotiateSupport(outCfg, inCtxCfg->allowLegacyRenegotiate);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetLegacyRenegotiateSupport ERROR");
#endif /* defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12) */
#ifdef HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES
if (inCtxCfg->caList != NULL) {
LOG_DEBUG("HiTLS Set caList");
ret = HITLS_CFG_SetCAList(outCfg, inCtxCfg->caList);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetCAList Fail");
}
#endif /* HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES */
#ifdef HITLS_TLS_PROTO_TLS13
// Whether to support middlebox compatibility.
LOG_DEBUG("HiTLS Set Support middlebox compatibility is %d", inCtxCfg->isMiddleBoxCompat);
ret = HITLS_CFG_SetMiddleBoxCompat(outCfg, (uint32_t)inCtxCfg->isMiddleBoxCompat);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetMiddleBoxCompat ERROR");
#endif
#ifdef HITLS_TLS_MAINTAIN_KEYLOG
// Set the keylogcb callback function on the server.
if (strncmp("NULL", inCtxCfg->keyLogCb, strlen(inCtxCfg->keyLogCb)) != 0) {
LOG_DEBUG("HiTLS Set key log callback is %s", inCtxCfg->keyLogCb);
ret = HITLS_CFG_SetKeyLogCb(outCfg, GetExtensionCb(inCtxCfg->keyLogCb));
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetKeyLogCb Fail");
}
// support exporting keys through environment variables
if (strncmp("NULL", inCtxCfg->keyLogCb, strlen(inCtxCfg->keyLogCb)) == 0) {
ret = HITLS_CFG_SetKeyLogCb(outCfg, KetLogPrint);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetKeyLogCb Fail");
}
#endif
return SUCCESS;
}
void *HitlsNewSsl(void *ctx)
{
return HITLS_New(ctx);
}
void HitlsFreeSsl(void *ssl)
{
HITLS_Ctx *ctx = (HITLS_Ctx *)ssl;
#ifdef HITLS_TLS_FEATURE_PROVIDER
HITLS_Lib_Ctx *libCtx = LIBCTX_FROM_CTX(ctx);
HITLS_Free(ctx);
CRYPT_EAL_LibCtxFree(libCtx);
#else
HITLS_Free(ctx);
#endif
}
const BSL_UIO_Method *GetDefaultMethod(HILT_TransportType type)
{
switch (type) {
#ifdef HITLS_BSL_UIO_TCP
case TCP:
return TcpGetDefaultMethod();
#endif
#ifdef HITLS_BSL_UIO_UDP
case UDP:
return UdpGetDefaultMethod();
#endif
default:
break;
}
return NULL;
}
int HitlsSetSsl(void *ssl, HLT_Ssl_Config *sslConfig)
{
int ret;
if (sslConfig->SupportType == SERVER_CTX_SET_TRUE) {
HITLS_SetCipherServerPreference((HITLS_Ctx *)ssl, true);
}
if (sslConfig->SupportType == SERVER_CTX_SET_FALSE) {
HITLS_SetCipherServerPreference((HITLS_Ctx *)ssl, false);
}
HILT_TransportType type = (sslConfig->connType == NONE_TYPE) ? SCTP : sslConfig->connType;
BSL_UIO *uio = BSL_UIO_New(GetDefaultMethod(type));
ASSERT_RETURN(uio != NULL, "HITLS_SetUio Fail");
ret = BSL_UIO_Ctrl(uio, BSL_UIO_SET_FD, (int32_t)sizeof(sslConfig->sockFd), &sslConfig->sockFd);
if (ret != SUCCESS) {
LOG_ERROR("BSL_UIO_SET_FD Fail");
BSL_UIO_Free(uio);
return ERROR;
}
if (BSL_UIO_GetTransportType(uio) == BSL_UIO_UDP) {
BSL_SAL_SockAddr serverAddr = NULL;
ret = SAL_SockAddrNew(&serverAddr);
if (ret != BSL_SUCCESS) {
LOG_ERROR("SAL_SockAddrNew failed\n");
BSL_UIO_Free(uio);
return ret;
}
int32_t addrlen = (int32_t)SAL_SockAddrSize(serverAddr);
if (getpeername(sslConfig->sockFd, (struct sockaddr *)serverAddr, (socklen_t *)&addrlen) == 0) {
ret = BSL_UIO_Ctrl(uio, BSL_UIO_UDP_SET_CONNECTED, addrlen, serverAddr);
if (ret != HITLS_SUCCESS) {
LOG_ERROR("BSL_UIO_SET_PEER_IP_ADDR failed %d\n", addrlen);
SAL_SockAddrFree(serverAddr);
BSL_UIO_Free(uio);
return ERROR;
}
}
SAL_SockAddrFree(serverAddr);
}
BSL_UIO_SetInit(uio, 1);
ret = HITLS_SetUio(ssl, uio);
if (ret != SUCCESS) {
LOG_ERROR("HITLS_SetUio Fail");
BSL_UIO_Free(uio);
return ERROR;
}
// Release the UIO to prevent memory leakage.
BSL_UIO_Free(uio);
return SUCCESS;
}
void *HitlsAccept(void *ssl)
{
static int ret;
int timeout = TIME_OUT_SEC;
if (getenv("SSL_TIMEOUT") != NULL) {
timeout = atoi(getenv("SSL_TIMEOUT"));
}
time_t start = time(NULL);
LOG_DEBUG("HiTLS Tls Accept Ing...");
do {
ret = HITLS_Accept(ssl);
usleep(1000); // stay 1000us
} while ((ret == HITLS_REC_NORMAL_RECV_BUF_EMPTY || ret == HITLS_REC_NORMAL_IO_BUSY ||
ret == HITLS_CALLBACK_CLIENT_HELLO_RETRY || ret == HITLS_CALLBACK_CERT_RETRY) &&
((time(NULL) - start < timeout))); // usleep(1000) after each attemp.
if (ret != SUCCESS) {
LOG_ERROR("HITLS_Accept Error is %d", ret);
} else {
LOG_DEBUG("HiTLS Tls Accept Success");
}
return &ret;
}
int HitlsConnect(void *ssl)
{
int ret;
int timeout = TIME_OUT_SEC;
if (getenv("SSL_TIMEOUT") != NULL) {
timeout = atoi(getenv("SSL_TIMEOUT"));
}
time_t start = time(NULL);
LOG_DEBUG("HiTLS Tls Connect Ing...");
do {
ret = HITLS_Connect(ssl);
usleep(1000); // stay 1000us
} while ((ret == HITLS_REC_NORMAL_RECV_BUF_EMPTY || ret == HITLS_REC_NORMAL_IO_BUSY ||
ret == HITLS_CALLBACK_CERT_RETRY) &&
((time(NULL) - start < timeout))); // usleep(1000) after each attemp.
if (ret != SUCCESS) {
LOG_ERROR("HITLS_Connect Error is %d", ret);
} else {
LOG_DEBUG("HiTLS Tls Connect Success");
}
return ret;
}
int HitlsWrite(void *ssl, uint8_t *data, uint32_t dataLen)
{
int ret;
int timeout = 4;
if (getenv("SSL_TIMEOUT") != NULL) {
timeout = atoi(getenv("SSL_TIMEOUT"));
}
time_t start = time(NULL);
LOG_DEBUG("HiTLS Write Ing...");
uint32_t len = 0;
do {
ret = HITLS_Write(ssl, data, dataLen, &len);
usleep(1000); // stay 1000us
} while ((ret == HITLS_REC_NORMAL_RECV_BUF_EMPTY ||
ret == HITLS_REC_NORMAL_IO_BUSY) &&
(time(NULL) - start < timeout)); // A maximum of 4000 calls
LOG_DEBUG("HiTLS Write Result is %d", ret);
return ret;
}
int HitlsRead(void *ssl, uint8_t *data, uint32_t bufSize, uint32_t *readLen)
{
int ret;
int timeout = 8;
if (getenv("SSL_TIMEOUT") != NULL) {
timeout = atoi(getenv("SSL_TIMEOUT"));
}
time_t start = time(NULL);
LOG_DEBUG("HiTLS Read Ing...");
do {
ret = HITLS_Read(ssl, data, bufSize, readLen);
usleep(1000); // stay 1000us
} while ((ret == HITLS_REC_NORMAL_RECV_BUF_EMPTY || ret == HITLS_REC_NORMAL_IO_BUSY ||
ret == HITLS_CALLBACK_CERT_RETRY) &&
((time(NULL) - start < timeout))); // A maximum of 8000 calls
LOG_DEBUG("HiTLS Read Result is %d", ret);
return ret;
}
int HitlsClose(void *ctx)
{
return HITLS_Close(ctx);
}
int HitlsRenegotiate(void *ssl)
{
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
return HITLS_Renegotiate(ssl);
#else
(void)ssl;
return -1;
#endif
}
int HitlsSetMtu(void *ssl, uint16_t mtu)
{
#ifdef HITLS_TLS_PROTO_DTLS12
return HITLS_SetMtu(ssl, mtu);
#else
(void)ssl;
(void)mtu;
return -1;
#endif
}
int HitlsSetSession(void *ssl, void *session)
{
#ifdef HITLS_TLS_FEATURE_SESSION
return HITLS_SetSession(ssl, session);
#else
(void)ssl;
(void)session;
return -1;
#endif
}
int HitlsSessionReused(void *ssl)
{
uint8_t isReused = 0;
(void)ssl;
#ifdef HITLS_TLS_FEATURE_SESSION
int32_t ret;
ret = HITLS_IsSessionReused(ssl, &isReused);
if (ret != HITLS_SUCCESS) {
return 0;
}
#endif
return (int)isReused;
}
void *HitlsGet1Session(void *ssl)
{
#ifdef HITLS_TLS_FEATURE_SESSION
return HITLS_GetDupSession(ssl);
#else
(void)ssl;
return NULL;
#endif
}
int HitlsSessionHasTicket(void *session)
{
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
return (HITLS_SESS_HasTicket(session) ? 1 : 0);
#else
(void)session;
return 0;
#endif
}
int HitlsSessionIsResumable(void *session)
{
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
return (HITLS_SESS_IsResumable(session) ? 1 : 0);
#else
(void)session;
return 0;
#endif
}
void HitlsFreeSession(void *session)
{
#ifdef HITLS_TLS_FEATURE_SESSION
HITLS_SESS_Free(session);
#else
(void)session;
#endif
}
int HitlsGetErrorCode(void *ssl)
{
return HITLS_GetErrorCode(ssl);
} | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/rpc/src/hitls_func.c | C | unknown | 42,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.
*/
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
#include "securec.h"
#include "logger.h"
#include "process.h"
#include "handle_cmd.h"
#include "hlt.h"
#include "tls_res.h"
#include "common_func.h"
#include "hitls_func.h"
#include "sctp_channel.h"
#include "tcp_channel.h"
#include "udp_channel.h"
#include "socket_common.h"
#include "cert_callback.h"
#include "sctp_channel.h"
#include "frame_tls.h"
#define DOMAIN_PATH_LEN (128)
#define CMD_MAX_LEN 1024
#define SUCCESS 0
#define ERROR (-1)
int g_acceptFd;
void* HLT_TlsNewCtx(TLS_VERSION tlsVersion)
{
int ret;
void *ctx = NULL;
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
ctx = HitlsNewCtx(tlsVersion);
break;
default:
ctx = NULL;
}
if ((process->remoteFlag == 0) && (ctx != NULL)) {
// If the value is LocalProcess, insert it to the CTX linked list.
ret = InsertCtxToList(ctx);
if (ret == ERROR) {
LOG_ERROR("InsertCtxToList ERROR");
return NULL;
}
}
return ctx;
}
#ifdef HITLS_TLS_FEATURE_PROVIDER
void* HLT_TlsProviderNewCtx(char *providerPath, char (*providerNames)[MAX_PROVIDER_NAME_LEN], int *providerLibFmts,
int providerCnt, char *attrName, TLS_VERSION tlsVersion)
{
int ret;
void *ctx = NULL;
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
ctx = HitlsProviderNewCtx(providerPath, providerNames, providerLibFmts, providerCnt,
attrName, tlsVersion);
break;
default:
ctx = NULL;
}
if ((process->remoteFlag == 0) && (ctx != NULL)) {
// If the value is LocalProcess, insert it to the CTX linked list.
ret = InsertCtxToList(ctx);
if (ret == ERROR) {
LOG_ERROR("InsertCtxToList ERROR");
return NULL;
}
}
return ctx;
}
#endif
void* HLT_TlsNewSsl(void *ctx)
{
int ret;
void *ssl = NULL;
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
LOG_DEBUG("Hitls New Ssl");
ssl = HitlsNewSsl(ctx);
break;
default:
ssl = NULL;
}
if ((process->remoteFlag == 0) && (ssl != NULL)) {
// If the value is LocalProcess, insert it to the SSL linked list.
ret = InsertSslToList(ctx, ssl);
if (ret == ERROR) {
LOG_ERROR("InsertSslToList ERROR");
return NULL;
}
}
return ssl;
}
int HLT_TlsSetCtx(void *ctx, HLT_Ctx_Config *ctxConfig)
{
int ret;
Process *process = GetProcess();
switch (process->tlsType) {
case HITLS:
LOG_DEBUG("HiTLS Set Ctx's Config");
ret = HitlsSetCtx(ctx, ctxConfig);
break;
default:
ret = ERROR;
}
return ret;
}
int HLT_TlsSetSsl(void *ssl, HLT_Ssl_Config *sslConfig)
{
int ret = ERROR;
Process *process = GetProcess();
switch (process->tlsType) {
case HITLS:
LOG_DEBUG("HiTLS Set Ssl's Config");
ret = HitlsSetSsl(ssl, sslConfig);
break;
default:
LOG_DEBUG("Unknown tls type");
break;
}
return ret;
}
// listen non-blocking interface
unsigned long int HLT_TlsListen(void *ssl)
{
(void)ssl;
Process *process = GetProcess();
switch (process->tlsType) {
case HITLS : {
return ERROR; // Hitls does not support the listen function.
}
default:
return ERROR;
}
}
// listen blocking interface
int HLT_TlsListenBlock(void* ssl)
{
(void)ssl;
Process *process = GetProcess();
switch (process->tlsType) {
case HITLS : return ERROR; // Hitls does not support the listen function.
default:
return ERROR;
}
}
// Non-blocking interface
unsigned long int HLT_TlsAccept(void *ssl)
{
(void)ssl;
unsigned long int ret = ERROR;
Process *process = GetProcess();
pthread_t t_id;
switch (process->tlsType) {
case HITLS :
ret = pthread_create(&t_id, NULL, (void*)HitlsAccept, (void*)ssl);
break;
default:
break;
}
if (ret != 0) {
return ret;
}
return t_id;
}
int HLT_TlsAcceptBlock(void *ssl)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
return *(int *)HitlsAccept(ssl);
default:
return ERROR;
}
}
int HLT_GetTlsAcceptResultFromId(unsigned long int threadId)
{
pthread_join(threadId, NULL);
return SUCCESS;
}
int HLT_GetTlsAcceptResult(HLT_Tls_Res* tlsRes)
{
static int ret;
if (tlsRes->acceptId <= 0) {
LOG_ERROR("This Res Has Not acceptId");
return ERROR;
}
if (tlsRes->ctx == NULL) {
// Indicates that the remote process accepts the request.
ret = HLT_RpcGetTlsAcceptResult(tlsRes->acceptId);
} else {
// Indicates that the local process accepts the request.
int *tmp = NULL;
pthread_join(tlsRes->acceptId, (void**)&tmp);
if (tmp == NULL) {
return ERROR;
}
ret = *tmp;
tlsRes->acceptId = 0;
return ret;
}
tlsRes->acceptId = 0;
return ret;
}
int HLT_TlsConnect(void *ssl)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
return HitlsConnect(ssl);
default:
return ERROR;
}
}
int HLT_TlsWrite(void *ssl, uint8_t *data, uint32_t dataLen)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS : {
LOG_DEBUG("Hitls Write Ing...");
return HitlsWrite(ssl, data, dataLen);
}
default:
return ERROR;
}
}
int HLT_TlsRead(void *ssl, uint8_t *data, uint32_t bufSize, uint32_t *readLen)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS: {
LOG_DEBUG("Hitls Read Ing...");
return HitlsRead(ssl, data, bufSize, readLen);
}
default:
return ERROR;
}
}
int HLT_TlsRenegotiate(void *ssl)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
return HitlsRenegotiate(ssl);
default:
return ERROR;
}
}
int HLT_TlsVerifyClientPostHandshake(void *ssl)
{
#ifdef HITLS_TLS_FEATURE_PHA
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS: return HITLS_VerifyClientPostHandshake(ssl);
default:
return ERROR;
}
#else
(void)ssl;
#endif
return ERROR;
}
int HLT_TlsClose(void *ssl)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS: return HitlsClose(ssl);
default:
return ERROR;
}
}
int HLT_TlsSetSession(void *ssl, void *session)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS: return (HitlsSetSession(ssl, session) == 0) ? 1 : 0;
default:
return ERROR;
}
}
int HLT_TlsSessionReused(void *ssl)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
return HitlsSessionReused(ssl);
default:
return ERROR;
}
}
void *HLT_TlsGet1Session(void *ssl)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
return HitlsGet1Session(ssl);
default:
return NULL;
}
}
int32_t HLT_SetSessionCacheMode(HLT_Ctx_Config* config, HITLS_SESS_CACHE_MODE mode)
{
config->setSessionCache = mode;
return SUCCESS;
}
int32_t HLT_SetSessionTicketSupport(HLT_Ctx_Config* config, bool issupport)
{
config->isSupportSessionTicket = issupport;
return SUCCESS;
}
int HLT_TlsSessionHasTicket(void *session)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
return HitlsSessionHasTicket(session);
default:
return ERROR;
}
}
int HLT_TlsSessionIsResumable(void *session)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
return HitlsSessionIsResumable(session);
default:
return ERROR;
}
}
void HLT_TlsFreeSession(void *session)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
HitlsFreeSession(session);
break;
default:
break;
}
}
int RunDataChannelBind(void *param)
{
int sockFd = -1;
LOG_DEBUG("RunDataChannelBind Ing...\n");
DataChannelParam *channelParam = (DataChannelParam*)param;
switch (channelParam->type) {
#ifdef HITLS_BSL_UIO_TCP
case TCP: sockFd = TcpBind(channelParam->port); break;
#endif
#ifdef HITLS_BSL_UIO_UDP
case UDP: sockFd = UdpBind(channelParam->port); break;
#endif
default:
return ERROR;
}
struct sockaddr_in add;
socklen_t len = sizeof(add);
getsockname(sockFd, (struct sockaddr *)&add, &len);
channelParam->port = ntohs(add.sin_port);
channelParam->bindFd = sockFd;
g_acceptFd = sockFd;
return sockFd;
}
int RunDataChannelAccept(void *param)
{
int sockFd = -1;
LOG_DEBUG("RunDataChannelAccept Ing...\n");
DataChannelParam *channelParam = (DataChannelParam *)param;
switch (channelParam->type) {
#ifdef HITLS_BSL_UIO_TCP
case TCP:
sockFd = TcpAccept(channelParam->ip, channelParam->bindFd, channelParam->isBlock, true);
break;
#endif
#ifdef HITLS_BSL_UIO_UDP
case UDP:
sockFd = UdpAccept(channelParam->ip, channelParam->bindFd, channelParam->isBlock, false);
#endif
break;
default:
return ERROR;
}
g_acceptFd = sockFd;
return sockFd;
}
pthread_t HLT_DataChannelAccept(DataChannelParam *channelParam)
{
pthread_t t_id;
if (pthread_create(&t_id, NULL, (void*)RunDataChannelAccept, (void*)channelParam) != 0) {
LOG_ERROR("Create Thread HLT_RpcDataChannelAccept Error ...");
return 0;
}
return t_id;
}
int HLT_DataChannelBind(DataChannelParam *channelParam)
{
return RunDataChannelBind(channelParam);
}
int HLT_DataChannelConnect(DataChannelParam *dstChannelParam)
{
switch (dstChannelParam->type) {
#ifdef HITLS_BSL_UIO_TCP
case TCP: return TcpConnect(dstChannelParam->ip, dstChannelParam->port);
#endif
#ifdef HITLS_BSL_UIO_UDP
case UDP: return UdpConnect(dstChannelParam->ip, dstChannelParam->port);
#endif
default:
return ERROR;
}
return ERROR;
}
int HLT_GetAcceptFd(pthread_t threadId)
{
pthread_join(threadId, NULL);
return g_acceptFd;
}
HLT_FD HLT_CreateDataChannel(HLT_Process *process1, HLT_Process *process2, DataChannelParam channelParam)
{
int acceptId;
int bindFd;
unsigned long int pthreadId;
HLT_FD sockFd;
char *userPort = getenv("FIXED_PORT");
if (userPort == NULL) {
channelParam.port = 0; // The system randomly allocates available ports.
}
if (process2->remoteFlag == 1) {
bindFd = HLT_RpcDataChannelBind(process2, &channelParam);
} else {
bindFd = HLT_DataChannelBind(&channelParam);
}
channelParam.bindFd = bindFd;
// Start Accept again.
if (process2->remoteFlag == 1) {
acceptId = HLT_RpcDataChannelAccept(process2, &channelParam);
} else {
pthreadId = HLT_DataChannelAccept(&channelParam);
}
// In Connect
if (process1->remoteFlag == 1) {
sockFd.srcFd = HLT_RpcDataChannelConnect(process1, &channelParam);
} else {
sockFd.srcFd = HLT_DataChannelConnect(&channelParam);
}
if (process2->remoteFlag == 1) {
if (sockFd.srcFd > 0) {
// Indicates that the CONNECT is successful.
sockFd.peerFd = HLT_RpcGetAcceptFd(acceptId);
} else {
sockFd.peerFd = -1;
}
} else {
if (sockFd.srcFd > 0) {
// Indicates that the CONNECT is successful.
sockFd.peerFd = HLT_GetAcceptFd(pthreadId);
sockFd.sockAddr = channelParam.sockAddr;
sockFd.connPort = channelParam.port;
} else {
// If the SCTP link fails to be established, delete the thread to avoid congestion.
pthread_cancel(pthreadId);
pthread_join(pthreadId, NULL);
}
}
return sockFd;
}
void HLT_CloseFd(int fd, int linkType)
{
switch (linkType) {
#ifdef HITLS_BSL_UIO_TCP
case TCP: TcpClose(fd); break;
#endif
#ifdef HITLS_BSL_UIO_UDP
case UDP: UdpClose(fd); break;
#endif
default:
/* Unknown fd type */
break;
}
}
HLT_Ctx_Config* HLT_NewCtxConfigTLCP(char *setFile, const char *key, bool isClient)
{
(void)setFile;
Process *localProcess;
HLT_Ctx_Config *ctxConfig = (HLT_Ctx_Config*)calloc(sizeof(HLT_Ctx_Config), 1u);
if (ctxConfig == NULL) {
return NULL;
}
ctxConfig->isSupportRenegotiation = false;
ctxConfig->allowClientRenegotiate = false;
ctxConfig->allowLegacyRenegotiate = false;
ctxConfig->isSupportClientVerify = false;
ctxConfig->isSupportNoClientCert = false;
ctxConfig->isSupportExtendMasterSecret = false;
ctxConfig->isClient = isClient;
ctxConfig->setSessionCache = 2;
HLT_SetGroups(ctxConfig, "NULL");
HLT_SetCipherSuites(ctxConfig, "NULL");
HLT_SetTls13CipherSuites(ctxConfig, "NULL");
HLT_SetSignature(ctxConfig, "NULL");
HLT_SetEcPointFormats(ctxConfig, "NULL");
HLT_SetPassword(ctxConfig, "NULL");
HLT_SetPsk(ctxConfig, "NULL");
HLT_SetTicketKeyCb(ctxConfig, "NULL");
if (strncmp("SERVER", key, strlen(key)) == 0) {
HLT_SetCertPath(ctxConfig, SM2_VERIFY_PATH, SM2_CHAIN_PATH, SM2_SERVER_ENC_CERT_PATH, SM2_SERVER_ENC_KEY_PATH,
SM2_SERVER_SIGN_CERT_PATH, SM2_SERVER_SIGN_KEY_PATH);
} else if (strncmp("CLIENT", key, strlen(key)) == 0) {
HLT_SetCertPath(ctxConfig, SM2_VERIFY_PATH, SM2_CHAIN_PATH, SM2_CLIENT_ENC_CERT_PATH, SM2_CLIENT_ENC_KEY_PATH,
SM2_CLIENT_SIGN_CERT_PATH, SM2_CLIENT_SIGN_KEY_PATH);
} else {
free(ctxConfig);
ctxConfig = NULL;
return NULL;
}
// Store CTX configuration resources and release them later.
localProcess = GetProcess();
localProcess->tlsResArray[localProcess->tlsResNum] = ctxConfig;
localProcess->tlsResNum++;
return ctxConfig;
}
HLT_Ctx_Config* HLT_NewCtxConfig(char *setFile, const char *key)
{
(void)setFile;
HLT_Ctx_Config *ctxConfig;
Process *localProcess;
ctxConfig = (HLT_Ctx_Config*)malloc(sizeof(HLT_Ctx_Config));
if (ctxConfig == NULL) {
return NULL;
}
(void)memset_s(ctxConfig, sizeof(HLT_Ctx_Config), 0, sizeof(HLT_Ctx_Config));
ctxConfig->needCheckKeyUsage = false;
ctxConfig->isSupportRenegotiation = false;
ctxConfig->allowClientRenegotiate = false;
ctxConfig->allowLegacyRenegotiate = false;
ctxConfig->isSupportClientVerify = false;
ctxConfig->isSupportNoClientCert = false;
ctxConfig->isSupportVerifyNone = false;
ctxConfig->isSupportPostHandshakeAuth = false;
ctxConfig->isSupportExtendMasterSecret = true;
ctxConfig->isSupportSessionTicket = false;
ctxConfig->isSupportDhAuto = true;
ctxConfig->isEncryptThenMac = true;
ctxConfig->isMiddleBoxCompat = true;
ctxConfig->keyExchMode = TLS13_KE_MODE_PSK_WITH_DHE;
ctxConfig->setSessionCache = HITLS_SESS_CACHE_SERVER;
ctxConfig->mtu = 0;
ctxConfig->infoCb = NULL;
ctxConfig->securitylevel = HITLS_SECURITY_LEVEL_ZERO;
ctxConfig->SupportType = 0;
ctxConfig->readAhead = 1;
ctxConfig->emptyRecordsNum = 32;
HLT_SetGroups(ctxConfig, "NULL");
HLT_SetCipherSuites(ctxConfig, "NULL");
HLT_SetTls13CipherSuites(ctxConfig, "NULL");
HLT_SetSignature(ctxConfig, "NULL");
HLT_SetEcPointFormats(ctxConfig, "HITLS_POINT_FORMAT_UNCOMPRESSED");
HLT_SetPassword(ctxConfig, "NULL");
HLT_SetPsk(ctxConfig, "NULL");
HLT_SetTicketKeyCb(ctxConfig, "NULL");
HLT_SetServerName(ctxConfig, "NULL");
HLT_SetServerNameCb(ctxConfig, "NULL");
HLT_SetServerNameArg(ctxConfig, "NULL");
HLT_SetAlpnProtos(ctxConfig, "NULL");
HLT_SetAlpnProtosSelectCb(ctxConfig, "NULL", "NULL");
if (strncmp("SERVER", key, strlen(key)) == 0) {
HLT_SetCertPath(ctxConfig, ECDSA_SHA256_CA_PATH,
ECDSA_SHA256_CHAIN_PATH, ECDSA_SHA256_EE_PATH1, ECDSA_SHA256_PRIV_PATH1, "NULL", "NULL");
} else if (strncmp("CLIENT", key, strlen(key)) == 0) {
HLT_SetCertPath(ctxConfig, ECDSA_SHA256_CA_PATH,
ECDSA_SHA256_CHAIN_PATH, ECDSA_SHA256_EE_PATH2, ECDSA_SHA256_PRIV_PATH2, "NULL", "NULL");
} else {
free(ctxConfig);
ctxConfig = NULL;
return NULL;
}
// Store CTX configuration resources and release them later.
localProcess = GetProcess();
localProcess->tlsResArray[localProcess->tlsResNum] = ctxConfig;
localProcess->tlsResNum++;
return ctxConfig;
}
HLT_Ssl_Config *HLT_NewSslConfig(char *setFile)
{
(void)setFile;
HLT_Ssl_Config *sslConfig;
Process *localProcess;
sslConfig = (HLT_Ssl_Config*)malloc(sizeof(HLT_Ssl_Config));
if (sslConfig == NULL) {
return NULL;
}
(void)memset_s(sslConfig, sizeof(HLT_Ssl_Config), 0, sizeof(HLT_Ssl_Config));
// Store SSL configuration resources and release them later.
localProcess = GetProcess();
localProcess->tlsResArray[localProcess->tlsResNum] = sslConfig;
localProcess->tlsResNum++;
return sslConfig;
}
int HLT_LibraryInit(TLS_TYPE tlsType)
{
switch (tlsType) {
case HITLS: return HitlsInit(); break;
default:
/* Unknown type */
break;
}
return ERROR;
}
int HLT_TlsRegCallback(TlsCallbackType type)
{
switch (type) {
case HITLS_CALLBACK_DEFAULT:
FRAME_Init();
break;
default:
return SUCCESS;
}
return SUCCESS;
}
void HLT_FreeAllProcess(void)
{
int ret;
HLT_Tls_Res* tlsRes;
Process *remoteProcess;
Process *localProcess = GetProcess();
if (localProcess == NULL) {
return;
}
if (localProcess->remoteFlag != 0) {
LOG_ERROR("Only Local Process Can Call HLT_FreeAllProcess");
return;
}
// Clearing HLT_Tls_Res and Threads
for (int i = 0; i < localProcess->hltTlsResNum; i++) {
tlsRes = localProcess->hltTlsResArray[i];
alarm(60); // Avoid long waits
if ((tlsRes->acceptId > 0) && (tlsRes->ctx != NULL)) {
pthread_join(tlsRes->acceptId, NULL);
}
free(tlsRes);
}
// Sends a signal for the peer process to exit.
remoteProcess = GetProcessFromList();
while (remoteProcess != NULL) {
ret = HLT_RpcProcessExit(remoteProcess);
if (ret != SUCCESS) {
LOG_ERROR("HLT_RpcProcessExit Error");
}
free(remoteProcess);
remoteProcess = GetProcessFromList();
}
// Clearing Local Resources
// Clearing Ports
if (localProcess->connFd > 0) {
close(localProcess->connFd);
}
// Clear the TlsRes linked list.
FreeTlsResList();
// Clear CTX SSL configuration resources.
for (int i = 0; i < localProcess->tlsResNum; i++) {
free(localProcess->tlsResArray[i]);
}
// Clear the linked list of the remote process.
FreeProcessResList();
// Clear local control connection resources
FreeControlChannelRes();
// Clear local processes.
FreeProcess();
return;
}
int HLT_FreeResFromSsl(const void *ssl)
{
return FreeResFromSsl(ssl);
}
static int LocalProcessTlsInit(HLT_Process *process, TLS_VERSION tlsVersion,
HLT_Ctx_Config *ctxConfig, HLT_Ssl_Config *sslConfig, HLT_Tls_Res *tlsRes)
{
void *ctx, *ssl;
#ifdef HITLS_TLS_FEATURE_PROVIDER
ctx = HLT_TlsProviderNewCtx(ctxConfig->providerPath, ctxConfig->providerNames, ctxConfig->providerLibFmts,
ctxConfig->providerCnt, ctxConfig->attrName, tlsVersion);
#else
ctx = HLT_TlsNewCtx(tlsVersion);
#endif
if (ctx == NULL) {
LOG_ERROR("HLT_TlsNewCtx or HLT_TlsProviderNewCtx ERROR");
return ERROR;
}
if (HLT_TlsSetCtx(ctx, ctxConfig) != SUCCESS) {
LOG_ERROR("HLT_TlsSetCtx ERROR");
return ERROR;
}
ssl = HLT_TlsNewSsl(ctx);
if (ssl == NULL) {
LOG_ERROR("HLT_TlsNewSsl ERROR");
return ERROR;
}
// When FD is 0, the default configuration is used.
if (sslConfig->sockFd == 0) {
sslConfig->sockAddr = process->sockAddr;
sslConfig->sockFd = process->connFd;
sslConfig->connType = process->connType;
}
if (HLT_TlsSetSsl(ssl, sslConfig) != SUCCESS) {
LOG_ERROR("HLT_TlsSetSsl ERROR");
return ERROR;
}
if (ctxConfig->mtu > 0) {
if (HLT_TlsSetMtu(ssl, ctxConfig->mtu) != SUCCESS) {
LOG_ERROR("HLT_TlsSetMtu ERROR");
return ERROR;
}
}
tlsRes->ctx = ctx;
tlsRes->ssl = ssl;
tlsRes->ctxId = -1; // -1 indicates that the field is discarded.
tlsRes->sslId = -1; // -1 indicates that the field is discarded.
return SUCCESS;
}
static int RemoteProcessTlsInit(HLT_Process *process, TLS_VERSION tlsVersion,
HLT_Ctx_Config *ctxConfig, HLT_Ssl_Config *sslConfig, HLT_Tls_Res *tlsRes)
{
int ctxId;
int sslId;
#ifdef HITLS_TLS_FEATURE_PROVIDER
ctxId = HLT_RpcProviderTlsNewCtx(process, tlsVersion, ctxConfig->isClient, ctxConfig->providerPath,
ctxConfig->providerNames, ctxConfig->providerLibFmts, ctxConfig->providerCnt, ctxConfig->attrName);
#else
ctxId = HLT_RpcTlsNewCtx(process, tlsVersion, ctxConfig->isClient);
#endif
if (ctxId < 0) {
LOG_ERROR("HLT_RpcTlsNewCtx ERROR");
return ERROR;
}
if (HLT_RpcTlsSetCtx(process, ctxId, ctxConfig) != SUCCESS) {
LOG_ERROR("HLT_RpcTlsSetCtx ERROR");
return ERROR;
}
sslId = HLT_RpcTlsNewSsl(process, ctxId);
if (sslId < 0) {
LOG_ERROR("HLT_RpcTlsNewSsl ERROR");
return ERROR;
}
// When FD is 0, the default configuration is used.
if (sslConfig->sockFd == 0) {
sslConfig->connPort = process->connPort;
sslConfig->sockFd = process->connFd;
sslConfig->connType = process->connType;
}
if (HLT_RpcTlsSetSsl(process, sslId, sslConfig) != SUCCESS) {
LOG_ERROR("HLT_RpcTlsSetSsl ERROR");
return ERROR;
}
if (ctxConfig->mtu > 0) {
if (HLT_RpcTlsSetMtu(process, sslId, ctxConfig->mtu) != SUCCESS) {
LOG_ERROR("HLT_RpcTlsSetMtu ERROR");
return ERROR;
}
}
tlsRes->ctx = NULL;
tlsRes->ssl = NULL;
tlsRes->ctxId = ctxId;
tlsRes->sslId = sslId;
return SUCCESS;
}
HLT_Tls_Res *HLT_ProcessTlsInit(HLT_Process *process, TLS_VERSION tlsVersion,
HLT_Ctx_Config *ctxConfig, HLT_Ssl_Config *sslConfig)
{
int ret;
HLT_Tls_Res *tlsRes = (HLT_Tls_Res*)malloc(sizeof(HLT_Tls_Res));
if (tlsRes == NULL) {
LOG_ERROR("Malloc TlsRes ERROR");
return NULL;
}
// Checking Configuration Parameters
if (ctxConfig == NULL) {
ctxConfig = HLT_NewCtxConfig(NULL, "SERVER");
}
if (sslConfig == NULL) {
sslConfig = HLT_NewSslConfig(NULL);
}
if ((ctxConfig == NULL) || (sslConfig == NULL)) {
LOG_ERROR("ctxConfig or sslConfig is NULL");
goto ERR;
}
sslConfig->SupportType = ctxConfig->SupportType;
// Check whether the call is invoked by the local process or by the RPC.
if (process->remoteFlag == 0) {
ret = LocalProcessTlsInit(process, tlsVersion, ctxConfig, sslConfig, tlsRes);
if (ret == ERROR) {
LOG_ERROR("LocalProcessTlsInit ERROR");
goto ERR;
}
} else {
ret = RemoteProcessTlsInit(process, tlsVersion, ctxConfig, sslConfig, tlsRes);
if (ret == ERROR) {
LOG_ERROR("RemoteProcessTlsInit ERROR");
goto ERR;
}
}
// The configuration resources of the HLT_Tls_Res table are stored and will be released later.
Process *localProcess = GetProcess();
tlsRes->acceptId = 0;
localProcess->hltTlsResArray[localProcess->hltTlsResNum] = tlsRes;
localProcess->hltTlsResNum++;
return tlsRes;
ERR:
free(tlsRes);
return NULL;
}
int HLT_TlsSetMtu(void *ssl, uint16_t mtu)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
return HitlsSetMtu(ssl, mtu);
default:
break;
}
return ERROR;
}
int HLT_TlsGetErrorCode(void *ssl)
{
return HitlsGetErrorCode(ssl);
}
HLT_Tls_Res* HLT_ProcessTlsAccept(HLT_Process *process, TLS_VERSION tlsVersion,
HLT_Ctx_Config *ctxConfig, HLT_Ssl_Config *sslConfig)
{
unsigned long int acceptId;
HLT_Tls_Res *tlsRes = NULL;
tlsRes = HLT_ProcessTlsInit(process, tlsVersion, ctxConfig, sslConfig);
if (tlsRes == NULL) {
LOG_ERROR("HLT_ProcessTlsInit ERROR");
return NULL;
}
// Check whether the call is invoked by the local process or by the RPC.
if (process->remoteFlag == 0) {
acceptId = HLT_TlsAccept(tlsRes->ssl);
if (acceptId == (unsigned long int)ERROR) {
LOG_ERROR("HLT_TlsAccept ERROR");
return NULL;
}
} else {
acceptId = HLT_RpcTlsAccept(process, tlsRes->sslId);
if (acceptId == (unsigned long int)ERROR) {
LOG_ERROR("HLT_TlsAccept ERROR");
return NULL;
}
}
tlsRes->acceptId = acceptId;
return tlsRes;
}
HLT_Tls_Res* HLT_ProcessTlsConnect(HLT_Process *process, TLS_VERSION tlsVersion,
HLT_Ctx_Config *ctxConfig, HLT_Ssl_Config *sslConfig)
{
int ret;
HLT_Tls_Res *tlsRes = (HLT_Tls_Res*)malloc(sizeof(HLT_Tls_Res));
if (tlsRes == NULL) {
LOG_ERROR("Malloc TlsRes ERROR");
return NULL;
}
(void)memset_s(tlsRes, sizeof(HLT_Tls_Res), 0, sizeof(HLT_Tls_Res));
// Checking Configuration Parameters
if (ctxConfig == NULL) {
ctxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
}
if (sslConfig == NULL) {
sslConfig = HLT_NewSslConfig(NULL);
}
if ((ctxConfig == NULL) || (sslConfig == NULL)) {
LOG_ERROR("ctxConfig or sslConfig is NULL");
goto ERR;
}
// Check whether the call is invoked by the local process or by the RPC.
if (process->remoteFlag == 0) {
ret = LocalProcessTlsInit(process, tlsVersion, ctxConfig, sslConfig, tlsRes);
if (ret == ERROR) {
LOG_ERROR("LocalProcessTlsInit ERROR");
goto ERR;
}
ret = HLT_TlsConnect(tlsRes->ssl);
if (ret != SUCCESS) {
LOG_ERROR("HLT_TlsConnect ERROR is %d", ret);
goto ERR;
}
} else {
ret = RemoteProcessTlsInit(process, tlsVersion, ctxConfig, sslConfig, tlsRes);
if (ret == ERROR) {
LOG_ERROR("Retmote Process Init Tls ERROR");
goto ERR;
}
ret = HLT_RpcTlsConnect(process, tlsRes->sslId);
if (ret != SUCCESS) {
LOG_ERROR("HLT_RpcTlsConnect ERROR is %d", ret);
goto ERR;
}
}
// The configuration resources of the HLT_Tls_Res table are stored and will be released later.
Process *localProcess = GetProcess();
localProcess->hltTlsResArray[localProcess->hltTlsResNum] = tlsRes;
localProcess->hltTlsResNum++;
return tlsRes;
ERR:
free(tlsRes);
return NULL;
}
int HLT_ProcessTlsWrite(HLT_Process *process, HLT_Tls_Res *tlsRes, uint8_t *data, uint32_t dataLen)
{
if (process == NULL) {
LOG_ERROR("Process is NULL");
return ERROR;
}
if (process->remoteFlag == 0) {
return HLT_TlsWrite(tlsRes->ssl, data, dataLen);
} else {
return HLT_RpcTlsWrite(process, tlsRes->sslId, data, dataLen);
}
}
int HLT_ProcessTlsRead(HLT_Process *process, HLT_Tls_Res *tlsRes, uint8_t *data, uint32_t bufSize, uint32_t *dataLen)
{
if (process == NULL) {
LOG_ERROR("Process is NULL");
return ERROR;
}
if (process->remoteFlag == 0) {
return HLT_TlsRead(tlsRes->ssl, data, bufSize, dataLen);
} else {
return HLT_RpcTlsRead(process, tlsRes->sslId, data, bufSize, dataLen);
}
}
int HLT_SetVersion(HLT_Ctx_Config *ctxConfig, uint16_t minVersion, uint16_t maxVersion)
{
ctxConfig->minVersion = minVersion;
ctxConfig->maxVersion = maxVersion;
return SUCCESS;
}
int HLT_SetSecurityLevel(HLT_Ctx_Config *ctxConfig, int32_t level)
{
ctxConfig->securitylevel = level;
return SUCCESS;
}
int HLT_SetRenegotiationSupport(HLT_Ctx_Config *ctxConfig, bool support)
{
ctxConfig->isSupportRenegotiation = support;
return SUCCESS;
}
int HLT_SetLegacyRenegotiateSupport(HLT_Ctx_Config *ctxConfig, bool support)
{
ctxConfig->allowLegacyRenegotiate = support;
return SUCCESS;
}
int HLT_SetClientRenegotiateSupport(HLT_Ctx_Config *ctxConfig, bool support)
{
ctxConfig->allowClientRenegotiate = support;
return SUCCESS;
}
int HLT_SetEmptyRecordsNum(HLT_Ctx_Config *ctxConfig, uint32_t emptyNum)
{
ctxConfig->emptyRecordsNum = emptyNum;
return SUCCESS;
}
int HLT_SetKeyLogCb(HLT_Ctx_Config *ctxConfig, char *SetKeyLogCb)
{
(void)memset_s(ctxConfig->keyLogCb, KEY_LOG_CB_LEN, 0, KEY_LOG_CB_LEN);
if (strcpy_s(ctxConfig->keyLogCb, KEY_LOG_CB_LEN, SetKeyLogCb) != EOK) {
LOG_ERROR("HLT_SetKeyLogCb failed.");
return -1;
}
return SUCCESS;
}
int HLT_SetEncryptThenMac(HLT_Ctx_Config *ctxConfig, int support)
{
ctxConfig->isEncryptThenMac = support;
return SUCCESS;
}
int HLT_SetMiddleBoxCompat(HLT_Ctx_Config *ctxConfig, int support)
{
ctxConfig->isMiddleBoxCompat = support;
return SUCCESS;
}
int HLT_SetFlightTransmitSwitch(HLT_Ctx_Config *ctxConfig, bool support)
{
ctxConfig->isFlightTransmitEnable = support;
return SUCCESS;
}
int HLT_SetClientVerifySupport(HLT_Ctx_Config *ctxConfig, bool support)
{
ctxConfig->isSupportClientVerify = support;
return SUCCESS;
}
int HLT_SetPostHandshakeAuth(HLT_Ctx_Config *ctxConfig, bool support)
{
ctxConfig->isSupportPostHandshakeAuth = support;
return SUCCESS;
}
int HLT_SetNoClientCertSupport(HLT_Ctx_Config *ctxConfig, bool support)
{
ctxConfig->isSupportNoClientCert = support;
return SUCCESS;
}
int HLT_SetExtenedMasterSecretSupport(HLT_Ctx_Config *ctxConfig, bool support)
{
ctxConfig->isSupportExtendMasterSecret = support;
return SUCCESS;
}
int HLT_SetModeSupport(HLT_Ctx_Config *ctxConfig, uint32_t mode)
{
ctxConfig->modeSupport = mode;
return SUCCESS;
}
int HLT_SetCipherSuites(HLT_Ctx_Config *ctxConfig, const char *cipherSuites)
{
int ret;
(void)memset_s(ctxConfig->cipherSuites, sizeof(ctxConfig->cipherSuites), 0, sizeof(ctxConfig->cipherSuites));
ret = sprintf_s(ctxConfig->cipherSuites, sizeof(ctxConfig->cipherSuites), cipherSuites);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetProviderPath(HLT_Ctx_Config *ctxConfig, char *providerPath)
{
if (strcpy_s(ctxConfig->providerPath, sizeof(ctxConfig->providerPath), providerPath) != EOK) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetProviderAttrName(HLT_Ctx_Config *ctxConfig, char *attrName)
{
if (strcpy_s(ctxConfig->attrName, sizeof(ctxConfig->attrName), attrName) != EOK) {
return ERROR;
}
return SUCCESS;
}
int HLT_AddProviderInfo(HLT_Ctx_Config *ctxConfig, char *providerName, int providerLibFmt)
{
if (providerName != NULL) {
if (strcpy_s(ctxConfig->providerNames[ctxConfig->providerCnt], MAX_PROVIDER_NAME_LEN, providerName) != EOK) {
return ERROR;
}
ctxConfig->providerLibFmts[ctxConfig->providerCnt] = providerLibFmt;
ctxConfig->providerCnt += 1;
}
return SUCCESS;
}
int HLT_SetTls13CipherSuites(HLT_Ctx_Config *ctxConfig, const char *cipherSuites)
{
int ret;
(void)memset_s(ctxConfig->tls13CipherSuites, sizeof(ctxConfig->tls13CipherSuites), 0,
sizeof(ctxConfig->tls13CipherSuites));
ret = sprintf_s(ctxConfig->tls13CipherSuites, sizeof(ctxConfig->tls13CipherSuites), cipherSuites);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetEcPointFormats(HLT_Ctx_Config *ctxConfig, const char *pointFormat)
{
int ret;
(void)memset_s(ctxConfig->pointFormats, sizeof(ctxConfig->pointFormats), 0, sizeof(ctxConfig->pointFormats));
ret = sprintf_s(ctxConfig->pointFormats, sizeof(ctxConfig->pointFormats), pointFormat);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetGroups(HLT_Ctx_Config *ctxConfig, const char *groups)
{
int ret;
(void)memset_s(ctxConfig->groups, sizeof(ctxConfig->groups), 0, sizeof(ctxConfig->groups));
ret = sprintf_s(ctxConfig->groups, sizeof(ctxConfig->groups), groups);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetSignature(HLT_Ctx_Config *ctxConfig, const char *signature)
{
int ret;
(void)memset_s(ctxConfig->signAlgorithms, sizeof(ctxConfig->signAlgorithms), 0, sizeof(ctxConfig->signAlgorithms));
ret = sprintf_s(ctxConfig->signAlgorithms, sizeof(ctxConfig->signAlgorithms), signature);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetPsk(HLT_Ctx_Config *ctxConfig, char *psk)
{
(void)memset_s(ctxConfig->psk, PSK_MAX_LEN, 0, PSK_MAX_LEN);
if (strcpy_s(ctxConfig->psk, PSK_MAX_LEN, psk) != EOK) {
LOG_ERROR("HLT_SetPsk failed.");
return -1;
}
return SUCCESS;
}
int HLT_SetKeyExchMode(HLT_Ctx_Config *config, uint32_t mode)
{
config->keyExchMode = mode;
return SUCCESS;
}
int HLT_SetTicketKeyCb(HLT_Ctx_Config *ctxConfig, char *ticketKeyCbName)
{
(void)memset_s(ctxConfig->ticketKeyCb, TICKET_KEY_CB_NAME_LEN, 0, TICKET_KEY_CB_NAME_LEN);
if (strcpy_s(ctxConfig->ticketKeyCb, TICKET_KEY_CB_NAME_LEN, ticketKeyCbName) != EOK) {
LOG_ERROR("HLT_SetTicketKeyCb failed.");
return -1;
}
return SUCCESS;
}
int HLT_SetCaCertPath(HLT_Ctx_Config *ctxConfig, const char *caCertPath)
{
int ret;
(void)memset_s(ctxConfig->caCert, sizeof(ctxConfig->caCert), 0, sizeof(ctxConfig->caCert));
ret = sprintf_s(ctxConfig->caCert, sizeof(ctxConfig->caCert), caCertPath);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetChainCertPath(HLT_Ctx_Config *ctxConfig, const char *chainCertPath)
{
int ret;
(void)memset_s(ctxConfig->chainCert, sizeof(ctxConfig->chainCert), 0, sizeof(ctxConfig->chainCert));
ret = sprintf_s(ctxConfig->chainCert, sizeof(ctxConfig->chainCert), chainCertPath);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetEeCertPath(HLT_Ctx_Config *ctxConfig, const char *eeCertPath)
{
int ret;
(void)memset_s(ctxConfig->eeCert, sizeof(ctxConfig->eeCert), 0, sizeof(ctxConfig->eeCert));
ret = sprintf_s(ctxConfig->eeCert, sizeof(ctxConfig->eeCert), eeCertPath);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetPrivKeyPath(HLT_Ctx_Config *ctxConfig, const char *privKeyPath)
{
int ret;
(void)memset_s(ctxConfig->privKey, sizeof(ctxConfig->privKey), 0, sizeof(ctxConfig->privKey));
ret = sprintf_s(ctxConfig->privKey, sizeof(ctxConfig->privKey), privKeyPath);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetSignCertPath(HLT_Ctx_Config *ctxConfig, const char *signCertPath)
{
int ret;
(void)memset_s(ctxConfig->signCert, sizeof(ctxConfig->signCert), 0, sizeof(ctxConfig->signCert));
ret = sprintf_s(ctxConfig->signCert, sizeof(ctxConfig->signCert), signCertPath);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetSignPrivKeyPath(HLT_Ctx_Config *ctxConfig, const char *signPrivKeyPath)
{
int ret;
(void)memset_s(ctxConfig->signPrivKey, sizeof(ctxConfig->signPrivKey), 0, sizeof(ctxConfig->signPrivKey));
ret = sprintf_s(ctxConfig->signPrivKey, sizeof(ctxConfig->signPrivKey), signPrivKeyPath);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetPassword(HLT_Ctx_Config* ctxConfig, const char* password)
{
int ret;
(void)memset_s(ctxConfig->password, sizeof(ctxConfig->password), 0, sizeof(ctxConfig->password));
ret = sprintf_s(ctxConfig->password, sizeof(ctxConfig->password), password);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
void HLT_SetCertPath(HLT_Ctx_Config *ctxConfig, const char *caPath, const char *chainPath, const char *EePath,
const char *PrivPath, const char *signCert, const char *signPrivKey)
{
HLT_SetCaCertPath(ctxConfig, caPath);
if (ctxConfig->isNoSetCert) {
return;
}
HLT_SetChainCertPath(ctxConfig, chainPath);
HLT_SetEeCertPath(ctxConfig, EePath);
HLT_SetPrivKeyPath(ctxConfig, PrivPath);
HLT_SetSignCertPath(ctxConfig, signCert);
HLT_SetSignPrivKeyPath(ctxConfig, signPrivKey);
}
int HLT_SetServerName(HLT_Ctx_Config *ctxConfig, const char *serverName)
{
(void)memset_s(ctxConfig->serverName, sizeof(ctxConfig->serverName), 0, sizeof(ctxConfig->serverName));
int ret = sprintf_s(ctxConfig->serverName, sizeof(ctxConfig->serverName), serverName);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetServerNameArg(HLT_Ctx_Config *ctxConfig, char *arg)
{
(void)memset_s(ctxConfig->sniArg, SERVER_NAME_ARG_NAME_LEN, 0, SERVER_NAME_ARG_NAME_LEN);
if (strcpy_s(ctxConfig->sniArg, SERVER_NAME_ARG_NAME_LEN, arg) != EOK) {
LOG_ERROR("HLT_SetServerNameArg failed.");
return ERROR;
}
return SUCCESS;
}
int HLT_SetServerNameCb(HLT_Ctx_Config *ctxConfig, char *sniCbName)
{
(void)memset_s(ctxConfig->sniDealCb, SERVER_NAME_CB_NAME_LEN, 0, SERVER_NAME_CB_NAME_LEN);
if (strcpy_s(ctxConfig->sniDealCb, SERVER_NAME_CB_NAME_LEN, sniCbName) != EOK) {
LOG_ERROR("HLT_SetServerNameCb failed.");
return ERROR;
}
return SUCCESS;
}
int HLT_SetAlpnProtos(HLT_Ctx_Config *ctxConfig, const char *alpnProtos)
{
(void)memset_s(ctxConfig->alpnList, sizeof(ctxConfig->alpnList), 0, sizeof(ctxConfig->alpnList));
int ret = sprintf_s(ctxConfig->alpnList, sizeof(ctxConfig->alpnList), alpnProtos);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetAlpnProtosSelectCb(HLT_Ctx_Config *ctxConfig, char *callback, char *userData)
{
(void)memset_s(ctxConfig->alpnSelectCb, ALPN_CB_NAME_LEN, 0, ALPN_CB_NAME_LEN);
if (strcpy_s(ctxConfig->alpnSelectCb, ALPN_CB_NAME_LEN, callback) != EOK) {
LOG_ERROR("HLT_SetAlpnCb failed.");
return ERROR;
}
(void)memset_s(ctxConfig->alpnUserData, ALPN_DATA_NAME_LEN, 0, ALPN_DATA_NAME_LEN);
if (strcpy_s(ctxConfig->alpnUserData, ALPN_DATA_NAME_LEN, userData) != EOK) {
LOG_ERROR("HLT_SetAlpnDataCb failed.");
return ERROR;
}
return SUCCESS;
}
int HLT_SetClientHelloCb(HLT_Ctx_Config *ctxConfig, HITLS_ClientHelloCb callback, void *arg)
{
ctxConfig->clientHelloCb = callback;
ctxConfig->clientHelloArg = arg;
return SUCCESS;
}
int HLT_SetCertCb(HLT_Ctx_Config *ctxConfig, HITLS_CertCb certCb, void *arg)
{
ctxConfig->certCb = certCb;
ctxConfig->certArg = arg;
return SUCCESS;
}
int HLT_SetCAList(HLT_Ctx_Config *ctxConfig, HITLS_TrustedCAList *caList)
{
ctxConfig->caList = caList;
return SUCCESS;
}
int HLT_SetFrameHandle(HLT_FrameHandle *frameHandle)
{
return SetFrameHandle(frameHandle);
}
void HLT_CleanFrameHandle(void)
{
CleanFrameHandle();
}
bool IsEnableSctpAuth(void)
{
return false;
}
void HLT_ConfigTimeOut(const char* timeout)
{
setenv("SSL_TIMEOUT", timeout, 1);
}
void HLT_UnsetTimeOut()
{
unsetenv("SSL_TIMEOUT");
}
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/rpc/src/hlt_func.c | C | unknown | 41,089 |
/*
* 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 <pthread.h>
#include <unistd.h>
#include "logger.h"
#include "process.h"
#include "hlt_type.h"
#include "control_channel.h"
#include "channel_res.h"
#include "handle_cmd.h"
#include "securec.h"
#define SUCCESS 0
#define ERROR (-1)
uint64_t g_cmdIndex = 0;
pthread_mutex_t g_cmdMutex = PTHREAD_MUTEX_INITIALIZER;
#define ASSERT_RETURN(condition, log) \
do { \
if (!(condition)) { \
LOG_ERROR(log); \
return ERROR; \
} \
} while (0)
void InitCmdIndex(void)
{
g_cmdIndex = 0;
}
static int WaitResult(CmdData *expectCmdData, int cmdIndex, const char *funcName)
{
int ret;
ret = sprintf_s(expectCmdData->id, sizeof(expectCmdData->id), "%d", cmdIndex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = sprintf_s(expectCmdData->funcId, sizeof(expectCmdData->funcId), "%s", funcName);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
// Receive the result.
ret = WaitResultFromPeer(expectCmdData);
ASSERT_RETURN(ret == SUCCESS, "WaitResultFromPeer Error");
return SUCCESS;
}
int HLT_RpcProviderTlsNewCtx(HLT_Process *peerProcess, TLS_VERSION tlsVersion, bool isClient, char *providerPath,
char (*providerNames)[MAX_PROVIDER_NAME_LEN], int32_t *providerLibFmts, int32_t providerCnt, char *attrName)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
uint32_t offset = 0;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsNewCtx");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data),
"%llu|%s|%d|%d|",
g_cmdIndex, __FUNCTION__, tlsVersion, isClient);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
offset += ret;
if (providerCnt == 0 || providerNames == NULL || providerLibFmts == NULL) {
ret = sprintf_s(dataBuf.data + offset, sizeof(dataBuf.data) - offset, "|");
ASSERT_RETURN(ret > 0, "sprintf_s Error");
offset += ret;
}
for (int i = 0; i < providerCnt - 1; i++) {
ret = sprintf_s(dataBuf.data + offset, sizeof(dataBuf.data) - offset, "%s,%d:", providerNames[i],
providerLibFmts[i]);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
offset += ret;
}
if (providerCnt >= 1) {
ret = sprintf_s(dataBuf.data + offset, sizeof(dataBuf.data) - offset, "%s,%d|", providerNames[providerCnt - 1],
providerLibFmts[providerCnt - 1]);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
offset += ret;
}
if (attrName != NULL && strlen(attrName) > 0) {
ret = sprintf_s(dataBuf.data + offset, sizeof(dataBuf.data) - offset, "%s|", attrName);
} else {
ret = sprintf_s(dataBuf.data + offset, sizeof(dataBuf.data) - offset, "|");
}
ASSERT_RETURN(ret > 0, "sprintf_s Error");
offset += ret;
if (providerPath != NULL && strlen(providerPath) > 0) {
ret = sprintf_s(dataBuf.data + offset, sizeof(dataBuf.data) - offset, "%s|", providerPath);
} else {
ret = sprintf_s(dataBuf.data + offset, sizeof(dataBuf.data) - offset, "|");
}
ASSERT_RETURN(ret > 0, "sprintf_s Error");
offset += ret;
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcTlsNewCtx(HLT_Process *peerProcess, TLS_VERSION tlsVersion, bool isClient)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsNewCtx");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%d", g_cmdIndex, __FUNCTION__, tlsVersion, isClient);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcTlsSetCtx(HLT_Process *peerProcess, int ctxId, HLT_Ctx_Config *config)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsSetCtx");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data),
"%llu|%s|%d|"
"%u|%u|%s|%s|"
"%s|%s|%s|%d|"
"%d|%d|%d|%s|"
"%s|%s|%s|%s|"
"%s|%s|%s|%d|"
"%d|%s|%d|%s|"
"%s|%s|%s|%s|"
"%s|%d|%d|"
"%u|%d|%d|"
"%d|%d|%d|"
"%d|%u|%d|%d|"
"%u|%d|%s",
g_cmdIndex, __FUNCTION__, ctxId,
config->minVersion, config->maxVersion, config->cipherSuites, config->tls13CipherSuites,
config->pointFormats, config->groups, config->signAlgorithms, config->isSupportRenegotiation,
config->isSupportClientVerify, config->isSupportNoClientCert, config->isSupportExtendMasterSecret, config->eeCert,
config->privKey, config->password, config->caCert, config->chainCert,
config->signCert, config->signPrivKey, config->psk, config->isSupportSessionTicket,
config->setSessionCache, config->ticketKeyCb, config->isFlightTransmitEnable, config->serverName,
config->sniDealCb, config->sniArg, config->alpnList, config->alpnSelectCb,
config->alpnUserData, config->securitylevel, config->isSupportDhAuto,
config->keyExchMode, config->SupportType, config->isSupportPostHandshakeAuth,
config->readAhead, config->needCheckKeyUsage, config->isSupportVerifyNone,
config->allowClientRenegotiate, config->emptyRecordsNum, config->allowLegacyRenegotiate, config->isEncryptThenMac,
config->modeSupport, config->isMiddleBoxCompat, config->attrName);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Wait to receive the result.
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcTlsNewSsl(HLT_Process *peerProcess, int ctxId)
{
int ret;
uint64_t cmdIndex;
CmdData expectCmdData = {0};
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsNewSsl");
// Constructing Commands
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, ctxId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Wait to receive the result.
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcTlsSetSsl(HLT_Process *peerProcess, int sslId, HLT_Ssl_Config *config)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsSetSsl");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%d|%d|%d",
g_cmdIndex, __FUNCTION__, sslId, config->sockFd, config->connType, config->connPort);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Wait to receive the result.
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcTlsListen(HLT_Process *peerProcess, int sslId)
{
int ret;
uint64_t acceptId;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
srcProcess = GetProcess();
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsListen");
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
acceptId = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
return acceptId;
}
int HLT_RpcTlsAccept(HLT_Process *peerProcess, int sslId)
{
int ret;
uint64_t acceptId;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
srcProcess = GetProcess();
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsAccept");
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
acceptId = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
return acceptId;
}
int HLT_RpcGetTlsListenResult(int acceptId)
{
int ret;
CmdData expectCmdData = {0};
ret = WaitResult(&expectCmdData, acceptId, "HLT_RpcTlsListen");
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], NULL, 10); // Convert to a decimal number
}
int HLT_RpcGetTlsAcceptResult(int acceptId)
{
int ret;
char *endPtr = NULL;
CmdData expectCmdData = {0};
ret = WaitResult(&expectCmdData, acceptId, "HLT_RpcTlsAccept");
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcTlsConnect(HLT_Process *peerProcess, int sslId)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsConnect");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result returned by the peer
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcTlsConnectUnBlock(HLT_Process *peerProcess, int sslId)
{
uint64_t cmdIndex;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsConnect");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
int ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, "HLT_RpcTlsConnect", sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
return cmdIndex;
}
int HLT_RpcGetTlsConnectResult(int cmdIndex)
{
int ret;
CmdData expectCmdData = {0};
// Waiting for the result returned by the peer
ret = WaitResult(&expectCmdData, cmdIndex, "HLT_RpcTlsConnect");
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcTlsRead(HLT_Process *peerProcess, int sslId, uint8_t *data, uint32_t bufSize, uint32_t *readLen)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsRead");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%u", g_cmdIndex, __FUNCTION__, sslId, bufSize);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result returned by the peer
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
// Parsing result
ret = atoi(expectCmdData.paras[0]);
if (ret == SUCCESS) {
*readLen = atoi(expectCmdData.paras[1]); // The first parameter indicates the read length.
memcpy_s(
data, bufSize, expectCmdData.paras[2], *readLen); // The second parameter indicates the content to be read.
}
return ret;
}
int HLT_RpcTlsReadUnBlock(HLT_Process *peerProcess, int sslId, uint8_t *data, uint32_t bufSize, uint32_t *readLen)
{
(void)data;
(void)readLen;
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsRead");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%u", g_cmdIndex, "HLT_RpcTlsRead", sslId, bufSize);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
return cmdIndex;
}
int HLT_RpcGetTlsReadResult(int cmdIndex, uint8_t *data, uint32_t bufSize, uint32_t *readLen)
{
int ret;
char *endPtr = NULL;
CmdData expectCmdData = {0};
ret = WaitResult(&expectCmdData, cmdIndex, "HLT_RpcTlsRead");
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
// Parsing result
ret = (int)strtol(expectCmdData.paras[0], &endPtr, 0);
if (ret == SUCCESS) {
*readLen = (int)strtol(expectCmdData.paras[1], &endPtr, 0); // The first parameter indicates the read length.
// The second parameter indicates the content to be read.
memcpy_s(data, bufSize, expectCmdData.paras[2], *readLen);
}
return ret;
}
int HLT_RpcTlsWrite(HLT_Process *peerProcess, int sslId, uint8_t *data, uint32_t bufSize)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsWrite");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%u|%s",
g_cmdIndex, __FUNCTION__, sslId, bufSize, data);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result returned by the peer
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcTlsWriteUnBlock(HLT_Process *peerProcess, int sslId, uint8_t *data, uint32_t bufSize)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsWrite");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%u|%s",
g_cmdIndex, "HLT_RpcTlsWrite", sslId, bufSize, data);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Do not wait for the result returned by the peer.
return cmdIndex;
}
int HLT_RpcGetTlsWriteResult(int cmdIndex)
{
int ret;
CmdData expectCmdData = {0};
ret = WaitResult(&expectCmdData, cmdIndex, "HLT_RpcTlsWrite");
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], NULL, 10); // Convert to a decimal number
}
int HLT_RpcTlsRenegotiate(HLT_Process *peerProcess, int sslId)
{
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
CmdData expectCmdData = {0};
srcProcess = GetProcess();
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsRenegotiate");
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcTlsVerifyClientPostHandshake(HLT_Process *peerProcess, int sslId)
{
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
CmdData expectCmdData = {0};
srcProcess = GetProcess();
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call RpcTlsVerifyClientPostHandshake");
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcDataChannelConnect(HLT_Process *peerProcess, DataChannelParam *channelParam)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcDataChannelConnect");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%d|%d", g_cmdIndex, __FUNCTION__,
channelParam->type, channelParam->port, channelParam->isBlock);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result returned by the peer
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcDataChannelBind(HLT_Process *peerProcess, DataChannelParam *channelParam)
{
int ret;
uint64_t bindId;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcDataChannelBind");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%d|%d|%d", g_cmdIndex, __FUNCTION__,
channelParam->type, channelParam->port, channelParam->isBlock, channelParam->bindFd);
dataBuf.dataLen = strlen(dataBuf.data);
bindId = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result returned by the peer
ret = WaitResult(&expectCmdData, bindId, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
channelParam->port = atoi(expectCmdData.paras[1]);
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcDataChannelAccept(HLT_Process *peerProcess, DataChannelParam *channelParam)
{
int ret;
uint64_t acceptId;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcDataChannelAccept");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%d|%d|%d", g_cmdIndex, __FUNCTION__,
channelParam->type, channelParam->port, channelParam->isBlock, channelParam->bindFd);
dataBuf.dataLen = strlen(dataBuf.data);
acceptId = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
return acceptId;
}
int HLT_RpcGetAcceptFd(int acceptId)
{
int ret;
CmdData expectCmdData = {0};
ret = WaitResult(&expectCmdData, acceptId, "HLT_RpcDataChannelAccept");
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcTlsRegCallback(HLT_Process *peerProcess, TlsCallbackType type)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsRegCallback");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, type);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcProcessExit(HLT_Process *peerProcess)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
srcProcess = GetProcess();
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcProcessExit");
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, peerProcess->connFd);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return SUCCESS;
}
int HLT_RpcTlsGetStatus(HLT_Process *peerProcess, int sslId)
{
ASSERT_RETURN(peerProcess != NULL, "HLT_RpcTlsGetStatus Parameter Error");
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsGetStatus");
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcTlsGetAlertFlag(HLT_Process *peerProcess, int sslId)
{
ASSERT_RETURN(peerProcess != NULL, "HLT_RpcTlsGetAlertFlag Parameter Error");
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcProcessExit");
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcTlsGetAlertLevel(HLT_Process *peerProcess, int sslId)
{
ASSERT_RETURN(peerProcess != NULL, "HLT_RpcTlsGetAlertLevel Parameter Error");
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsGetAlertLevel");
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcTlsGetAlertDescription(HLT_Process *peerProcess, int sslId)
{
ASSERT_RETURN(peerProcess != NULL, "HLT_RpcTlsGetAlertDescription Parameter Error");
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsGetAlertDescription");
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcTlsClose(HLT_Process *peerProcess, int sslId)
{
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
CmdData expectCmdData = {0};
srcProcess = GetProcess();
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsClose");
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcFreeResFormSsl(HLT_Process *peerProcess, int sslId)
{
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
CmdData expectCmdData = {0};
srcProcess = GetProcess();
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcFreeResFormSsl");
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcSctpClose(HLT_Process *peerProcess, int fd)
{
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
CmdData expectCmdData = {0};
srcProcess = GetProcess();
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcSctpClose");
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, fd);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol((const char *)expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcCloseFd(HLT_Process *peerProcess, int fd, int linkType)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
srcProcess = GetProcess();
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcCloseFd");
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%d", g_cmdIndex, __FUNCTION__, fd, linkType);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// The close fd does not need to wait for the result.
return ret;
}
int HLT_RpcTlsSetMtu(HLT_Process *peerProcess, int sslId, uint16_t mtu)
{
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
CmdData expectCmdData = {0};
srcProcess = GetProcess();
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsSetMtu");
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%d", g_cmdIndex, __FUNCTION__, sslId, mtu);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcTlsGetErrorCode(HLT_Process *peerProcess, int sslId)
{
ASSERT_RETURN(peerProcess != NULL, "HLT_RpcTlsGetStatus Parameter Error");
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsGetErrorCode");
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
} | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/rpc/src/hlt_rpc_func.c | C | unknown | 38,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 <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include "securec.h"
#include "hlt.h"
#include "handle_cmd.h"
#include "tls_res.h"
#include "logger.h"
#include "lock.h"
#include "hitls_error.h"
#include "hitls_type.h"
#include "tls.h"
#include "alert.h"
#include "hitls.h"
#include "common_func.h"
#include "sctp_channel.h"
#include "rpc_func.h"
#define HITLS_READBUF_MAXLEN (20 * 1024) /* 20K */
#define SUCCESS 0
#define ERROR (-1)
#define ASSERT_RETURN(condition) \
do { \
if (!(condition)) { \
LOG_ERROR("sprintf_s Error"); \
return ERROR; \
} \
} while (0)
RpcFunList g_rpcFuncList[] = {
#ifdef HITLS_TLS_FEATURE_PROVIDER
{"HLT_RpcProviderTlsNewCtx", RpcProviderTlsNewCtx},
#else
{"HLT_RpcTlsNewCtx", RpcTlsNewCtx},
#endif
{"HLT_RpcTlsSetCtx", RpcTlsSetCtx},
{"HLT_RpcTlsNewSsl", RpcTlsNewSsl},
{"HLT_RpcTlsSetSsl", RpcTlsSetSsl},
{"HLT_RpcTlsListen", RpcTlsListen},
{"HLT_RpcTlsAccept", RpcTlsAccept},
{"HLT_RpcTlsConnect", RpcTlsConnect},
{"HLT_RpcTlsRead", RpcTlsRead},
{"HLT_RpcTlsWrite", RpcTlsWrite},
{"HLT_RpcTlsRenegotiate", RpcTlsRenegotiate},
{"HLT_RpcDataChannelAccept", RpcDataChannelAccept},
{"HLT_RpcDataChannelConnect", RpcDataChannelConnect},
{"HLT_RpcProcessExit", RpcProcessExit},
{"HLT_RpcTlsRegCallback", RpcTlsRegCallback},
{"HLT_RpcTlsGetStatus", RpcTlsGetStatus},
{"HLT_RpcTlsGetAlertFlag", RpcTlsGetAlertFlag},
{"HLT_RpcTlsGetAlertLevel", RpcTlsGetAlertLevel},
{"HLT_RpcTlsGetAlertDescription", RpcTlsGetAlertDescription},
{"HLT_RpcTlsClose", RpcTlsClose},
{"HLT_RpcFreeResFormSsl", RpcFreeResFormSsl},
{"HLT_RpcCloseFd", RpcCloseFd},
{"HLT_RpcTlsSetMtu", RpcTlsSetMtu},
{"HLT_RpcTlsGetErrorCode", RpcTlsGetErrorCode},
{"HLT_RpcDataChannelBind", RpcDataChannelBind},
{"HLT_RpcTlsVerifyClientPostHandshake", RpcTlsVerifyClientPostHandshake},
};
RpcFunList *GetRpcFuncList(void)
{
return g_rpcFuncList;
}
int GetRpcFuncNum(void)
{
return sizeof(g_rpcFuncList) / sizeof(g_rpcFuncList[0]);
}
#ifdef HITLS_TLS_FEATURE_PROVIDER
/**
* Parse the provider string in format "name1,fmt1:name2,fmt2:...:nameN,fmtN"
*/
static int ParseProviderString(const char *providerStr, char (*providerNames)[MAX_PROVIDER_NAME_LEN],
int32_t *providerLibFmts, int32_t *providerCnt)
{
if (providerStr == NULL) {
LOG_DEBUG("Provider names is NULL");
return SUCCESS;
}
if (providerStr == NULL || providerLibFmts == NULL || providerCnt == NULL) {
LOG_ERROR("Invalid input parameters");
return ERROR;
}
int count = 1;
const char *ptr = providerStr;
while (*ptr) {
if (*ptr == ':') {
count++;
}
ptr++;
}
*providerCnt = count;
if (count == 0) {
LOG_ERROR("Provider string is empty");
return SUCCESS;
}
char *tempStr = strdup(providerStr);
if (tempStr == NULL) {
LOG_ERROR("Failed to duplicate provider string");
return ERROR;
}
char *saveptr1 = NULL;
char *saveptr2 = NULL;
char *token = strtok_r(tempStr, ":", &saveptr1);
int i = 0;
while (token != NULL && i < count) {
char *name = strtok_r(token, ",", &saveptr2);
char *fmt = strtok_r(NULL, ",", &saveptr2);
if (name == NULL || fmt == NULL) {
LOG_ERROR("Invalid provider format");
free(tempStr);
return ERROR;
}
if (strcpy_s(providerNames[i], MAX_PROVIDER_NAME_LEN, name) != EOK) {
LOG_ERROR("Failed to allocate memory for provider name");
free(tempStr);
return ERROR;
}
providerLibFmts[i] = atoi(fmt);
token = strtok_r(NULL, ":", &saveptr1);
i++;
}
free(tempStr);
return SUCCESS;
}
int RpcProviderTlsNewCtx(CmdData *cmdData)
{
int id;
TLS_VERSION tlsVersion;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
tlsVersion = atoi(cmdData->paras[0]);
char *providerNames = strlen(cmdData->paras[2]) > 0 ? cmdData->paras[2] : NULL;
char *attrName = strlen(cmdData->paras[3]) > 0 ? cmdData->paras[3] : NULL;
char *providerPath = strlen(cmdData->paras[4]) > 0 ? cmdData->paras[4] : NULL;
char parsedProviderNames[MAX_PROVIDER_COUNT][MAX_PROVIDER_NAME_LEN] = {0};
int32_t providerLibFmts[MAX_PROVIDER_COUNT] = {0};
int32_t providerCnt = 0;
if (ParseProviderString(providerNames, parsedProviderNames, providerLibFmts, &providerCnt) != SUCCESS) {
LOG_ERROR("Failed to parse provider string");
id = ERROR;
goto EXIT;
}
// Invoke the corresponding function.
void *ctx = HLT_TlsProviderNewCtx(providerPath, parsedProviderNames, providerLibFmts, providerCnt, attrName,
tlsVersion);
if (ctx == NULL) {
LOG_ERROR("HLT_TlsProviderNewCtx Return NULL");
id = ERROR;
goto EXIT;
}
// Insert to CTX linked list
id = InsertCtxToList(ctx);
EXIT:
// Return Result
if (sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, id) <= 0) {
return ERROR;
}
return SUCCESS;
}
#endif
int RpcTlsNewCtx(CmdData *cmdData)
{
int id;
TLS_VERSION tlsVersion;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
tlsVersion = atoi(cmdData->paras[0]);
// Invoke the corresponding function.
void* ctx = HLT_TlsNewCtx(tlsVersion);
if (ctx == NULL) {
LOG_ERROR("HLT_TlsNewCtx Return NULL");
id = ERROR;
goto EXIT;
}
// Insert to CTX linked list
id = InsertCtxToList(ctx);
EXIT:
// Return Result
if (sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, id) <= 0) {
return ERROR;
}
return SUCCESS;
}
int RpcTlsSetCtx(CmdData *cmdData)
{
int ret;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
// Find the corresponding CTX.
ResList *ctxList = GetCtxList();
int ctxId = atoi(cmdData->paras[0]);
void *ctx = GetTlsResFromId(ctxList, ctxId);
if (ctx == NULL) {
LOG_ERROR("GetResFromId Error");
ret = ERROR;
goto EXIT;
}
// Configurations related to parsing
HLT_Ctx_Config ctxConfig = {0};
ret = ParseCtxConfigFromString(cmdData->paras, &ctxConfig);
if (ret != SUCCESS) {
LOG_ERROR("ParseCtxConfigFromString Error");
ret = ERROR;
goto EXIT;
}
// Configure the data
ret = HLT_TlsSetCtx(ctx, &ctxConfig);
EXIT:
// Return the result
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsNewSsl(CmdData *cmdData)
{
int id, ret;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
// Invoke the corresponding function.
ResList *ctxList = GetCtxList();
int ctxId = atoi(cmdData->paras[0]);
void *ctx = GetTlsResFromId(ctxList, ctxId);
if (ctx == NULL) {
LOG_ERROR("Not Find Ctx");
id = ERROR;
goto EXIT;
}
void *ssl = HLT_TlsNewSsl(ctx);
if (ssl == NULL) {
LOG_ERROR("HLT_TlsNewSsl Return NULL");
id = ERROR;
goto EXIT;
}
// Insert to the SSL linked list.
id = InsertSslToList(ctx, ssl);
EXIT:
// Return the result.
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, id);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsSetSsl(CmdData *cmdData)
{
int ret;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
int sslId = atoi(cmdData->paras[0]);
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl == NULL) {
LOG_ERROR("Not Find Ssl");
ret = ERROR;
goto EXIT;
}
HLT_Ssl_Config sslConfig = {0};
sslConfig.sockFd = atoi(cmdData->paras[1]); // The first parameter indicates the FD value.
sslConfig.connType = atoi(cmdData->paras[2]); // The second parameter indicates the link type.
// The third parameter of indicates the Ctrl command that needs to register the hook.
sslConfig.connPort = atoi(cmdData->paras[3]);
ret = HLT_TlsSetSsl(ssl, &sslConfig);
EXIT:
// Return the result.
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsListen(CmdData *cmdData)
{
int ret;
int sslId;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
sslId = strtol(cmdData->paras[0], NULL, 10); // Convert to a decimal number
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl == NULL) {
LOG_ERROR("Not Find Ssl");
ret = ERROR;
goto EXIT;
}
ret = HLT_TlsListenBlock(ssl);
EXIT:
// Return the result
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsAccept(CmdData *cmdData)
{
int ret;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
int sslId = atoi(cmdData->paras[0]);
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl == NULL) {
LOG_ERROR("Not Find Ssl");
ret = ERROR;
goto EXIT;
}
// If there is a problem, the user must use non-blocking, and the remote call must use blocking
ret = HLT_TlsAcceptBlock(ssl);
EXIT:
// Return the result
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsConnect(CmdData *cmdData)
{
int ret;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
int sslId = atoi(cmdData->paras[0]);
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl == NULL) {
LOG_ERROR("Not Find Ssl");
ret = ERROR;
goto EXIT;
}
ret = HLT_TlsConnect(ssl);
EXIT:
// Return the result
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsRead(CmdData *cmdData)
{
int ret = SUCCESS;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
int sslId = atoi(cmdData->paras[0]);
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl == NULL) {
LOG_ERROR("Not Find Ssl");
ret = ERROR;
goto ERR;
}
int dataLen = atoi(cmdData->paras[1]);
uint32_t readLen = 0;
if (dataLen == 0) {
LOG_ERROR("dataLen is 0");
ret = ERROR;
goto ERR;
}
uint8_t *data = (uint8_t *)calloc(1u, dataLen);
if (data == NULL) {
LOG_ERROR("Calloc Error");
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
}
(void)memset_s(data, dataLen, 0, dataLen);
ret = HLT_TlsRead(ssl, data, dataLen, &readLen);
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d|%u|%s",
cmdData->id, cmdData->funcId, ret, readLen, data);
free(data);
return SUCCESS;
ERR:
// Return the result
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d|", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsWrite(CmdData *cmdData)
{
int ret;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
int sslId = atoi(cmdData->paras[0]);
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl == NULL) {
LOG_ERROR("Not Find Ssl");
ret = ERROR;
goto ERR;
}
int dataLen = atoi(cmdData->paras[1]); // The first parameter indicates the data length.
if (dataLen == 0) {
LOG_ERROR("dataLen is 0");
ret = ERROR;
goto ERR;
}
uint8_t *data = (uint8_t *)calloc(1u, dataLen);
if (data == NULL) {
LOG_ERROR("Calloc Error");
ret = ERROR;
goto ERR;
}
if (dataLen >= CONTROL_CHANNEL_MAX_MSG_LEN) {
free(data);
goto ERR;
}
// The second parameter of indicates the content of the write data.
ret = memcpy_s(data, dataLen, cmdData->paras[2], dataLen);
if (ret != EOK) {
LOG_ERROR("memcpy_s Error");
free(data);
goto ERR;
}
ret = HLT_TlsWrite(ssl, data, dataLen);
free(data);
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
ERR:
// Return the result
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsRenegotiate(CmdData *cmdData)
{
int ret = ERROR;
ResList *sslList = GetSslList();
int sslId = (int)strtol(cmdData->paras[0], NULL, 10); // Convert to a decimal number
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl == NULL) {
LOG_ERROR("Not Find Ssl");
goto EXIT;
}
ret = HLT_TlsRenegotiate(ssl);
EXIT:
// Return the result
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsVerifyClientPostHandshake(CmdData *cmdData)
{
int ret = ERROR;
ResList *sslList = GetSslList();
int sslId = (int)strtol(cmdData->paras[0], NULL, 10); // Convert to a decimal number
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl == NULL) {
LOG_ERROR("Not Find Ssl");
goto EXIT;
}
ret = HLT_TlsVerifyClientPostHandshake(ssl);
EXIT:
// Return Result
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcProcessExit(CmdData *cmdData)
{
int ret;
// If 1 is returned, the process needs to exit
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, getpid());
ASSERT_RETURN(ret > 0);
return 1;
}
int RpcDataChannelAccept(CmdData *cmdData)
{
int sockFd, ret;
DataChannelParam channelParam;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
(void)memset_s(&channelParam, sizeof(DataChannelParam), 0, sizeof(DataChannelParam));
channelParam.type = atoi(cmdData->paras[0]);
channelParam.port = atoi(cmdData->paras[1]); // The first parameter of indicates the port number
channelParam.isBlock = atoi(cmdData->paras[2]); // The second parameter of indicates whether to block
channelParam.bindFd = atoi(cmdData->paras[3]); // The third parameter of indicates whether the cis blocked.
// Invoke the blocking interface
sockFd = RunDataChannelAccept(&channelParam);
// Return the result.
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, sockFd);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcDataChannelBind(CmdData *cmdData)
{
int sockFd, ret;
DataChannelParam channelParam;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
(void)memset_s(&channelParam, sizeof(DataChannelParam), 0, sizeof(DataChannelParam));
channelParam.type = atoi(cmdData->paras[0]);
channelParam.port = atoi(cmdData->paras[1]); // The first parameter of indicates the port number
channelParam.isBlock = atoi(cmdData->paras[2]); // The second parameter of indicates whether to block
channelParam.bindFd = atoi(cmdData->paras[3]); // The third parameter of indicates whether the cis blocked.
// Invoke the blocking interface
sockFd = RunDataChannelBind(&channelParam);
// Return the result.
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d|%d", cmdData->id, cmdData->funcId,
sockFd, channelParam.port);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcDataChannelConnect(CmdData *cmdData)
{
int ret, sockFd;
DataChannelParam channelParam;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
(void)memset_s(&channelParam, sizeof(DataChannelParam), 0, sizeof(DataChannelParam));
channelParam.type = atoi(cmdData->paras[0]);
channelParam.port = atoi(cmdData->paras[1]); // The first parameter of indicates the port number.
channelParam.isBlock = atoi(cmdData->paras[2]); // The second parameter of indicates whether the is blocked
sockFd = HLT_DataChannelConnect(&channelParam);
// Return the result.
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, sockFd);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsRegCallback(CmdData *cmdData)
{
int ret;
TlsCallbackType type;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
type = atoi(cmdData->paras[0]);
// Invoke the corresponding function
ret = HLT_TlsRegCallback(type);
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsGetStatus(CmdData *cmdData)
{
int ret, sslId;
uint32_t sslState = 0;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
sslId = atoi(cmdData->paras[0]);
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl != NULL) {
sslState = ((HITLS_Ctx *)ssl)->state;
}
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%u", cmdData->id, cmdData->funcId, sslState);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsGetAlertFlag(CmdData *cmdData)
{
int ret, sslId;
ALERT_Info alertInfo = {0};
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
sslId = atoi(cmdData->paras[0]);
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl != NULL) {
ALERT_GetInfo(ssl, &alertInfo);
}
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d",
cmdData->id, cmdData->funcId, alertInfo.flag);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsGetAlertLevel(CmdData *cmdData)
{
int ret, sslId;
ALERT_Info alertInfo = {0};
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
sslId = atoi(cmdData->paras[0]);
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl != NULL) {
ALERT_GetInfo(ssl, &alertInfo);
}
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d",
cmdData->id, cmdData->funcId, alertInfo.level);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsGetAlertDescription(CmdData *cmdData)
{
int ret, sslId;
ALERT_Info alertInfo = {0};
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
sslId = atoi(cmdData->paras[0]);
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl != NULL) {
ALERT_GetInfo(ssl, &alertInfo);
}
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d",
cmdData->id, cmdData->funcId, alertInfo.description);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsClose(CmdData *cmdData)
{
int ret, sslId;
void *ssl = NULL;
char *endPtr = NULL;
ASSERT_RETURN(memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result)) == EOK);
ResList *sslList = GetSslList();
sslId = (int)strtol(cmdData->paras[0], &endPtr, 0);
ssl = GetTlsResFromId(sslList, sslId);
ASSERT_RETURN(ssl != NULL);
ret = HLT_TlsClose(ssl);
// Return the result
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcFreeResFormSsl(CmdData *cmdData)
{
int ret, sslId;
void *ssl = NULL;
char *endPtr = NULL;
ASSERT_RETURN(memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result)) == EOK);
ResList *sslList = GetSslList();
sslId = (int)strtol(cmdData->paras[0], &endPtr, 0);
ssl = GetTlsResFromId(sslList, sslId);
ASSERT_RETURN(ssl != NULL);
ret = HLT_FreeResFromSsl(ssl);
// Return the result
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcCloseFd(CmdData *cmdData)
{
int ret, fd, linkType;
char *endPtr = NULL;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
fd = (int)strtol(cmdData->paras[0], &endPtr, 0);
linkType = (int)strtol(cmdData->paras[1], &endPtr, 0);
ret = SUCCESS;
HLT_CloseFd(fd, linkType);
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsSetMtu(CmdData *cmdData)
{
int ret, sslId;
uint16_t mtu;
void *ssl = NULL;
char *endPtr = NULL;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
sslId = (int)strtol(cmdData->paras[0], &endPtr, 0);
mtu = (int)strtol(cmdData->paras[1], &endPtr, 0);
ssl = GetTlsResFromId(sslList, sslId);
ASSERT_RETURN(ssl != NULL);
ret = HLT_TlsSetMtu(ssl, mtu);
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsGetErrorCode(CmdData *cmdData)
{
int sslId;
int errorCode;
void *ssl = NULL;
char *endPtr = NULL;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
sslId = (int)strtol(cmdData->paras[0], &endPtr, 0);
ssl = GetTlsResFromId(sslList, sslId);
ASSERT_RETURN(ssl != NULL);
errorCode = HLT_TlsGetErrorCode(ssl);
int ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, errorCode);
ASSERT_RETURN(ret > 0);
return SUCCESS;
} | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/rpc/src/rpc_func.c | C | unknown | 23,838 |
/*
* 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.
*/
#ifndef CONTROL_CHANNEL_H
#define CONTROL_CHANNEL_H
#include "channel_res.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Initialize the control channel
*/
int ControlChannelInit(ControlChannelRes *info);
/**
* @brief Close the control channel
*/
int ControlChannelClose(ControlChannelRes *info);
/**
* @brief Read data from the control channel
*/
int ControlChannelRead(int32_t sockFd, ControlChannelBuf *dataBuf);
/**
* @brief Write data to the control channel
*/
int ControlChannelWrite(int32_t sockFd, char *peerDomainPath, ControlChannelBuf *dataBuf);
/**
* @brief Control channel initiation
*/
int ControlChannelConnect(ControlChannelRes *info);
/**
* @brief The control channel waits for a connection
*/
int ControlChannelAccept(ControlChannelRes *info);
#ifdef __cplusplus
}
#endif
#endif // CONTROL_CHANNEL_H | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/transfer/include/control_channel.h | C | unknown | 1,395 |
/*
* 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.
*/
#ifndef SCTP_CHANNEL_H
#define SCTP_CHANNEL_H
#include <netinet/in.h>
#include <stdint.h>
#include "hitls.h"
#include "bsl_uio.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Initiate an SCTP connection
*/
int32_t SctpConnect(char *targetIP, int32_t targetPort, bool isBlock);
/**
* @brief Waiting for SCTP connection
*/
int32_t SctpAccept(char *ip, int listenFd, bool isBlock);
/**
* @brief Disable the SCTP connection
*/
void SctpClose(int fd);
/**
* @brief Obtain the default SCTP method
*/
BSL_UIO_Method *SctpGetDefaultMethod(void);
/**
* @brief Set the Ctrl command for registering the hook
*/
void SetNeedCbSctpCtrlCmd(int cmd);
int32_t SctpBind(int port);
// Default SCTP connection method
int32_t SctpDefaultWrite(BSL_UIO *uio, const void *buf, uint32_t len, uint32_t *writeLen);
int32_t SctpDefaultRead(BSL_UIO *uio, void *buf, uint32_t len, uint32_t *readLen);
int32_t SctpDefaultCtrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *param);
// Change the SCTP connection of the message
int32_t SctpFrameWrite(BSL_UIO *uio, const void *buf, uint32_t len, uint32_t *writeLen);
int32_t SctpFrameRead(BSL_UIO *uio, void *buf, uint32_t len, uint32_t *readLen);
#ifdef __cplusplus
}
#endif
#endif // SCTP_CHANNEL_H
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/transfer/include/sctp_channel.h | C | unknown | 1,797 |
/*
* 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.
*/
#ifndef SOCKET_COMMON_H
#define SOCKET_COMMON_H
#include <stdint.h>
#include "hlt_type.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Sock Set the block
*/
int32_t SetBlockMode(int32_t sd, bool isBlock);
/**
* @brief Check whether there are fatal I/O errors
*/
bool IsNonFatalErr(int32_t err);
/**
* @brief Set the message injection parameter, which must be used with the CleantFrameHandle
*/
int32_t SetFrameHandle(HLT_FrameHandle *frameHandle);
/**
* @brief Clear message injection parameters
*/
void CleanFrameHandle(void);
/**
* @brief Obtain message injection parameters
*/
HLT_FrameHandle *GetFrameHandle(void);
/**
* @brief Obtain the newbuf by parsing the buf. Constraint: The input parameter of packLen cannot be empty
*/
uint8_t *GetNewBuf(const void *buf, uint32_t len, uint32_t *packLen);
/**
* @brief Release the newbuf applied by GetNewBuf
*/
void FreeNewBuf(void *newBuf);
#ifdef __cplusplus
}
#endif
#endif // SOCKET_COMMON_H | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/transfer/include/socket_common.h | C | unknown | 1,527 |
/*
* 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.
*/
#ifndef TCP_CHANNEL_H
#define TCP_CHANNEL_H
#include <stdbool.h>
#ifdef __cplusplus
extern "C" {
#endif
/* Connects to the peer and returns a socket descriptor. */
int TcpConnect(const char *targetIP, const int targetPort);
/* listen */
int TcpBind(const int localPort);
/* accept */
int TcpAccept(char *ip, int listenFd, bool isBlock, bool needClose);
/* write */
int32_t TcpFrameWrite(BSL_UIO *uio, const void *buf, uint32_t len, uint32_t *writeLen);
/*
* When the Windows TCP server is used, the socket that is closed accept cannot be cleaned up.
* Otherwise, the next accept operation will fail
*/
void TcpClose(int sd);
/* Default TCP method based on Linux */
void *TcpGetDefaultMethod(void);
#ifdef __cplusplus
}
#endif
#endif // TCP_CHANNEL_H
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/transfer/include/tcp_channel.h | C | unknown | 1,308 |
/*
* 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.
*/
#ifndef UDP_CHANNEL_H
#define UDP_CHANNEL_H
#include <stdbool.h>
#ifdef __cplusplus
extern "C" {
#endif
/* Connects to the peer and returns a socket descriptor. */
int UdpConnect(const char *targetIP, const int targetPort);
/* listen */
int UdpBind(const int localPort);
/* accept */
int UdpAccept(char *ip, int listenFd, bool isBlock, bool needClose);
/* write */
int32_t UdpFrameWrite(BSL_UIO *uio, const void *buf, uint32_t len, uint32_t *writeLen);
void UdpClose(int sd);
/* Default UDP method based on Linux */
void *UdpGetDefaultMethod(void);
#ifdef __cplusplus
}
#endif
#endif // UDP_CHANNEL_H
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/transfer/include/udp_channel.h | C | unknown | 1,156 |
/*
* 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 <sys/time.h>
#include "channel_res.h"
#include "logger.h"
#include "securec.h"
#define SUCCESS 0
#define ERROR (-1)
int ControlChannelInit(ControlChannelRes *channelInfo)
{
int len;
int sockFd;
struct timeval timeOut;
unlink(channelInfo->srcDomainPath);
// Create a socket.
sockFd = socket(AF_UNIX, SOCK_DGRAM, 0);
if (sockFd < 0) {
LOG_ERROR("Get SockFd Error");
return ERROR;
}
// Set the non-blocking mode.
timeOut.tv_sec = 0; // Second
timeOut.tv_usec = 10000; // 10000 microseconds
if (setsockopt(sockFd, SOL_SOCKET, SO_RCVTIMEO, &timeOut, sizeof(timeOut)) == -1) {
LOG_ERROR("Setsockopt Fail");
return ERROR;
}
// Binding ports.
len = offsetof(struct sockaddr_un, sun_path) + strlen(channelInfo->srcDomainPath) + 1;
if (bind(sockFd, (struct sockaddr *)&(channelInfo->srcAddr), len) < 0) {
LOG_ERROR("Bind Error\n");
return ERROR;
}
channelInfo->sockFd = sockFd;
return 0;
}
int ControlChannelAcept(ControlChannelRes *channelInfo)
{
(void)channelInfo;
return SUCCESS;
}
int ControlChannelConnect(ControlChannelRes *channelInfo)
{
(void)channelInfo;
return SUCCESS;
}
int ControlChannelWrite(int32_t sockFd, char *peerDomainPath, ControlChannelBuf *dataBuf)
{
int ret;
uint32_t dataLen;
uint32_t addrLen;
struct sockaddr_un peerAddr;
peerAddr.sun_family = AF_UNIX;
ret = strcpy_s(peerAddr.sun_path, strlen(peerDomainPath) + 1, peerDomainPath);
if (ret != EOK) {
LOG_ERROR("strcpy_s Error");
return ERROR;
}
addrLen = offsetof(struct sockaddr_un, sun_path) + strlen(peerDomainPath) + 1;
dataLen = sendto(sockFd, dataBuf->data, dataBuf->dataLen, 0, (struct sockaddr *)&peerAddr, addrLen);
if (dataLen != dataBuf->dataLen) {
LOG_ERROR("Send Msg Error: %s\n", dataBuf->data);
return ERROR;
}
return SUCCESS;
}
int ControlChannelRead(int32_t sockFd, ControlChannelBuf *dataBuf)
{
struct sockaddr_un peerAddr;
int dataLen;
socklen_t addrLen = sizeof(struct sockaddr_un);
(void)memset_s(dataBuf->data, CONTROL_CHANNEL_MAX_MSG_LEN, 0, CONTROL_CHANNEL_MAX_MSG_LEN);
dataLen = recvfrom(sockFd, dataBuf->data, CONTROL_CHANNEL_MAX_MSG_LEN, 0,
(struct sockaddr *)(&peerAddr), &(addrLen));
if (dataLen < 0) {
return ERROR;
}
dataBuf->dataLen = dataLen;
return SUCCESS;
} | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/transfer/src/control_channel.c | C | unknown | 3,018 |
/*
* 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 <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include "hitls_error.h"
#include "hitls_type.h"
#include "hitls.h"
#include "tls.h"
#include "hs_ctx.h"
#include "bsl_errno.h"
#include "uio_base.h"
#include "frame_msg.h"
#include "logger.h"
#include "hlt_type.h"
#define SUCCESS 0
#define ERROR (-1)
#define MAX_LEN (20 * 1024)
/* set block mode. */
int32_t SetBlockMode(int32_t sd, bool isBlock)
{
if (isBlock) {
LOG_DEBUG("Socket Set Block Mode");
int flag;
flag = fcntl(sd, F_GETFL, 0);
flag &= ~O_NONBLOCK;
if (fcntl(sd, F_SETFL, flag) < 0) {
LOG_ERROR("fcntl fail");
return ERROR;
}
} else {
LOG_DEBUG("Socket Set Unblock Mode");
int flag;
flag = fcntl(sd, F_GETFL, 0);
flag |= O_NONBLOCK;
if (fcntl(sd, F_SETFL, flag) < 0) {
LOG_ERROR("fcntl fail");
return ERROR;
}
}
return SUCCESS;
}
/**
* @brief Check whether there are fatal I/O errors
*
* @param err [IN] Error type
*
* @return true :A fatal error occurs
* false:No fatal error occurs
*/
bool IsNonFatalErr(int32_t err)
{
bool ret = true;
/** @alias Check whether err is a fatal error and modify ret */
switch (err) {
#if defined(ENOTCONN)
case ENOTCONN:
#endif
#ifdef EINTR
case EINTR:
#endif
#ifdef EINPROGRESS
case EINPROGRESS:
#endif
#ifdef EWOULDBLOCK
#if !defined(WSAEWOULDBLOCK) || WSAEWOULDBLOCK != EWOULDBLOCK
case EWOULDBLOCK:
#endif
#endif
#ifdef EAGAIN
#if EWOULDBLOCK != EAGAIN
case EAGAIN:
#endif
#endif
#ifdef EALREADY
case EALREADY:
#endif
#ifdef EPROTO
case EPROTO:
#endif
#ifdef EMSGSIZE
case EMSGSIZE:
#endif
ret = true;
break;
default:
ret = false;
break;
}
return ret;
}
static HLT_FrameHandle g_frameHandle;
int32_t SetFrameHandle(HLT_FrameHandle *frameHandle)
{
if (frameHandle == NULL || frameHandle->ctx == NULL) {
return HITLS_NULL_INPUT;
}
g_frameHandle.ctx = frameHandle->ctx;
g_frameHandle.frameCallBack = frameHandle->frameCallBack;
g_frameHandle.userData = frameHandle->userData;
g_frameHandle.expectHsType = frameHandle->expectHsType;
g_frameHandle.expectReType = frameHandle->expectReType;
g_frameHandle.ioState = frameHandle->ioState;
g_frameHandle.pointType = frameHandle->pointType;
g_frameHandle.method.uioWrite = frameHandle->method.uioWrite;
g_frameHandle.method.uioRead = frameHandle->method.uioRead;
g_frameHandle.method.uioCtrl = frameHandle->method.uioCtrl;
return HITLS_SUCCESS;
}
void CleanFrameHandle(void)
{
g_frameHandle.ctx = NULL;
g_frameHandle.frameCallBack = NULL;
g_frameHandle.userData = NULL;
g_frameHandle.expectHsType = 0;
g_frameHandle.expectReType = 0;
g_frameHandle.ioState = 0;
g_frameHandle.pointType = 0;
g_frameHandle.method.uioWrite = NULL;
g_frameHandle.method.uioRead = NULL;
g_frameHandle.method.uioCtrl = NULL;
}
HLT_FrameHandle *GetFrameHandle(void)
{
return &g_frameHandle;
}
/* Obtain the frameType. The input parameters frameHandle and frameType must not be empty */
static int32_t GetFrameType(HLT_FrameHandle *frameHandle, FRAME_Type *frameType)
{
if (frameHandle->ctx == NULL) {
return HITLS_NULL_INPUT;
}
TLS_Ctx *tmpCtx = (TLS_Ctx *)frameHandle->ctx;
frameType->versionType = tmpCtx->negotiatedInfo.version > 0 ?
tmpCtx->negotiatedInfo.version : tmpCtx->config.tlsConfig.maxVersion;
frameType->keyExType = tmpCtx->hsCtx->kxCtx->keyExchAlgo;
frameType->recordType = frameHandle->expectReType;
frameType->handshakeType = frameHandle->expectHsType;
return HITLS_SUCCESS;
}
/* Verify whether the parsed msg meets the requirements. Restrict the msg input parameter */
static bool CheckHandleType(FRAME_Msg *msg)
{
if (msg->recType.data != REC_TYPE_HANDSHAKE) {
if ((int32_t)msg->recType.data == g_frameHandle.expectReType) {
return true;
}
} else {
if ((int32_t)msg->recType.data == g_frameHandle.expectReType &&
(int32_t)msg->body.hsMsg.type.data == g_frameHandle.expectHsType) {
return true;
}
}
return false;
}
/* Release the newbuf */
void FreeNewBuf(void *newBuf)
{
if (newBuf != NULL) {
free(newBuf);
newBuf = NULL;
}
}
/* Obtain the newbuf by parsing the buffer. The input parameter of the packageLen constraint is not empty */
uint8_t *GetNewBuf(const void *buf, uint32_t len, uint32_t *packLen)
{
uint32_t packLenTmp = 0;
/* Obtain the frameType */
FRAME_Type frameType = { 0 };
if (GetFrameType(&g_frameHandle, &frameType) != HITLS_SUCCESS) {
return NULL;
}
/* Unpack the buffer into the msg structure */
uint32_t parseLen = 0;
FRAME_Msg msg = { 0 };
uint32_t offset = 0;
uint8_t *newBuf = (uint8_t *)calloc(MAX_LEN, sizeof(uint8_t));
uint32_t newOffset = 0;
while (offset < *packLen) {
/* Currently, encryption and decryption are not performed.
* Therefore, the return value is not determined
* because the encrypted messages such as finished messages will fail to be parsed
*/
(void)FRAME_ParseMsg(&frameType, &((uint8_t*)buf)[offset], len - offset, &msg, &parseLen);
if (CheckHandleType(&msg)) {
if (g_frameHandle.ioState == EXP_IO_BUSY) {
FRAME_CleanMsg(&frameType, &msg);
/* Set I/O to busy */
*packLen = 0;
FreeNewBuf(newBuf);
return NULL;
}
if (g_frameHandle.userData == NULL) {
g_frameHandle.userData = (void *)&frameType;
}
g_frameHandle.frameCallBack(&msg, g_frameHandle.userData);
if (g_frameHandle.userData == (void *)&frameType) {
g_frameHandle.userData = NULL;
}
/* Pack the newly constructed msg into a buffer */
if (FRAME_PackMsg(&frameType, &msg, &newBuf[newOffset], MAX_LEN - newOffset, &packLenTmp) != HITLS_SUCCESS) {
FRAME_CleanMsg(&frameType, &msg);
FreeNewBuf(newBuf);
return NULL;
}
newOffset += packLenTmp;
} else {
memcpy_s(&newBuf[newOffset], MAX_LEN - newOffset, &((uint8_t*)buf)[offset], parseLen);
newOffset += parseLen;
}
offset += parseLen;
FRAME_CleanMsg(&frameType, &msg);
}
/* Check whether the package is reassembled. If not, *packLen should not be changed */
if (packLenTmp == 0) {
FreeNewBuf(newBuf);
return NULL;
}
*packLen = newOffset;
return newBuf;
} | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/transfer/src/socket_common.c | C | unknown | 7,504 |
/*
* 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <errno.h>
#include "hitls_build.h"
#ifdef HITLS_BSL_UIO_TCP
#include "securec.h"
#include "bsl_uio.h"
#include "hitls_error.h"
#include "hitls_type.h"
#include "hitls.h"
#include "tls.h"
#include "hs_ctx.h"
#include "bsl_errno.h"
#include "uio_base.h"
#include "logger.h"
#include "hlt_type.h"
#include "socket_common.h"
#include "tcp_channel.h"
/**
* @brief Connects to the peer and returns a socket descriptor.
*
* @return -1 is returned when an error occurs
* */
int TcpConnect(const char *targetIP, const int targetPort)
{
(void)targetIP;
int fd;
struct sockaddr_in serverAddr;
// Create a socket
if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
LOG_ERROR("socket() fail\n");
return -1;
}
int option = 1;
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option)) < 0) {
close(fd);
LOG_ERROR("setsockopt() fail\n");
return -1;
}
struct linger so_linger;
so_linger.l_onoff = true;
so_linger.l_linger = 0;
if (setsockopt(fd, SOL_SOCKET, SO_LINGER, &so_linger, sizeof(so_linger)) < 0) {
close(fd);
LOG_ERROR("setsockopt() linger fail\n");
return -1;
}
// Set the protocol and port number
(void)memset_s(&serverAddr, sizeof(serverAddr), 0, sizeof(serverAddr));
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(targetPort);
// Set the IP address
serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
// Connection
int index = 0;
const int maxConnTime = 8000;
do {
if (connect(fd, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) == 0) {
break;
}
usleep(1000); // Delay 100000 us
LOG_ERROR("Connect error try again\n");
} while (index++ < maxConnTime);
if (index >= maxConnTime) {
close(fd);
LOG_ERROR("Connect error\n");
return -1;
}
SetBlockMode(fd, false);
return fd;
}
int TcpBind(const int localPort)
{
int lisentFd, ret;
struct sockaddr_in serverAddr;
// Create a socket
if ((lisentFd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
LOG_ERROR("create socket fail\n");
return -1;
}
int option = 1;
if (setsockopt(lisentFd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option)) < 0) {
close(lisentFd);
LOG_ERROR("setsockopt fail\n");
return -1;
}
struct linger so_linger;
so_linger.l_onoff = true;
so_linger.l_linger = 0;
if (setsockopt(lisentFd, SOL_SOCKET, SO_LINGER, &so_linger, sizeof(so_linger)) < 0) {
close(lisentFd);
LOG_ERROR("setsockopt() linger fail\n");
return -1;
}
// Set the protocol and port number
(void)memset_s(&serverAddr, sizeof(serverAddr), 0, sizeof(serverAddr));
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(localPort);
serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
uint32_t tryNum = 0;
LOG_DEBUG("bind socket ing...\n");
do {
ret = bind(lisentFd, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
usleep(1000); // 1000 microseconds, that is, 1 ms
tryNum++;
} while ((ret != 0) && (tryNum < 8000)); // 8000: indicates that the binding attempt is 8 seconds
if (ret != 0) {
close(lisentFd);
LOG_DEBUG("bind socket fail\n");
return -1;
}
if (listen(lisentFd, 5) != 0) { // core should queue for the corresponding socket5
close(lisentFd);
LOG_DEBUG("listen socket fail\n");
return -1;
}
SetBlockMode(lisentFd, false);
return lisentFd;
}
int TcpAccept(char *ip, int listenFd, bool isBlock, bool needClose)
{
(void)ip;
int32_t ret;
struct sockaddr_in clientAddr;
unsigned int len = sizeof(struct sockaddr_in);
int fd = -1;
uint32_t tryNum = 0;
LOG_DEBUG("tcp Accept ing...\n");
do {
fd = accept(listenFd, (struct sockaddr *)&clientAddr, &len);
tryNum++;
usleep(1000); // 1000 microseconds, that is, 1 ms
// 10000: indicates that the system attempts to listen on the system for 10 seconds
} while ((fd == -1) && (tryNum < 10000));
if (fd == -1) {
LOG_DEBUG("TCP accept fail\n");
return -1;
}
// Whether to block the interface
ret = SetBlockMode(fd, isBlock);
if (ret != 0) {
close(listenFd);
close(fd);
LOG_DEBUG("SetBlockMode ERROR");
}
// Disable listenFd
if (needClose) {
close(listenFd);
}
struct linger so_linger;
so_linger.l_onoff = 1;
so_linger.l_linger = 1;
setsockopt(fd,SOL_SOCKET,SO_LINGER, &so_linger,sizeof(so_linger));
LOG_DEBUG("accept a fd:%d\n", fd);
return fd;
}
/* Disable the specified socket */
void TcpClose(int sd)
{
close(sd);
}
int32_t TcpFrameWrite(BSL_UIO *uio, const void *buf, uint32_t len, uint32_t *writeLen)
{
int32_t ret;
uint8_t *newBuf = NULL;
const void *sendBuf = buf;
uint32_t sendLen = len;
HLT_FrameHandle *frameHandle = GetFrameHandle();
if (frameHandle->frameCallBack != NULL && frameHandle->pointType == POINT_SEND) {
newBuf = GetNewBuf(buf, len, &sendLen);
if (sendLen == 0) { // sendLen value changes and becomes 0, the value is IO_BUSY
*writeLen = 0;
return BSL_SUCCESS;
}
if (newBuf != NULL) {
sendBuf = (void *)newBuf;
}
}
ret = BSL_UIO_TcpMethod()->uioWrite(uio, sendBuf, sendLen, writeLen);
if (sendLen != len && *writeLen != 0) {
*writeLen = len;
}
FreeNewBuf(newBuf);
return ret;
}
int32_t TcpFrameRead(BSL_UIO *uio, void *buf, uint32_t len, uint32_t *readLen)
{
int ret;
ret = BSL_UIO_TcpMethod()->uioRead(uio, buf, len, readLen);
if (ret != BSL_SUCCESS) {
return ret;
}
uint8_t *newBuf = NULL;
uint32_t packLen = *readLen;
HLT_FrameHandle *frameHandle = GetFrameHandle();
if (frameHandle->frameCallBack != NULL && frameHandle->pointType == POINT_RECV) {
newBuf = GetNewBuf(buf, len, &packLen);
if (packLen == 0) { // packLen changes and becomes 0, the value is IO_BUSY
*readLen = 0;
return BSL_SUCCESS;
}
if (newBuf != NULL) {
if (memcpy_s(buf, len, (uint8_t *)newBuf, packLen) != EOK) {
FreeNewBuf(newBuf);
return BSL_UIO_IO_EXCEPTION;
}
*readLen = packLen;
}
FreeNewBuf(newBuf);
}
return BSL_SUCCESS;
}
int32_t SelectTcpWrite(BSL_UIO *uio, const void *buf, uint32_t len, uint32_t *writeLen)
{
HLT_FrameHandle *frameHandle = GetFrameHandle();
if (frameHandle->method.uioWrite != NULL) {
return frameHandle->method.uioWrite(uio, buf, len, writeLen);
}
return TcpFrameWrite(uio, buf, len, writeLen);
}
int32_t SelectTcpRead(BSL_UIO *uio, void *buf, uint32_t len, uint32_t *readLen)
{
HLT_FrameHandle *frameHandle = GetFrameHandle();
if (frameHandle->method.uioRead != NULL) {
return frameHandle->method.uioRead(uio, buf, len, readLen);
}
return TcpFrameRead(uio, buf, len, readLen);
}
static BSL_UIO_Method g_TcpUioMethodDefault;
/* Provide the default Linux implementation method */
void *TcpGetDefaultMethod(void)
{
const BSL_UIO_Method *ori = BSL_UIO_TcpMethod();
memcpy(&g_TcpUioMethodDefault, ori, sizeof(g_TcpUioMethodDefault));
g_TcpUioMethodDefault.uioWrite = SelectTcpWrite;
g_TcpUioMethodDefault.uioRead = SelectTcpRead;
return &g_TcpUioMethodDefault;
}
#endif
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/transfer/src/tcp_channel.c | C | unknown | 8,323 |
/*
* 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <errno.h>
#include "hitls_build.h"
#ifdef HITLS_BSL_UIO_UDP
#include "securec.h"
#include "bsl_uio.h"
#include "hitls_error.h"
#include "hitls_type.h"
#include "hitls.h"
#include "tls.h"
#include "hs_ctx.h"
#include "bsl_errno.h"
#include "uio_base.h"
#include "logger.h"
#include "hlt_type.h"
#include "socket_common.h"
#include "udp_channel.h"
/**
* @brief Connects to the peer and returns a socket descriptor.
*
* @return -1 is returned when an error occurs
* */
int UdpConnect(const char *targetIP, const int targetPort)
{
(void)targetIP;
(void)targetPort;
int fd;
struct sockaddr_in serverAddr;
// Create a socket
if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
LOG_ERROR("socket() fail\n");
return -1;
}
int option = 1;
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option)) < 0) {
close(fd);
LOG_ERROR("setsockopt() fail\n");
return -1;
}
// Set the protocol and port number
bzero(&serverAddr, sizeof(serverAddr));
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(targetPort);
// Set the IP address
serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
// Connection
int index = 0;
const int maxConnTime = 8000;
do {
if (connect(fd, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) == 0) {
break;
}
usleep(1000); // Delay 100000 us
LOG_ERROR("Connect error try again\n");
} while (index++ < maxConnTime);
if (index >= maxConnTime) {
close(fd);
LOG_ERROR("Connect error\n");
return -1;
}
SetBlockMode(fd, false);
return fd;
}
int UdpBind(const int localPort)
{
int lisentFd, ret;
struct sockaddr_in serverAddr;
// Create a socket
if ((lisentFd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
LOG_ERROR("create socket fail\n");
return -1;
}
int option = 1;
if (setsockopt(lisentFd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option)) < 0) {
close(lisentFd);
LOG_ERROR("setsockopt fail\n");
return -1;
}
// Set the protocol and port number
bzero(&serverAddr, sizeof(serverAddr));
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(localPort);
serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
uint32_t tryNum = 0;
LOG_DEBUG("bind socket ing...\n");
do {
ret = bind(lisentFd, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
usleep(1000); // 1000 microseconds, that is, 1 ms
tryNum++;
} while ((ret != 0) && (tryNum < 8000)); // 8000: indicates that the binding attempt is 8 seconds
if (ret != 0) {
close(lisentFd);
LOG_DEBUG("bind socket fail\n");
return -1;
}
SetBlockMode(lisentFd, false);
return lisentFd;
}
int UdpAccept(char *ip, int listenFd, bool isBlock, bool needClose)
{
(void)ip;
(void)listenFd;
(void)isBlock;
if (needClose) {
close(listenFd);
}
return listenFd;
}
/* Disable the specified socket */
void UdpClose(int sd)
{
close(sd);
}
int32_t UdpFrameWrite(BSL_UIO *uio, const void *buf, uint32_t len, uint32_t *writeLen)
{
int32_t ret;
uint8_t *newBuf = NULL;
const void *sendBuf = buf;
uint32_t sendLen = len;
HLT_FrameHandle *frameHandle = GetFrameHandle();
if (frameHandle->frameCallBack != NULL && frameHandle->pointType == POINT_SEND) {
newBuf = GetNewBuf(buf, len, &sendLen);
if (sendLen == 0) { // sendLen value changes and becomes 0, the value is IO_BUSY
*writeLen = 0;
return BSL_SUCCESS;
}
if (newBuf != NULL) {
sendBuf = (void *)newBuf;
}
}
ret = BSL_UIO_UdpMethod()->uioWrite(uio, sendBuf, sendLen, writeLen);
if (sendLen != len && *writeLen != 0) {
*writeLen = len;
}
FreeNewBuf(newBuf);
return ret;
}
int32_t UdpFrameRead(BSL_UIO *uio, void *buf, uint32_t len, uint32_t *readLen)
{
int ret;
ret = BSL_UIO_UdpMethod()->uioRead(uio, buf, len, readLen);
if (ret != BSL_SUCCESS) {
return ret;
}
uint8_t *newBuf = NULL;
uint32_t packLen = *readLen;
HLT_FrameHandle *frameHandle = GetFrameHandle();
if (frameHandle->frameCallBack != NULL && frameHandle->pointType == POINT_RECV) {
newBuf = GetNewBuf(buf, len, &packLen);
if (packLen == 0) { // packLen changes and becomes 0, the value is IO_BUSY
*readLen = 0;
return BSL_SUCCESS;
}
if (newBuf != NULL) {
if (memcpy_s(buf, len, (uint8_t *)newBuf, packLen) != EOK) {
FreeNewBuf(newBuf);
return BSL_UIO_IO_EXCEPTION;
}
*readLen = packLen;
}
FreeNewBuf(newBuf);
}
return BSL_SUCCESS;
}
int32_t SelectUdpWrite(BSL_UIO *uio, const void *buf, uint32_t len, uint32_t *writeLen)
{
HLT_FrameHandle *frameHandle = GetFrameHandle();
if (frameHandle->method.uioWrite != NULL) {
return frameHandle->method.uioWrite(uio, buf, len, writeLen);
}
return UdpFrameWrite(uio, buf, len, writeLen);
}
int32_t SelectUdpRead(BSL_UIO *uio, void *buf, uint32_t len, uint32_t *readLen)
{
HLT_FrameHandle *frameHandle = GetFrameHandle();
if (frameHandle->method.uioRead != NULL) {
return frameHandle->method.uioRead(uio, buf, len, readLen);
}
return UdpFrameRead(uio, buf, len, readLen);
}
static BSL_UIO_Method g_UdpUioMethodDefault;
/* Provide the default Linux implementation method */
void *UdpGetDefaultMethod(void)
{
const BSL_UIO_Method *ori = BSL_UIO_UdpMethod();
memcpy_s(&g_UdpUioMethodDefault, sizeof(g_UdpUioMethodDefault), ori, sizeof(g_UdpUioMethodDefault));
g_UdpUioMethodDefault.uioWrite = SelectUdpWrite;
g_UdpUioMethodDefault.uioRead = SelectUdpRead;
return &g_UdpUioMethodDefault;
}
#endif | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/framework/tls/transfer/src/udp_channel.c | C | unknown | 6,669 |
#!/bin/bash
# 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.
# Build different miniaturized targets and perform basic functional testing.
set -eu
PARAM_LIST=$@
COMMON_PARAM=""
TEST=""
ASM_TYPE=""
CUR_DIR=`pwd`
HITLS_ROOT_DIR=`realpath $CUR_DIR/../../`
parse_option()
{
for i in $PARAM_LIST
do
case "${i}" in
"bsl"|"md"|"mac"|"kdf"|"cipher"|"bn"|"ecc"|"pkey"|"pki"|"all"|"tls"|"provider")
TEST=$i
;;
"x8664"|"armv8")
ASM_TYPE=$i
COMMON_PARAM="$COMMON_PARAM $i"
;;
"linux")
COMMON_PARAM="$COMMON_PARAM $i"
;;
"32")
COMMON_PARAM="$COMMON_PARAM $i"
;;
"big")
COMMON_PARAM="$COMMON_PARAM $i"
;;
*)
echo "Wrong parameter: $i"
exit 1
;;
esac
done
}
test_bsl()
{
if [ "$ASM_TYPE" != "" ]; then
echo "bsl does not support assembly."
return
fi
NO_LIB="no-crypto no-tls linux"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=asn1 test=asn1
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=base64 test=base64
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=buffer test=buffer
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=err test=err
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=hash test=hash
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=init test=init
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=list test=list
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=log test=log
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=obj test=obj
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=obj,hash,sal_thread test=obj # depends on thread to init hash
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=params test=params
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=pem test=pem
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=sal test=sal
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=sal_mem test=sal_mem
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=sal_thread test=sal_thread
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=sal_lock test=sal_lock
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=sal_time test=sal_time
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=sal_file test=sal_file
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=sal_net test=sal_net
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=sal_str test=sal_str
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=sal_dl test=sal_dl
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=tlv test=tlv
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=uio test=uio
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=uio_buffer
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=uio_mem
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=uio_sctp
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=uio_tcp
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=uio_udp
}
test_md()
{
NO_LIB="no-tls"
if [ "$ASM_TYPE" = "armv8" ]; then
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm3 test=sm3
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sha1 test=sha1
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sha2 test=sha2
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sha224 test=sha224
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sha256 test=sha256
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha384 test=sha384
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha512 test=sha512
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha3 test=sha3
elif [ "$ASM_TYPE" = "x8664" ]; then
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm3 test=sm3
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,md5 test=md5
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha1 test=sha1
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha2 test=sha2
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha224 test=sha224
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha256 test=sha256
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha384 test=sha384
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha512 test=sha512
else
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,md5 test=md5
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm3 test=sm3
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha1 test=sha1
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha2 test=sha2
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha224 test=sha224
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha256 test=sha256
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha384 test=sha384
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha512 test=sha512
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha3 test=sha3
fi
}
test_mac()
{
if [ "$ASM_TYPE" != "" ]; then
echo "mac does not support assembly."
return
fi
NO_LIB="no-tls"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hmac,md5 test=hmac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hmac,sha1 test=hmac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hmac,sha2 test=hmac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hmac,sha224 test=hmac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hmac,sha256 test=hmac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hmac,sha384 test=hmac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hmac,sha512 test=hmac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hmac,sha3 test=hmac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hmac,sm3 test=hmac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,gmac test=gmac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,cmac_aes test=cmac_aes
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,cmac_sm4 test=cmac_sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,cbc_mac test=cbc_mac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,siphash test=siphash
}
test_kdf()
{
if [ "$ASM_TYPE" != "" ]; then
echo "kdf does not support assembly."
return
fi
NO_LIB="no-tls"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,scrypt test=scrypt
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hkdf,md5 test=hkdf
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hkdf,sha1 test=hkdf
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hkdf,sha2 test=hkdf
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,pbkdf2,md5 test=pbkdf2
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,pbkdf2,sha1 test=pbkdf2
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,pbkdf2,sha2 test=pbkdf2
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,pbkdf2,sha3 test=pbkdf2
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,pbkdf2,sm3 test=pbkdf2
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,kdftls12,sha256 test=kdftls12
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,kdftls12,sha384 test=kdftls12
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,kdftls12,sha512 test=kdftls12
}
test_cipher()
{
NO_LIB="no-tls"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,aes,modes test=aes
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,aes,cbc test=aes
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,aes,ctr test=aes
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,aes,ecb test=aes # SDV_CRYPTO_AES_ENCRYPT_FUNC_TC001
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,aes,xts test=aes # SDV_CRYPTO_EAL_AES_FUNC_TC001
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,aes,ccm test=aes
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,aes,gcm test=aes
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,aes,cfb test=aes
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,aes,ofb test=aes
if [ "$ASM_TYPE" = "x8664" ]; then
# depends on ealinit
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sm4,modes test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sm4,xts test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sm4,cbc test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sm4,ecb test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sm4,ctr test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sm4,gcm test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sm4,cfb test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sm4,ofb test=sm4
else
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm4,modes test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm4,xts test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm4,cbc test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm4,ecb test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm4,ctr test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm4,gcm test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm4,cfb test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm4,ofb test=sm4
fi
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,chacha20 test=chacha20
}
test_bn()
{
NO_LIB="no-tls"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=bn
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=bn_basic
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal_bn
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=bn_rand
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=bn_prime
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=bn_str_conv
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=bn_cb
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=bn_prime_rfc3526
}
test_ecc()
{
NO_LIB="no-tls"
if [ "$ASM_TYPE" = "armv8" -o "$ASM_TYPE" = "x8664" ]; then
# The curves that support assembly are: curve_sm2, curve_nistp256
# all curves.
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,ecdh,ecdsa,sm2,drbg_hash,entropy,sha2,ecc,ealinit test=curve_nistp224 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
# sm2, depends on sm3
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,sm2,drbg_hash,entropy,ealinit test=sm2 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,sm2_crypt,drbg_hash,entropy,ealinit test=sm2_crypt add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,sm2_exch,drbg_hash,entropy,ealinit test=sm2_exch add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,sm2_sign,drbg_hash,entropy,ealinit test=sm2_sign add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
# nistp256
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,ecdh,ecdsa,drbg_hash,entropy,sha2,curve_nistp256,ealinit test=curve_nistp256 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
return
fi
# Test all curves.
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,ecdh,ecdsa,sm2,drbg_hash,entropy,sha2,ecc test=curve_nistp224 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
# nist224/256/384/521
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,ecdh,ecdsa,drbg_hash,entropy,sha2,curve_nistp224 test=curve_nistp224 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,ecdh,ecdsa,drbg_hash,entropy,sha2,curve_nistp256 test=curve_nistp256 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,ecdh,ecdsa,drbg_hash,entropy,sha2,curve_nistp384 test=curve_nistp384 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,ecdh,ecdsa,drbg_hash,entropy,sha2,curve_nistp521 test=curve_nistp521 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
# br256/384/512
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,ecdh,ecdsa,drbg_hash,entropy,sha2,curve_bp256r1 test=curve_bp256r1 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,ecdh,ecdsa,drbg_hash,entropy,sha2,curve_bp384r1 test=curve_bp384r1 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,ecdh,ecdsa,drbg_hash,entropy,sha2,curve_bp512r1 test=curve_bp512r1 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
# sm2 depends on sm3 by default.
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,sm2,drbg_hash,entropy test=sm2 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,sm2_crypt,drbg_hash,entropy test=sm2_crypt add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,sm2_exch,drbg_hash,entropy test=sm2_exch add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,sm2_sign,drbg_hash,entropy test=sm2_sign add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
}
test_pkey()
{
NO_LIB="no-tls"
if [ "$ASM_TYPE" = "x8664" -o "$ASM_TYPE" = "armv8" ]; then
# The pkey that support assembly is: x25519.
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=x25519,sha2,ealinit
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,x25519,drbg_hash,sha2,ealinit test=x25519
return
fi
# rsa
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa,rsa_bssa,drbg_hash,sha1,sha2 test=rsa
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa,drbg_hash,sha1,sha2 test=rsa
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_gen,drbg_hash,sha1,sha2 test=rsa_gen
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_sign,rsa_emsa_pss,sha1,sha2,drbg_hash test=rsa_sign
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_sign,rsa_emsa_pss,drbg_hash,sha1,sha2 test=rsa_sign
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_sign,rsa_emsa_pkcsv15,sha1,sha2 test=rsa_sign # not need drbg
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_verify,rsa_emsa_pss,sha1,sha2 test=rsa_verify # not need drbg
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_verify,rsa_emsa_pkcsv15,sha1,sha2 test=rsa_verify # not need drbg
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_encrypt,rsa_no_pad,sha1,sha2 test=rsa_encrypt # not need drbg
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_encrypt,rsaes_oaep,drbg_hash,sha1,sha2 test=rsa_encrypt
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_encrypt,rsaes_pkcsv15,drbg_hash,sha1,sha2 test=rsa_encrypt
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_encrypt,rsaes_pkcsv15_tls,drbg_hash,sha1,sha2 test=rsa_encrypt
# rsa_decrypt: not need drbg
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_decrypt,rsa_no_pad,sha1,sha2 test=rsa_decrypt
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_decrypt,rsaes_oaep,sha1,sha2 test=rsa_decrypt
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_decrypt,rsaes_pkcsv15,sha1,sha2 test=rsa_decrypt
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_decrypt,rsaes_pkcsv15_tls,sha1,sha2 test=rsa_decrypt
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_sign,rsa_blinding,rsa_emsa_pkcsv15,drbg_hash,sha1,sha2 test=rsa_sign
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_decrypt,rsa_blinding,rsaes_oaep,drbg_hash,sha1,sha2 test=rsa_decrypt
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_sign,rsa_bssa,rsa_blinding,rsa_emsa_pss,drbg_hash,sha1,sha2 test=rsa_sign
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_sign,rsa_verify,rsa_bssa,rsa_emsa_pss,drbg_hash,sha1,sha2 test=rsa_sign
# dsa
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,dsa,drbg_hash,sha2 test=dsa
# dh
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,dh,drbg_hash,sha2 test=dh
# curve25519: ed25519 depends on sha512 by default.
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,x25519,drbg_hash,sha2 test=x25519
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ed25519,drbg_hash,sha2 test=ed25519
# mldsa
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,mldsa,drbg_hash,sha2 test=mldsa
# paillier
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,paillier,drbg_hash,sha2 test=paillier
# mlkem
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,mlkem,drbg_hash,sha2 test=mlkem
# hybridkem
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hybridkem,x25519,ecdh,ecc,drbg_hash,sha2 test=hybridkem
# elgamal
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,elgamal,drbg_hash,sha2 test=elgamal
# slh_dsa
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,slh_dsa,drbg_hash,sha2 test=slh_dsa
# xmss
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,xmss,slh_dsa,drbg_hash,sha2 test=xmss
}
test_tls()
{
NO_LIB=""
bash mini_build_test.sh $COMMON_PARAM $NO_LIB feature-config=tlcp_feature test=base,asn1,base64,buffer,err,hash,init,list,log,obj,params,pem,tlv,sal,sal_mem,sal_lock,sal_str,sal_file,sal_thread,sal_net,sal_time,aes,bn,chacha20,cmac_aes,drbg_ctr,drbg_hash,ecc,ecdh,ecdsa,entropy,gcm,hkdf,hpke,mlkem,mldsa,sha256,sha384,sha512,slh_dsa,sm2,sm3,sm4,x25519,curve_nistp256,curve_nistp384,curve_nistp521,x509_crl_gen,x509_crl_parse,x509_csr_gen,x509_csr_parse,x509_crt_gen,x509_crt_parse,x509_vfy,tlcp linux add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB feature-config=nokem_feature test=base linux
bash mini_build_test.sh $COMMON_PARAM $NO_LIB feature-config=mtu_feature test=mtu linux
bash mini_build_test.sh $COMMON_PARAM $NO_LIB feature-config=max_send_fragment_feature test=max_send_fragment linux
bash mini_build_test.sh $COMMON_PARAM $NO_LIB feature-config=ca_list_feature test=ca_list linux
}
test_pki()
{
if [ "$ASM_TYPE" != "" ]; then
return
fi
bash mini_build_test.sh no-tls enable=eal,codecskey,rsa,drbg_hash,cipher,modes,sha256,hmac
bash mini_build_test.sh no-tls enable=eal,key_epki,key_encode,rsa,drbg_hash,cipher,modes,sha256,hmac
bash mini_build_test.sh no-tls enable=eal,key_encode,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,key_decode,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509_crt,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509_crt_gen,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509_crt_parse,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509_csr,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509_csr_gen,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509_csr_parse,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509_crl,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509_crl_gen,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509_crl_parse,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509_vfy,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,pkcs12,rsa,sha256,drbg_hash,md,cipher,modes,hmac
bash mini_build_test.sh no-tls enable=eal,pkcs12_gen,rsa,sha256,drbg_hash,md,cipher,modes,hmac
bash mini_build_test.sh no-tls enable=eal,pkcs12_parse,rsa,drbg_hash,md,cipher,modes,hmac
bash mini_build_test.sh no-tls enable=eal,info,x509_crt,rsa,drbg_hash,md,cipher,modes,hmac
### key gen ####
bash mini_build_test.sh no-tls enable=eal,key_encode,sal_file,pem,rsa,sha256,drbg_hash test=key_encode linux
bash mini_build_test.sh no-tls enable=eal,key_encode,pem,ed25519,drbg_hash test=key_encode
bash mini_build_test.sh no-tls enable=eal,key_encode,sal_file,sm2,sha256,drbg_hash test=key_encode linux
bash mini_build_test.sh no-tls enable=eal,key_encode,pem,ecdsa,curve_nistp256,sha256,drbg_hash test=key_encode
#### key parse ####
bash mini_build_test.sh no-tls enable=eal,key_decode,sal_file,pem,rsa,sha256,drbg_hash test=key_decode linux
bash mini_build_test.sh no-tls enable=eal,key_decode,sal_file,pem,ed25519 test=key_decode linux
bash mini_build_test.sh no-tls enable=eal,key_decode,sal_file,sm2,sha256 test=key_decode linux
bash mini_build_test.sh no-tls enable=eal,key_decode,sal_file,pem,ecdsa,curve_nistp256,sha256 test=key_decode linux
#### crl gen ####
bash mini_build_test.sh no-tls enable=eal,x509_crl_gen,rsa,sal_file,pem,sha256,drbg_hash test=x509_crl_gen linux
bash mini_build_test.sh no-tls enable=eal,x509_crl_gen,pem,ed25519,drbg_hash test=x509_crl_gen
bash mini_build_test.sh no-tls enable=eal,x509_crl_gen,sm2,sha256,drbg_hash test=x509_crl_gen
bash mini_build_test.sh no-tls enable=eal,x509_crl_gen,sal_file,ecdsa,curve_nistp256,sha256,drbg_hash test=x509_crl_gen linux
# #### crl parse ####
bash mini_build_test.sh no-tls enable=eal,x509_crl_parse,pem,sal_file,rsa,sha256,drbg_hash test=x509_crl_parse linux
bash mini_build_test.sh no-tls enable=eal,x509_crl_parse,sal_file,ed25519,sha256 test=x509_crl_parse linux
bash mini_build_test.sh no-tls enable=eal,x509_crl_parse,pem,sal_file,sm2,sha256 test=x509_crl_parse linux
bash mini_build_test.sh no-tls enable=eal,x509_crl_parse,sal_file,ecdsa,curve_nistp256,sha256 test=x509_crl_parse linux
#### csr gen ####
bash mini_build_test.sh no-tls enable=eal,x509_csr_gen,pem,rsa,sha256,drbg_hash test=x509_csr_gen
bash mini_build_test.sh no-tls enable=eal,x509_csr_gen,sal_file,ed25519,drbg_hash test=x509_csr_gen linux add-options="-DHITLS_CRYPTO_ED25519_CHECK"
bash mini_build_test.sh no-tls enable=eal,x509_csr_gen,sm2,sha256,drbg_hash test=x509_csr_gen
bash mini_build_test.sh no-tls enable=eal,x509_csr_gen,sal_file,pem,ecdsa,curve_nistp256,sha256,drbg_hash test=x509_csr_gen linux
#### csr parse ####
bash mini_build_test.sh no-tls enable=eal,x509_csr_parse,sal_file,rsa,sha256,drbg_hash test=x509_csr_parse linux
bash mini_build_test.sh no-tls enable=eal,x509_csr_parse,sal_file,pem,ed25519,drbg_hash test=x509_csr_parse linux
bash mini_build_test.sh no-tls enable=eal,x509_csr_parse,sal_file,pem,sm2,sha256,drbg_hash test=x509_csr_parse linux
bash mini_build_test.sh no-tls enable=eal,x509_csr_parse,sal_file,ecdsa,curve_nistp256,sha256,drbg_hash test=x509_csr_parse linux
#### cert gen ####
bash mini_build_test.sh no-tls enable=eal,x509_crt_gen,pem,rsa,sha256,drbg_hash test=x509_crt_gen
bash mini_build_test.sh no-tls enable=eal,x509_crt_gen,sal_file,pem,ed25519,drbg_hash test=x509_crt_gen linux
bash mini_build_test.sh no-tls enable=eal,x509_crt_gen,sal_file,sm2,sha256,drbg_hash test=x509_crt_gen linux
bash mini_build_test.sh no-tls enable=eal,x509_crt_gen,ecdsa,curve_nistp256,sha256,drbg_hash test=x509_crt_gen
### cert parse ####
bash mini_build_test.sh no-tls enable=eal,x509_crt_parse,sal_file,pem,rsa,sha256,drbg_hash test=x509_crt_parse linux
bash mini_build_test.sh no-tls enable=eal,x509_crt_parse,sal_file,ed25519,drbg_hash test=x509_crt_parse linux
bash mini_build_test.sh no-tls enable=eal,x509_crt_parse,sal_file,sm2,sha256,drbg_hash test=x509_crt_parse linux
bash mini_build_test.sh no-tls enable=eal,x509_crt_parse,sal_file,pem,ecdsa,curve_nistp256,curve_nistp384,sha256,drbg_hash test=x509_crt_parse linux
### cert chain ####
bash mini_build_test.sh no-tls enable=eal,x509_vfy,sal_file,pem,rsa,ecdsa,curve_nistp256,curve_nistp384,ed25519,sm2,sha2,drbg_hash test=x509_vfy linux
### pkcs12 gen ####
bash mini_build_test.sh no-tls enable=eal,pkcs12_gen,key_decode,sal_file,pem,rsa,ecdsa,curve_nistp256,ed25519,sm2,drbg_hash,cipher,modes,md,hmac test=pkcs12_gen linux
bash mini_build_test.sh no-tls enable=eal,pkcs12_parse,sal_file,pem,rsa,ecdsa,curve_nistp256,curve_nistp384,curve_nistp521,ed25519,sm2,cipher,modes,md,drbg_hash,hmac test=pkcs12_parse linux debug
}
provider_test_check()
{
set +e
nm $HITLS_ROOT_DIR/build/libhitls_crypto.a | grep CRYPT_SHA2_256_
if [ "$?" != "1" ]; then
echo "Error: CRYPT_SHA2_256_ is found in libhitls_crypto.a"
exit 1
fi
nm $HITLS_ROOT_DIR/build/libhitls_crypto.a | grep CRYPT_EAL_ProviderMdNewCtx
if [ "$?" != "0" ]; then
echo "Error: CRYPT_EAL_ProviderMdNewCtx is not found in libhitls_crypto.a"
exit 1
fi
}
test_provider()
{
include_path="-I${HITLS_ROOT_DIR}/testcode/script/mini_test_config"
NO_LIB="no-tls"
# sha256
bash mini_build_test.sh $COMMON_PARAM $NO_LIB linux enable=eal,provider,sha256 test=provider add-options="-DHITLS_CONFIG_FILE='<test_config.h>'" include-path="${include_path}"
provider_test_check
bash mini_build_test.sh $COMMON_PARAM $NO_LIB linux enable=eal,provider test=provider add-options="-DHITLS_CONFIG_FILE='<test_config.h>'" include-path="${include_path}"
provider_test_check
# hmac
# build with sha256
bash mini_build_test.sh $COMMON_PARAM $NO_LIB linux enable=eal,provider,hmac,sha256 test=provider add-options="-DHITLS_CONFIG_FILE='<test_config.h>'" include-path="${include_path}"
provider_test_check
# build without sha256, and not check config
bash mini_build_test.sh $COMMON_PARAM $NO_LIB linux enable=eal,provider,hmac test=provider add-options="-DHITLS_CONFIG_FILE='<test_config.h>'" include-path="${include_path}" add-options="-DHITLS_NO_CONFIG_CHECK"
provider_test_check
# hkdf
bash mini_build_test.sh $COMMON_PARAM $NO_LIB linux enable=eal,provider,hkdf test=provider add-options="-DHITLS_CONFIG_FILE='<test_config.h>'" include-path="${include_path}" add-options="-DHITLS_NO_CONFIG_CHECK"
provider_test_check
# pbkdf2
bash mini_build_test.sh $COMMON_PARAM $NO_LIB linux enable=eal,provider,pbkdf2 test=provider add-options="-DHITLS_CONFIG_FILE='<test_config.h>'" include-path="${include_path}" add-options="-DHITLS_NO_CONFIG_CHECK"
provider_test_check
# kdftls12
bash mini_build_test.sh $COMMON_PARAM $NO_LIB linux enable=eal,provider,kdftls12 test=provider add-options="-DHITLS_CONFIG_FILE='<test_config.h>'" include-path="${include_path}" add-options="-DHITLS_NO_CONFIG_CHECK"
provider_test_check
# rsa
bash mini_build_test.sh $COMMON_PARAM $NO_LIB linux enable=eal,provider,rsa,sm3,drbg_hash,entropy test=provider add-options="-DHITLS_CONFIG_FILE='<test_config.h>'" include-path="${include_path}" add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SM3" add-options="-DHITLS_CRYPTO_DRBG_GM" add-options="-DHITLS_NO_CONFIG_CHECK"
provider_test_check
}
parse_option
case $TEST in
"all")
test_bsl
test_md
test_mac
test_kdf
test_cipher
test_bn
test_ecc
test_pkey
test_tls
test_provider
;;
"bsl")
test_bsl
;;
"md")
test_md
;;
"mac")
test_mac
;;
"kdf")
test_kdf
;;
"cipher")
test_cipher
;;
"bn")
test_bn
;;
"ecc")
test_ecc
;;
"pkey")
test_pkey
;;
"pki")
test_pki
;;
"tls")
test_tls
;;
"provider")
test_provider
;;
*)
;;
esac
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/script/all_mini_test.sh | Shell | unknown | 30,531 |
#!/bin/bash
# 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.
set -e
cd ../../
HITLS_ROOT_DIR=`pwd`
hitls_compile_option=()
paramList=$@
paramNum=$#
add_options=""
del_options=""
dis_options=""
get_arch=`arch`
executes="OFF"
LIB_TYPE="static shared"
enable_sctp="--enable-sctp"
BITS=64
subdir="CMVP"
libname=""
usage()
{
printf "%-50s %-30s\n" "Build openHiTLS Code" "sh build_hitls.sh"
printf "%-50s %-30s\n" "Build openHiTLS Code With Gcov" "sh build_hitls.sh gcov"
printf "%-50s %-30s\n" "Build openHiTLS Code With Debug" "sh build_hitls.sh debug"
printf "%-50s %-30s\n" "Build openHiTLS Code With Asan" "sh build_hitls.sh asan"
printf "%-50s %-30s\n" "Build openHiTLS Code With Pure C" "sh build_hitls.sh pure_c"
printf "%-50s %-30s\n" "Build openHiTLS Code With X86_64" "sh build_hitls.sh x86_64"
printf "%-50s %-30s\n" "Build openHiTLS Code With Armv8_be" "sh build_hitls.sh armv8_be"
printf "%-50s %-30s\n" "Build openHiTLS Code With Armv8_le" "sh build_hitls.sh armv8_le"
printf "%-50s %-30s\n" "Build openHiTLS Code With Add Options" "sh build_hitls.sh add-options=xxx"
printf "%-50s %-30s\n" "Build openHiTLS Code With No Provider" "sh build_hitls.sh no-provider"
printf "%-50s %-30s\n" "Build openHiTLS Code With No Sctp" "sh build_hitls.sh no_sctp"
printf "%-50s %-30s\n" "Build openHiTLS Code With Bits" "sh build_hitls.sh bits=xxx"
printf "%-50s %-30s\n" "Build openHiTLS Code With Lib Type" "sh build_hitls.sh shared"
printf "%-50s %-30s\n" "Build openHiTLS Code With Lib Fuzzer" "sh build_hitls.sh libfuzzer"
printf "%-50s %-30s\n" "Build openHiTLS Code With command line" "sh build_hitls.sh exe"
printf "%-50s %-30s\n" "Build openHiTLS Code With Iso Provider" "sh build_hitls.sh iso"
printf "%-50s %-30s\n" "Build openHiTLS Code With Help" "sh build_hitls.sh help"
}
clean()
{
rm -rf ${HITLS_ROOT_DIR}/build
mkdir ${HITLS_ROOT_DIR}/build
}
down_depend_code()
{
if [ ! -d "${HITLS_ROOT_DIR}/platform" ]; then
cd ${HITLS_ROOT_DIR}
mkdir platform
fi
if [ ! -d "${HITLS_ROOT_DIR}/platform/Secure_C/src" ]; then
cd ${HITLS_ROOT_DIR}/platform
git clone https://gitee.com/openeuler/libboundscheck.git Secure_C
fi
}
build_depend_code()
{
if [ ! -d "${HITLS_ROOT_DIR}/platform/Secure_C/lib" ]; then
mkdir -p ${HITLS_ROOT_DIR}/platform/Secure_C/lib
cd ${HITLS_ROOT_DIR}/platform/Secure_C
make -j
fi
}
build_hitls_code()
{
# Compile openHiTLS
cd ${HITLS_ROOT_DIR}/build
add_options="${add_options} -DHITLS_CRYPTO_RAND_CB" # HITLS_CRYPTO_RAND_CB: add rand callback
add_options="${add_options} -DHITLS_EAL_INIT_OPTS=9 -DHITLS_CRYPTO_ASM_CHECK" # Get CPU capability
add_options="${add_options} -DHITLS_CRYPTO_ENTROPY -DHITLS_CRYPTO_ENTROPY_DEVRANDOM -DHITLS_CRYPTO_ENTROPY_GETENTROPY -DHITLS_CRYPTO_ENTROPY_SYS -DHITLS_CRYPTO_ENTROPY_HARDWARE" # add default entropy
add_options="${add_options} -DHITLS_CRYPTO_DRBG_GM" # enable GM DRBG
add_options="${add_options} -DHITLS_CRYPTO_ACVP_TESTS" # enable ACVP tests
add_options="${add_options} -DHITLS_CRYPTO_DSA_GEN_PARA" # enable DSA genPara tests
add_options="${add_options} ${test_options}"
if [[ $get_arch = "x86_64" ]]; then
echo "Compile: env=x86_64, c, little endian, 64bits"
add_options="${add_options} -DHITLS_CRYPTO_SP800_STRICT_CHECK" # open the strict check in crypto.
del_options="${del_options} -DHITLS_CRYPTO_SM2_PRECOMPUTE_512K_TBL" # close the sm2 512k pre-table
if [[ $executes = "ON" ]]; then
python3 ../configure.py --executes hitls --lib_type ${LIB_TYPE} --enable all --asm_type x8664 --add_options="$add_options" --del_options="$del_options" --add_link_flags="-ldl" ${enable_sctp} ${dis_options}
else
python3 ../configure.py --lib_type ${LIB_TYPE} --enable all --asm_type x8664 --add_options="$add_options" --del_options="$del_options" --add_link_flags="-ldl" ${enable_sctp} ${dis_options}
fi
elif [[ $get_arch = "armv8_be" ]]; then
echo "Compile: env=armv8, asm + c, big endian, 64bits"
python3 ../configure.py --lib_type ${LIB_TYPE} --enable all --endian big --asm_type armv8 --add_options="$add_options" --del_options="$del_options" --add_link_flags="-ldl" ${enable_sctp} ${dis_options}
elif [[ $get_arch = "armv8_le" ]]; then
echo "Compile: env=armv8, asm + c, little endian, 64bits"
python3 ../configure.py --lib_type ${LIB_TYPE} --enable all --asm_type armv8 --add_options="$add_options" --del_options="$del_options" --add_link_flags="-ldl" ${enable_sctp} ${dis_options}
else
echo "Compile: env=$get_arch, c, little endian, 64bits"
python3 ../configure.py --lib_type ${LIB_TYPE} --enable all --add_options="$add_options" --del_options="$del_options" --add_link_flags="-ldl" ${enable_sctp} ${dis_options}
fi
cmake ..
make -j
}
build_hitls_provider()
{
# Compile openHiTLS
cd ${HITLS_ROOT_DIR}/build
if [[ $libname = "libhitls_sm.so" ]] && [[ $get_arch = "armv8_le" ]]; then
config_file="${subdir}_sm_feature_config.json"
compile_file="${subdir}_sm_compile_config.json"
else
config_file="${subdir}_feature_config.json"
compile_file="${subdir}_compile_config.json"
fi
python3 ../configure.py --add_options="$add_options" --del_options="$del_options" \
--feature_config=./config/json/${subdir}/${get_arch}/${config_file} \
--compile=./config/json/${subdir}/${get_arch}/${compile_file} \
--lib_type=shared
cmake .. -DCMAKE_SKIP_RPATH=TRUE -DCMAKE_INSTALL_PREFIX=../output/${subdir}/${get_arch}
make -j
make install
cd ../output/${subdir}/${get_arch}/lib
mv libhitls.so $libname
mv libhitls.so.hmac $libname.hmac
}
parse_option()
{
for i in $paramList
do
key=${i%%=*}
value=${i#*=}
case "${key}" in
"add-options")
add_options="${add_options} ${value}"
;;
"no-provider")
dis_options="--disable feature_provider provider codecs"
;;
"gcov")
add_options="${add_options} -fno-omit-frame-pointer -fprofile-arcs -ftest-coverage -fdump-rtl-expand"
;;
"debug")
add_options="${add_options} -O0 -g3 -gdwarf-2"
del_options="${del_options} -O2 -D_FORTIFY_SOURCE=2"
;;
"asan")
add_options="${add_options} -fsanitize=address -fsanitize-address-use-after-scope -O0 -g3 -fno-stack-protector -fno-omit-frame-pointer -fgnu89-inline"
del_options="${del_options} -fstack-protector-strong -fomit-frame-pointer -O2 -D_FORTIFY_SOURCE=2"
;;
"x86_64")
get_arch="x86_64"
;;
"armv8_be")
get_arch="armv8_be"
;;
"armv8_le")
get_arch="armv8_le"
;;
"pure_c")
get_arch="C"
;;
"no_sctp")
enable_sctp=""
;;
"bits")
BITS="$value"
;;
"static")
LIB_TYPE="static"
;;
"shared")
LIB_TYPE="shared"
;;
"libfuzzer")
add_options="${add_options} -fsanitize=fuzzer-no-link -fsanitize=signed-integer-overflow -fsanitize-coverage=trace-cmp"
del_options="${del_options} -Wtrampolines -O2 -D_FORTIFY_SOURCE=2 -fstack-protector-strong -fomit-frame-pointer -fdump-rtl-expand"
export ASAN_OPTIONS=detect_stack_use_after_return=1:strict_string_checks=1:detect_leaks=1:log_path=asan.log
export CC=clang
;;
"exe")
executes="ON"
add_options="${add_options} -fno-plt"
;;
"iso")
add_options="${add_options} -DHITLS_CRYPTO_CMVP_ISO19790"
libname="libhitls_iso.so"
;;
"fips")
add_options="${add_options} -DHITLS_CRYPTO_CMVP_FIPS"
libname="libhitls_fips.so"
;;
"sm")
add_options="${add_options} -DHITLS_CRYPTO_CMVP_SM"
libname="libhitls_sm.so"
;;
"help")
usage
exit 0
;;
*)
echo "${i} option is not recognized, Please run <sh build_hitls.sh help> get supported options."
usage
exit 0
;;
esac
done
}
clean
parse_option
down_depend_code
build_depend_code
if [[ $libname != "" ]]; then
build_hitls_provider
else
build_hitls_code
fi | 2302_82127028/openHiTLS-examples_5062_4009 | testcode/script/build_hitls.sh | Shell | unknown | 9,543 |
#!/bin/bash
# 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.
set -e
usage()
{
printf "\n"
printf "%-05s %-30s\n" "* Script :" "${BASH_SOURCE[0]}"
printf "%-50s %-30s\n" "* Usage Option :" ""
printf "%-50s %-30s\n" "* --help|-h : Help information." ""
printf "%-50s %-30s\n" "* add-options : Add options." "bash ${BASH_SOURCE[0]} add-options=xxx"
printf "%-50s %-30s\n" "* no-provider : Disable provider." "bash ${BASH_SOURCE[0]} no-provider"
printf "%-50s %-30s\n" "* tls-debug : Enable the debug mode." "bash ${BASH_SOURCE[0]} tls-debug"
printf "%-50s %-30s\n" "* no-crypto : Custom crypto testcase." "bash ${BASH_SOURCE[0]} no-crypto"
printf "%-50s %-30s\n" "* no-bsl : Custom bsl testcase." "bash ${BASH_SOURCE[0]} no-bsl"
printf "%-50s %-30s\n" "* no-tls : Custom tls testcase." "bash ${BASH_SOURCE[0]} no-tls"
printf "%-50s %-30s\n" "* no-pki : Custom pki testcase." "bash ${BASH_SOURCE[0]} no-pki"
printf "%-50s %-30s\n" "* no-auth : Custom auth testcase." "bash ${BASH_SOURCE[0]} no-auth"
printf "%-50s %-30s\n" "* no-demos : Not build demos." "bash ${BASH_SOURCE[0]} no-auth"
printf "%-50s %-30s\n" "* verbose : Show detailse." "bash ${BASH_SOURCE[0]} verbose"
printf "%-50s %-30s\n" "* gcov : Enable the coverage capability." "bash ${BASH_SOURCE[0]} gcov"
printf "%-50s %-30s\n" "* asan : Enabling the ASAN capability." "bash ${BASH_SOURCE[0]} asan"
printf "%-50s %-30s\n" "* big-endian : Specify the platform endianness." "bash ${BASH_SOURCE[0]} big-endian"
printf "%-50s %-30s\n" "* include-path : Specify the config file path." "bash ${BASH_SOURCE[0]} include-path=-Ixxx"
printf "%-50s %-30s\n\n" "* run-tests : Creating a custom test suite." "bash ${BASH_SOURCE[0]} run-tests=xxx1|xxx2|xxx3"
printf "%-50s %-30s\n" "* apps : Create apps testcase." "bash ${BASH_SOURCE[0]} apps"
}
export_env()
{
HITLS_ROOT_DIR=${HITLS_ROOT_DIR:=$(cd $(dirname ${BASH_SOURCE[0]})/../..;pwd)}
LOCAL_ARCH=${LOCAL_ARCH:=`arch`}
ENABLE_GCOV=${ENABLE_GCOV:=OFF}
ENABLE_ASAN=${ENABLE_ASAN:=OFF}
ENABLE_PRINT=${ENABLE_PRINT:=ON}
ENABLE_FAIL_REPEAT=${ENABLE_FAIL_REPEAT:=OFF}
CUSTOM_CFLAGS=${CUSTOM_CFLAGS:=''}
ENABLE_APP=${ENABLE_APP:=OFF}
ENABLE_TLS=${ENABLE_TLS:=ON}
BIG_ENDIAN=${BIG_ENDIAN:=OFF}
ENABLE_CRYPTO=${ENABLE_CRYPTO:=ON}
ENABLE_BSL=${ENABLE_BSL:=ON}
ENABLE_PKI=${ENABLE_PKI:=ON}
ENABLE_AUTH=${ENABLE_AUTH:=ON}
ENABLE_CMVP=${ENABLE_CMVP:=OFF}
ENABLE_DEMOS=${ENABLE_DEMOS:=ON}
ENABLE_UIO_SCTP=${ENABLE_UIO_SCTP:=ON}
ENABLE_VERBOSE=${ENABLE_VERBOSE:=''}
RUN_TESTS=${RUN_TESTS:=''}
DEBUG=${DEBUG:=ON}
if [ -f ${HITLS_ROOT_DIR}/build/macro.txt ];then
CUSTOM_CFLAGS=$(cat ${HITLS_ROOT_DIR}/build/macro.txt)
CUSTOM_CFLAGS="$CUSTOM_CFLAGS -D__FILENAME__=__FILE__"
fi
if [[ ! -e "${HITLS_ROOT_DIR}/testcode/output/log" ]]; then
mkdir ${HITLS_ROOT_DIR}/testcode/output/log
fi
}
down_depend_code()
{
if [ ! -d "${HITLS_ROOT_DIR}/platform/Secure_C/lib" ]; then
cd ${HITLS_ROOT_DIR}/platform/Secure_C
make -j
fi
}
find_test_suite()
{
if [[ ${ENABLE_CRYPTO} == "ON" ]]; then
crypto_testsuite=$(find ${HITLS_ROOT_DIR}/testcode/sdv/testcase/crypto -name "*.data" | sed -e "s/.data//" | tr -s "\n" " ")
crypto_testsuite=${crypto_testsuite}$(find ${HITLS_ROOT_DIR}/testcode/sdv/testcase/codecs -name "*.data" | sed -e "s/.data//" | tr -s "\n" " ")
fi
if [[ ${ENABLE_BSL} == "ON" ]]; then
bsl_testsuite=$(find ${HITLS_ROOT_DIR}/testcode/sdv/testcase/bsl -name "*.data" | sed -e "s/.data//" | tr -s "\n" " ")
fi
if [[ ${ENABLE_PKI} == "ON" ]]; then
pki_testsuite=$(find ${HITLS_ROOT_DIR}/testcode/sdv/testcase/pki -name "*.data" | sed -e "s/.data//" | tr -s "\n" " ")
fi
if [[ ${ENABLE_TLS} == "ON" ]]; then
proto_testsuite=$(find ${HITLS_ROOT_DIR}/testcode/sdv/testcase/tls -name "*.data" | sed -e "s/.data//" | tr -s "\n" " ")
fi
if [[ ${ENABLE_AUTH} == "ON" ]]; then
auth_testsuite=$(find ${HITLS_ROOT_DIR}/testcode/sdv/testcase/auth -name "*.data" | sed -e "s/.data//" | tr -s "\n" " ")
fi
if [[ ${ENABLE_CMVP} == "ON" ]]; then
cmvp_testsuite=$(find ${HITLS_ROOT_DIR}/testcode/sdv/testcase/cmvp -name "*.data" | sed -e "s/.data//" | tr -s "\n" " ")
fi
RUN_TEST_SUITES="${crypto_testsuite}${bsl_testsuite}${pki_testsuite}${proto_testsuite}${auth_testsuite}${cmvp_testsuite}"
if [[ ${ENABLE_APP} == "ON" ]]; then
apps_testsuite=$(find ${HITLS_ROOT_DIR}/testcode/sdv/testcase/apps -name "*.data" | sed -e "s/.data//" | tr -s "\n" " ")
RUN_TEST_SUITES="${apps_testsuite}"
fi
}
build_test_suite()
{
build_provider_so
[[ -n ${CASES} ]] && RUN_TEST_SUITES=${CASES}
cd ${HITLS_ROOT_DIR}/testcode && rm -rf ./build && mkdir build && cd build
cmake -DENABLE_GCOV=${ENABLE_GCOV} -DENABLE_ASAN=${ENABLE_ASAN} \
-DCUSTOM_CFLAGS="${CUSTOM_CFLAGS}" -DDEBUG=${DEBUG} -DENABLE_UIO_SCTP=${ENABLE_UIO_SCTP} \
-DGEN_TEST_FILES="${RUN_TEST_SUITES}" -DENABLE_TLS=${ENABLE_TLS} \
-DENABLE_CRYPTO=${ENABLE_CRYPTO} -DENABLE_PKI=${ENABLE_PKI} -DENABLE_AUTH=${ENABLE_AUTH} \
-DTLS_DEBUG=${TLS_DEBUG} -DOS_BIG_ENDIAN=${BIG_ENDIAN} -DPRINT_TO_TERMINAL=${ENABLE_PRINT} \
-DENABLE_FAIL_REPEAT=${ENABLE_FAIL_REPEAT} -DAPPS=${ENABLE_APP} ..
make -j
}
# Function: Compile provider .so file
build_provider_so()
{
cd ${HITLS_ROOT_DIR}/testcode/testdata/provider
mkdir -p build && cd build
cmake ..
make -j
}
process_custom_cases()
{
if [[ -n "${RUN_TESTS}" ]];then
local tmp=($(echo "${RUN_TESTS}" | tr -s "|" " "))
for i in ${!tmp[@]}
do
local suite=$(find ${HITLS_ROOT_DIR}/testcode/sdv -name "${tmp[i]}.data" | sed -e "s/.data//")
[[ -z "${suite}" ]] && echo "not found testsuite:${tmp[i]}"
[[ -n "${suite}" ]] && CASES="${suite} ${CASES}"
done
fi
}
build_demos()
{
if [[ ${ENABLE_DEMOS} == "OFF" ]]; then
return
fi
pushd ${HITLS_ROOT_DIR}/testcode/demo/
rm -rf build && mkdir build
pushd build
cmake -DENABLE_GCOV=${ENABLE_GCOV} -DCUSTOM_CFLAGS="${CUSTOM_CFLAGS}" -DENABLE_ASAN=${ENABLE_ASAN} ../
make -j
popd
popd
}
clean()
{
rm -rf ${HITLS_ROOT_DIR}/testcode/output/log
rm -rf ${HITLS_ROOT_DIR}/testcode/output/test_suite*
rm -rf ${HITLS_ROOT_DIR}/testcode/output/asan.*
rm -rf ${HITLS_ROOT_DIR}/testcode/output/*.log
rm -rf ${HITLS_ROOT_DIR}/testcode/output/*.xml
rm -rf ${HITLS_ROOT_DIR}/testcode/output/gen_testcase
rm -rf ${HITLS_ROOT_DIR}/testcode/output/process
rm -rf ${HITLS_ROOT_DIR}/testcode/framework/tls/build
rm -rf ${HITLS_ROOT_DIR}/testcode/build
rm -rf ${HITLS_ROOT_DIR}/testcode/sdv/build
rm -rf ${HITLS_ROOT_DIR}/testcode/framework/process/build
rm -rf ${HITLS_ROOT_DIR}/testcode/framework/gen_test/build
rm -rf ${HITLS_ROOT_DIR}/testcode/testdata/provider/build
rm -rf ${HITLS_ROOT_DIR}/testcode/testdata/provider/path1
rm -rf ${HITLS_ROOT_DIR}/testcode/testdata/provider/path2
mkdir ${HITLS_ROOT_DIR}/testcode/output/log
}
options()
{
while [[ -n $1 ]]
do
key=${1%%=*}
value=${1#*=}
case ${key} in
add-options)
CUSTOM_CFLAGS="${CUSTOM_CFLAGS} ${value}"
;;
no-provider)
dis_options="--disable feature_provider provider codecs"
;;
tls-debug)
TLS_DEBUG=ON
;;
gcov)
ENABLE_GCOV=ON
;;
asan)
ENABLE_ASAN=ON
;;
no-print)
ENABLE_PRINT=OFF
;;
no-crypto)
ENABLE_CRYPTO=OFF
;;
no-pki)
ENABLE_PKI=OFF
;;
no-auth)
ENABLE_AUTH=OFF
;;
no-bsl)
ENABLE_BSL=OFF
;;
no-tls)
ENABLE_TLS=OFF
;;
no-demos)
ENABLE_DEMOS=OFF
;;
no-sctp)
ENABLE_UIO_SCTP=OFF
;;
no-demos)
ENABLE_DEMOS=OFF
;;
verbose)
ENABLE_VERBOSE='VERBOSE=1'
;;
fail-repeat)
ENABLE_FAIL_REPEAT=ON
;;
run-tests)
RUN_TESTS=${value}
;;
big-endian)
BIG_ENDIAN=ON
;;
include-path)
CUSTOM_CFLAGS="${CUSTOM_CFLAGS} ${value}"
;;
apps)
ENABLE_APP=ON
;;
--help|-h)
usage
exit 0
;;
*)
usage
exit 1
;;
esac
shift
done
}
export_env
options "$@"
clean
down_depend_code
find_test_suite
process_custom_cases
build_test_suite
if [[ ${ENABLE_DEMOS} == "ON" ]]; then
build_demos
fi
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/script/build_sdv.sh | Shell | unknown | 10,063 |
#!/bin/bash
# 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.
elapsed=0
cd ../../
HITLS_ROOT_DIR=`pwd`
paramList=$@
paramNum=$#
is_concurrent=1
need_run_all=1
threadsNum=$(grep -c ^processor /proc/cpuinfo)
testsuite_array=()
testcase_array=()
export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:$(realpath ${HITLS_ROOT_DIR}/build):$(realpath ${HITLS_ROOT_DIR}/platform/Secure_C/lib)
# Check whether an ASAN alarm is generated.
generate_asan_log() {
ASAN_LOG=$(find ../output -name "asan.log*")
if [ ! -z "$ASAN_LOG" ]; then
for i in $ASAN_LOG
do
if grep -q "ASan doesn't fully support makecontext/swapcontext" $i
then
line_count=$(wc -l < "$i")
if [ "$line_count" -eq 1 ]; then
echo "The ASAN log contains only ucontext warning content. Ignore it."
else
echo "ASAN ERROR. Exit with ucontext check failure."
cat ${i}
exit 1
fi
continue
else
echo "ASAN ERROR. Exit with failure."
cat ${i}
exit 1
fi
done
fi
}
# Run the specified test suites or test cases in the output directory.
run_test() {
cd ${HITLS_ROOT_DIR}/testcode/output
export ASAN_OPTIONS=detect_stack_use_after_return=1:strict_string_checks=1:detect_leaks=1:halt_on_error=0:detect_odr_violation=0:log_path=asan.log
echo ""
echo "Begin Test"
echo ".................................................."
start_time=$(date +%s)
# Run the specified test suite.
if [ ${#testsuite_array[*]} -ne 0 ] && [ ${#testcase_array[*]} -eq 0 ];then
for i in ${testsuite_array[@]}
do
if [ "${i}" = "test_suite_sdv_eal_provider_load" ]; then
# 针对特定测试套件设置 LD_LIBRARY_PATH
echo "Running ${i} with LD_LIBRARY_PATH set to ../testdata/provider/path1"
env LD_LIBRARY_PATH="../testdata/provider/path1:${LD_LIBRARY_PATH}" ./${i} NO_DETAIL
else
# 其他测试套件正常运行
./${i} NO_DETAIL
fi
done
fi
# Run the specified test case.
if [ ${#testcase_array[*]} -ne 0 ];then
num=0
for i in ${testcase_array[@]}
do
./${testsuite_array[num]} ${i}
let num+=1
done
fi
end_time=$(date +%s)
elapsed=$((end_time - start_time))
generate_asan_log
}
gen_test_report()
{
cd ${HITLS_ROOT_DIR}/testcode/output
./gen_testcase GenReport
testcase_num=0
pass_num=0
skip_num=0
while read line
do
array=(${line})
last_index=$((${#array[@]}-1))
if [ "${array[last_index]}" = "PASS" ]; then
let pass_num+=1
elif [ "${array[last_index]}" = "SKIP" ]; then
let skip_num+=1
fi
let testcase_num+=1
done < result.log
fail_num=`expr $testcase_num - $pass_num - $skip_num`
SumTime=`echo "$elapsed 60" |awk '{printf("%.2f",$1/$2)}'`
echo "SumTime is ${SumTime} mintues TestCase Num is ${testcase_num} Pass is ${pass_num} Skip is ${skip_num} Fail is ${fail_num}"
if [ ${fail_num} -ne 0 ]; then
exit 1
fi
}
# Run all tests in the output directory.
run_all() {
start_time=$(date +%s)
echo "Test: $1" >> ${HITLS_ROOT_DIR}/testcode/output/time.txt
echo "Start: $(date)" >> ${HITLS_ROOT_DIR}/testcode/output/time.txt
cd ${HITLS_ROOT_DIR}/testcode/output
SUITES=$(ls ./ | grep .datax | sed -e "s/.datax//")
export ASAN_OPTIONS=detect_stack_use_after_return=1:strict_string_checks=1:detect_leaks=1:halt_on_error=0:detect_odr_violation=0:log_path=asan.log
echo ""
echo "Begin Test"
echo ".................................................."
if [ $is_concurrent = 1 ]; then
mkfifo tmppipe
exec 5<>tmppipe
rm -f tmppipe
echo "threadsNum = $threadsNum"
# procNum indicates the maximum number of concurrent processes.
for ((i=1;i<=$threadsNum;i++)); do
echo >&5
done
retPipe=$tmpPipe.ret
mkfifo $retPipe
exec 8<>$retPipe
rm -f $retPipe
echo "0" >&8
for i in $SUITES
do
# Run tests in parallel.
read -u5
{
if [ "${i}" = "test_suite_sdv_eal_provider_load" ]; then
echo "Running ${i} with LD_LIBRARY_PATH set to ../testdata/provider/path1"
env LD_LIBRARY_PATH="../testdata/provider/path1:${LD_LIBRARY_PATH}" ./${i} NO_DETAIL || (read -u8 && echo "1 $i" >&8)
else
./${i} NO_DETAIL || (read -u8 && echo "1 $i" >&8)
fi
echo >&5
} &
done
wait
exec 5>&-
exec 5<&-
read -u8 ret
exec 8<&-
if [ "$ret" != "0" ];then
echo "some case failed $ret"
gen_test_report
generate_asan_log
exit 1
fi
else
for i in $SUITES
do
if [ "${i}" = "test_suite_sdv_eal_provider_load" ]; then
echo "Running ${i} with LD_LIBRARY_PATH set to ../testdata/provider/path1"
env LD_LIBRARY_PATH="../testdata/provider/path1:${LD_LIBRARY_PATH}" ./${i} NO_DETAIL
else
./${i} NO_DETAIL
fi
done
fi
end_time=$(date +%s)
echo "End: $(date)" >> time.txt
elapsed=$((end_time - start_time))
eval "echo Elapsed time: $(date -ud "@$elapsed" +'$((%s/3600/24)) days %H hr %M min %S sec') >> time.txt"
generate_asan_log
}
parse_testsuite_testcase()
{
cd ${HITLS_ROOT_DIR}/testcode/output
testsuite_name="test_suite"
if [[ "$1" == *$testsuite_name* ]]; then
if [ -f "$1" ]; then
testsuite_array[${#testsuite_array[*]}]=$i
return 1
fi
return 0
else
testsuite=`grep -l $1 *.c`
if [ "${testsuite}" = "" ]; then
return 0
else
array=(${testsuite//./ })
testsuite_array[${#testcase_array[*]}]="${array[0]}"
testcase_array[${#testcase_array[*]}]="$1"
return 1
fi
fi
}
parse_option()
{
for i in $paramList
do
case "$i" in
"help")
printf "Note: Before Run <sh ${BASH_SOURCE[0]}>, Please Fisrt Run <sh build_hitls.sh && sh build_sdv.sh>"
printf "%-50s %-30s\n" "Run All Testsuites Of The Output" "sh ${BASH_SOURCE[0]}"
printf "%-50s %-30s\n" "Run The Specified Testsuite" "sh ${BASH_SOURCE[0]} test_suites_xxx test_suites_xxx"
printf "%-50s %-30s\n" "Run The Specified Testcase" "sh ${BASH_SOURCE[0]} UT_CRYPTO_xxx SDV_CRYPTO_xxx"
printf "%-50s %-30s\n" "Set Thread Pool Size" "sh ${BASH_SOURCE[0]} threads=N"
printf "%-50s %-30s\n" "Example: Run with 4 threads" "sh ${BASH_SOURCE[0]} threads=4"
exit 0
;;
"threads"*)
threads_num=${i#*=}
threadsNum=$threads_num
;;
*)
parse_testsuite_testcase $i
if [ $? -eq 0 ]; then
echo "Not Find This Testsuite or Testcase : ${i}"
exit 1
fi
need_run_all=0
;;
esac
done
}
run_demos()
{
exit_code=$?
pushd ${HITLS_ROOT_DIR}/testcode/demo/build
executales=$(find ./ -maxdepth 1 -type f -perm -a=x )
for e in $executales
do
if [[ ! "$e" == *"client"* ]] && [[ ! "$e" == *"server"* ]]; then
echo "${e} start"
eval "${e}"
if [ $exit_code -ne 0 ]; then
echo "Demo ${e} failed"
exit 1
fi
fi
done
# run server and client in order.
./server &
if [ $exit_code -ne 0 ]; then
echo "Demo ${e} failed"
exit 1
fi
sleep 1
./client
if [ $exit_code -ne 0 ]; then
echo "Demo ${e} failed"
exit 1
fi
# run tlcp server and client in order.
./tlcp_server &
if [ $exit_code -ne 0 ]; then
echo "Demo ${e} failed"
exit 1
fi
sleep 1
./tlcp_client
if [ $exit_code -ne 0 ]; then
echo "Demo ${e} failed"
exit 1
fi
popd
}
clean()
{
rm -rf ${HITLS_ROOT_DIR}/testcode/output/log/*
rm -rf ${HITLS_ROOT_DIR}/testcode/output/result.log
rm -rf ${HITLS_ROOT_DIR}/testcode/output/*.sock*
rm -rf ${HITLS_ROOT_DIR}/testcode/output/asan*
}
clean
parse_option
if [ ${need_run_all} -eq 1 ]; then
run_all
run_demos
else
run_test
fi
gen_test_report
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/script/execute_sdv.sh | Shell | unknown | 9,379 |
#!/bin/bash
# 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.
# Build different miniaturized targets and perform basic functional testing.
set -eu
PARAM_LIST=$@
CUR_DIR=`pwd`
HITLS_ROOT_DIR=`realpath $CUR_DIR/../../`
HITLS_BUILD_DIR=$HITLS_ROOT_DIR/build
FEATURES=()
TEST_FEATURE=""
BUILD_HITLS="on"
EXE_TEST="on"
SHOW_SIZE="on" # size libhitls_*.a
SHOW_MACRO="off"
ASM_TYPE=""
NO_LIB=""
LIB_TYPE="static"
DEBUG="off"
ADD_OPTIONS=""
DEL_OPTIONS=""
SYSTEM=""
BITS=64
ENDIAN="little"
FEATURE_CONFIG_FILE=""
INCLUDE_PATH=""
print_usage() {
printf "Usage: $0\n"
printf " %-25s %s\n" "help" "Print this help."
printf " %-25s %s\n" "macro" "INFO: Obtains the macro of the hitls."
printf " %-25s %s\n" "no-size" "INFO: Do not list the detail of the object files in static libraries."
printf " %-25s %s\n" "no-build" "BUILD: Do not build hitls."
printf " %-25s %s\n" "enable=a;b;c" "BUILD: Specify the features of the build."
printf " %-25s %s\n" "x8664|armv8" "BUILD: Specify the type of assembly to build."
printf " %-25s %s\n" "linux|dopra" "BUILD: Specify the type of system to build."
printf " %-25s %s\n" "32" "BUILD: Specify the number of system bits to 32, default is 64."
printf " %-25s %s\n" "big" "BUILD: Specify the endian mode of the system to big, default is little."
printf " %-25s %s\n" "debug" "BUILD: Build HiTLS with debug flags."
printf " %-25s %s\n" "asan" "BUILD: Build HiTLS with asan flags."
printf " %-25s %s\n" "test=a" "TEST: Specify the feature for which the test is to be performed."
printf " %-25s %s\n" "no-tls" "TEST: Do not link hitls_tls related libraries."
printf " %-25s %s\n" "no-crypto" "TEST: Do not link hitls_crypto related libraries."
printf " %-25s %s\n" "no-mpa" "TEST: Do not link hitls_mpa related libraries."
printf " %-25s %s\n" "no-exe-test" "TEST: Do not exe tests."
printf "\nexample:\n"
printf " %-50s %-30s\n" "bash mini_build_test.sh enable=sha1,sha2,sha3 test=sha1,sha3" "Build sha1, sha2 and sha3, test sha1 and sha2."
printf " %-50s %-30s\n" "bash mini_build_test.sh enable=sha1,sm3 armv8" "Build sha1 and sm3 and enable armv8 assembly."
}
parse_option()
{
for i in $PARAM_LIST
do
key=${i%%=*}
value=${i#*=}
case "${key}" in
"help")
print_usage
exit 0;
;;
"macro")
SHOW_MACRO="on"
ADD_OPTIONS="${ADD_OPTIONS} -E -dM"
LIB_TYPE="static"
;;
"no-size")
SHOW_SIZE="off"
;;
"no-build")
BUILD_HITLS="off"
;;
"x8664"|"armv8")
ASM_TYPE=$key
;;
"linux"|"dopra")
SYSTEM=$key
;;
"32")
BITS=32
;;
"big")
ENDIAN="big"
;;
"enable")
FEATURES=(${value//,/ })
;;
"debug")
ADD_OPTIONS="$ADD_OPTIONS -O0 -g3 -gdwarf-2"
DEL_OPTIONS="$DEL_OPTIONS -O2 -D_FORTIFY_SOURCE=2"
;;
"asan")
ADD_OPTIONS="$ADD_OPTIONS -fsanitize=address -fsanitize-address-use-after-scope -O0 -g3 -fno-stack-protector -fno-omit-frame-pointer -fgnu89-inline"
DEL_OPTIONS="$DEL_OPTIONS -fstack-protector-strong -fomit-frame-pointer -O2 -D_FORTIFY_SOURCE=2"
;;
"feature-config")
# First try to find file with ASM_TYPE suffix
if [ -n "$ASM_TYPE" ]; then
FEATURE_CONFIG_FILE=$(find $HITLS_ROOT_DIR -name "${value}_${ASM_TYPE}.json" -type f | head -n 1)
fi
# If not found with suffix, try the original filename
if [ -z "$FEATURE_CONFIG_FILE" ]; then
FEATURE_CONFIG_FILE=$(find $HITLS_ROOT_DIR -name "${value}.json" -type f | head -n 1)
fi
if [ -z "$FEATURE_CONFIG_FILE" ]; then
echo "Error: Cannot find feature config file '${value}.json' or '${value}.json' under $HITLS_ROOT_DIR"
exit 1
fi
;;
"test")
LIB_TYPE="static shared"
TEST_FEATURE=$value
if [[ $value == *cmvp* ]]; then
ADD_OPTIONS="$ADD_OPTIONS -DHITLS_CRYPTO_DRBG_GM -DHITLS_CRYPTO_CMVP_INTEGRITY"
fi
;;
"no-exe-test")
EXE_TEST="off"
;;
"no-tls")
NO_LIB="$NO_LIB no-tls"
;;
"no-crypto")
NO_LIB="$NO_LIB no-crypto"
;;
"no-mpa")
NO_LIB="$NO_LIB no-mpa"
;;
"add-options")
ADD_OPTIONS="$ADD_OPTIONS $value"
;;
"include-path")
INCLUDE_PATH="$value $INCLUDE_PATH "
ADD_OPTIONS="$ADD_OPTIONS $value"
;;
*)
echo "Wrong parameter: $key"
exit 1
;;
esac
done
}
show_size()
{
cd $HITLS_BUILD_DIR
libs=`find -name '*.a'`
echo "$libs"
array=(${libs//\n/ })
for lib in ${array[@]}
do
ls -lh ${lib}
echo -e ""
size ${lib} | grep -v "0 0 0 0 0"
done
}
show_macro()
{
cd ${HITLS_BUILD_DIR}
grep "#define HITLS_" libhitls_bsl.a | grep -v HITLS_VERSION |awk '{print $2}' > macro_new.txt
sort macro_new.txt | uniq >unique_macro.txt
cat unique_macro.txt
}
process_feature_config()
{
local config_file="$1"
local endian="$2"
local bits="$3"
local asm_type="$4"
local build_dir="$5"
python3 - "$config_file" "$endian" "$bits" "$asm_type" "$build_dir" <<END
#!/usr/bin/env python
import json
import sys
import os
if __name__ == "__main__":
config_file = sys.argv[1]
endian = sys.argv[2]
bits = int(sys.argv[3])
asm_type = sys.argv[4] if len(sys.argv) > 4 and sys.argv[4] else None
build_dir = sys.argv[5]
# Read the current config
with open(config_file, 'r') as f:
config = json.load(f)
# Update the fields
config['endian'] = endian
config['bits'] = bits
if asm_type:
config['asmType'] = asm_type
else:
# If no asm_type is defined, remove the "asm" field from hitls_crypto
config['asmType'] = "no_asm"
if 'libs' in config and 'hitls_crypto' in config['libs'] and 'asm' in config['libs']['hitls_crypto']:
del config['libs']['hitls_crypto']['asm']
# Create build directory if it doesn't exist
os.makedirs(build_dir, exist_ok=True)
# Save to build directory
output_file = os.path.join(build_dir, 'feature_config_modified.json')
with open(output_file, 'w') as f:
json.dump(config, f, indent=4)
# Print the output file path for the shell script to use
print(output_file)
END
}
mini_config()
{
enables="--enable"
for feature in ${FEATURES[@]}
do
enables="$enables $feature"
done
if [ "$FEATURE_CONFIG_FILE" != "" ]; then
MODIFIED_CONFIG_FILE=$(process_feature_config "$FEATURE_CONFIG_FILE" "$ENDIAN" "$BITS" "$ASM_TYPE" "$HITLS_ROOT_DIR/build/")
enables="--feature_config $MODIFIED_CONFIG_FILE"
fi
echo "python3 configure.py --lib_type $LIB_TYPE $enables --endian=$ENDIAN --bits=$BITS"
python3 $HITLS_ROOT_DIR/configure.py --lib_type $LIB_TYPE $enables --endian=$ENDIAN --bits=$BITS
if [ "$ASM_TYPE" != "" ]; then
echo "python3 configure.py --asm_type $ASM_TYPE"
python3 $HITLS_ROOT_DIR/configure.py --asm_type $ASM_TYPE
fi
if [ "$SYSTEM" != "" ]; then
echo "python3 configure.py --system $SYSTEM"
python3 $HITLS_ROOT_DIR/configure.py --system $SYSTEM
fi
if [ "$ADD_OPTIONS" != "" -o "$DEL_OPTIONS" != "" ]; then
echo "python3 configure.py --add_options=\"$ADD_OPTIONS\" --del_options=\"$DEL_OPTIONS\""
python3 $HITLS_ROOT_DIR/configure.py --add_options="$ADD_OPTIONS" --del_options="$DEL_OPTIONS"
fi
}
check_cmd_res()
{
if [ "$?" -ne "0" ]; then
echo "Error: $1"
exit 1
fi
}
build_hitls()
{
# cleanup
cd $HITLS_ROOT_DIR
rm -rf $HITLS_BUILD_DIR
mkdir $HITLS_BUILD_DIR
cd $HITLS_BUILD_DIR
# config
mini_config
check_cmd_res "configure.py"
# cmake ..
cmake .. > cmake.txt
# cmake ..
check_cmd_res "cmake .."
# make
make -j > make.txt
check_cmd_res "make -j"
}
get_testfiles_by_features()
{
cd $HITLS_ROOT_DIR/testcode/test_config
# 参数：被测试的特性列表（以逗号分隔）
python3 - "$1" <<END
#!/usr/bin/env python
import os, sys, json
if __name__ == "__main__":
with open('crypto_test_config.json', 'r') as f:
test_config1 = json.loads(f.read())
with open('tls_test_config.json', 'r') as f:
test_config2 = json.loads(f.read())
files = set()
for fea in sys.argv[1].split(","):
files.update(test_config1['testFeatures'].get(fea, ''))
files.update(test_config2['testFeatures'].get(fea, ''))
sys.stdout.write('%s' % '|'.join(files))
END
}
get_testcases_by_testfile()
{
cd $HITLS_ROOT_DIR/testcode/test_config/
# 参数：测试文件，获取需执行的测试用例
python3 - "$1" <<END
#!/usr/bin/env python
import os, sys, json
if __name__ == "__main__":
with open('crypto_test_config.json', 'r') as f:
test_config1 = json.loads(f.read())
with open('tls_test_config.json', 'r') as f:
test_config2 = json.loads(f.read())
if sys.argv[1] not in test_config1['testSuiteCases'] and sys.argv[1] not in test_config2['testSuiteCases']:
raise ValueError('The test case of file %s is not configured in file crypto_test_config.json or tls_test_config.json.'% sys.argv[1])
cases = set()
if sys.argv[1] in test_config1['testSuiteCases']:
cases.update(test_config1['testSuiteCases'][sys.argv[1]])
if sys.argv[1] in test_config2['testSuiteCases']:
cases.update(test_config2['testSuiteCases'][sys.argv[1]])
sys.stdout.write('%s' % ' '.join(cases))
END
}
exe_file_testcases()
{
test_file=$1
# Get test cases according to test file.
cd $HITLS_ROOT_DIR/testcode/script
test_cases=`get_testcases_by_testfile $test_file`
echo "test cases: $test_cases"
cd $HITLS_ROOT_DIR/testcode/output
./$test_file ${test_cases} NO_DETAIL
check_cmd_res "exe $test_file failed"
}
test_feature()
{
features=$1
cd $HITLS_ROOT_DIR/testcode/script
files=`get_testfiles_by_features $features`
echo "files: $files"
if [ -z $files ]; then
return
fi
params=""
if [ "$INCLUDE_PATH" != "" ]; then
params="${params} include-path=$INCLUDE_PATH"
fi
bash build_sdv.sh run-tests="$files" $NO_LIB no-demos no-sctp $params
if [ $EXE_TEST == "on" ]; then
# exe test
file_array=(${files//|/ })
for file in ${file_array[@]}
do
exe_file_testcases $file
done
fi
}
parse_option
# build securec
if [ ! -d "${HITLS_ROOT_DIR}/platform/Secure_C/lib" ]; then
cd ${HITLS_ROOT_DIR}/platform/Secure_C
make -j
fi
if [ "${BUILD_HITLS}" = "on" ]; then
build_hitls
fi
if [ "${SHOW_SIZE}" = "on" ]; then
show_size
fi
if [ "${SHOW_MACRO}" = "on" ]; then
show_macro
exit 0
fi
if [ "$TEST_FEATURE" != "" ]; then
test_feature $TEST_FEATURE
fi
| 2302_82127028/openHiTLS-examples_5062_4009 | testcode/script/mini_build_test.sh | Shell | unknown | 12,460 |
#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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | 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_5062_4009 | testcode/sdv/testcase/bsl/sal/test_suite_sdv_sal_atomic.c | C | unknown | 3,144 |