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 |
|---|---|---|---|---|---|
/*
* SM9 Benchmark - Following benchmark framework pattern
* 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 <stddef.h>
#include <string.h>
#include <stdlib.h>
#include "crypt_algid.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_md.h"
#include "crypt_util_rand.h"
#include "crypt_params_key.h"
#include "bsl_params.h"
#include "benchmark.h"
#define SM9_SIGNATURE_LEN 96
#define SM9_KEY_TYPE_SIGN 1
#define SM9_KEY_TYPE_ENC 2
// SM9 context structure
typedef struct {
CRYPT_EAL_PkeyCtx *ctx;
uint8_t sign[SM9_SIGNATURE_LEN];
uint32_t signLen;
uint8_t ciphertext[256];
uint32_t cipherLen;
} Sm9Context;
// Test data
static unsigned char g_msg[] = "Hello SM9 Benchmark!";
static unsigned char g_plaintext[] = "Secret Message for SM9 Encryption Test";
// Master keys
static unsigned char g_sig_master_key[32] = {
0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF
};
static unsigned char g_enc_master_key[32] = {
0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10
};
static unsigned char g_user_id[] = "BenchmarkUser";
// Random number generator callback
static int32_t RandFunc(uint8_t *randNum, uint32_t randLen)
{
for (uint32_t i = 0; i < randLen; i++) {
randNum[i] = (uint8_t)(rand() % 255);
}
return 0;
}
static int32_t Sm9SetUp(void **ctx, BenchCtx *bench, const CtxOps *ops, int32_t paraId)
{
(void)paraId;
int32_t ret;
BSL_Param params[3];
int32_t keyType;
// Allocate context structure
Sm9Context *sm9Ctx = (Sm9Context *)malloc(sizeof(Sm9Context));
if (sm9Ctx == NULL) {
printf("Failed to allocate SM9 context\n");
return CRYPT_MEM_ALLOC_FAIL;
}
memset(sm9Ctx, 0, sizeof(Sm9Context));
// Register random number generator
CRYPT_RandRegist(RandFunc);
// Create SM9 context
sm9Ctx->ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SM9);
if (sm9Ctx->ctx == NULL) {
printf("Failed to create SM9 pkey context\n");
free(sm9Ctx);
return CRYPT_MEM_ALLOC_FAIL;
}
// Determine key type based on operation
// For sign/verify: use signature master key
// For enc/dec: use encryption master key
if (ops->opsNum > 0) {
// Check if this is sign/verify (default to sign for now)
keyType = SM9_KEY_TYPE_SIGN;
// Set master key
BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_SM9_MASTER_KEY, BSL_PARAM_TYPE_OCTETS,
g_sig_master_key, sizeof(g_sig_master_key));
BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_SM9_KEY_TYPE, BSL_PARAM_TYPE_INT32,
&keyType, sizeof(int32_t));
params[2] = (BSL_Param)BSL_PARAM_END;
ret = CRYPT_EAL_PkeySetPubEx(sm9Ctx->ctx, params);
if (ret != CRYPT_SUCCESS) {
printf("Failed to set SM9 master key: %d\n", ret);
CRYPT_EAL_PkeyFreeCtx(sm9Ctx->ctx);
free(sm9Ctx);
return ret;
}
// Generate user key
BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_SM9_USER_ID, BSL_PARAM_TYPE_OCTETS,
g_user_id, strlen((char*)g_user_id));
BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_SM9_KEY_TYPE, BSL_PARAM_TYPE_INT32,
&keyType, sizeof(int32_t));
params[2] = (BSL_Param)BSL_PARAM_END;
ret = CRYPT_EAL_PkeySetPrvEx(sm9Ctx->ctx, params);
if (ret != CRYPT_SUCCESS) {
printf("Failed to set SM9 user key: %d\n", ret);
CRYPT_EAL_PkeyFreeCtx(sm9Ctx->ctx);
free(sm9Ctx);
return ret;
}
}
*ctx = sm9Ctx;
return CRYPT_SUCCESS;
}
static void Sm9TearDown(void *ctx)
{
if (ctx == NULL) {
return;
}
Sm9Context *sm9Ctx = (Sm9Context *)ctx;
if (sm9Ctx->ctx != NULL) {
CRYPT_EAL_PkeyFreeCtx(sm9Ctx->ctx);
}
free(sm9Ctx);
}
static int32_t Sm9KeyGen(void *ctx, BenchCtx *bench, BenchOptions *opts)
{
// SM9 doesn't use traditional key generation like RSA/ECC
// Keys are derived from master key + user ID
// This operation is already done in SetUp
(void)ctx;
(void)bench;
(void)opts;
return CRYPT_SUCCESS;
}
static int32_t Sm9Sign(void *ctx, BenchCtx *bench, BenchOptions *opts)
{
Sm9Context *sm9Ctx = (Sm9Context *)ctx;
int rc = CRYPT_SUCCESS;
sm9Ctx->signLen = SM9_SIGNATURE_LEN;
BENCH_TIMES(
CRYPT_EAL_PkeySign(sm9Ctx->ctx, CRYPT_MD_SM3, g_msg, sizeof(g_msg),
sm9Ctx->sign, &sm9Ctx->signLen),
rc, CRYPT_SUCCESS, sizeof(g_msg), opts->times, "sm9 sign"
);
return rc;
}
static int32_t Sm9Verify(void *ctx, BenchCtx *bench, BenchOptions *opts)
{
Sm9Context *sm9Ctx = (Sm9Context *)ctx;
int rc = CRYPT_SUCCESS;
// First generate a signature to verify
sm9Ctx->signLen = SM9_SIGNATURE_LEN;
rc = CRYPT_EAL_PkeySign(sm9Ctx->ctx, CRYPT_MD_SM3, g_msg, sizeof(g_msg),
sm9Ctx->sign, &sm9Ctx->signLen);
if (rc != CRYPT_SUCCESS) {
printf("Failed to generate signature for verify benchmark: %d\n", rc);
return rc;
}
BENCH_TIMES(
CRYPT_EAL_PkeyVerify(sm9Ctx->ctx, CRYPT_MD_SM3, g_msg, sizeof(g_msg),
sm9Ctx->sign, sm9Ctx->signLen),
rc, CRYPT_SUCCESS, sizeof(g_msg), opts->times, "sm9 verify"
);
return rc;
}
static int32_t Sm9Enc(void *ctx, BenchCtx *bench, BenchOptions *opts)
{
Sm9Context *sm9Ctx = (Sm9Context *)ctx;
int rc = CRYPT_SUCCESS;
// Need to reconfigure context for encryption
BSL_Param params[3];
int32_t keyType = SM9_KEY_TYPE_ENC;
// Set encryption master key
BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_SM9_MASTER_KEY, BSL_PARAM_TYPE_OCTETS,
g_enc_master_key, sizeof(g_enc_master_key));
BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_SM9_KEY_TYPE, BSL_PARAM_TYPE_INT32,
&keyType, sizeof(int32_t));
params[2] = (BSL_Param)BSL_PARAM_END;
rc = CRYPT_EAL_PkeySetPubEx(sm9Ctx->ctx, params);
if (rc != CRYPT_SUCCESS) {
return rc;
}
// Set user key for encryption
BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_SM9_USER_ID, BSL_PARAM_TYPE_OCTETS,
g_user_id, strlen((char*)g_user_id));
BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_SM9_KEY_TYPE, BSL_PARAM_TYPE_INT32,
&keyType, sizeof(int32_t));
params[2] = (BSL_Param)BSL_PARAM_END;
rc = CRYPT_EAL_PkeySetPrvEx(sm9Ctx->ctx, params);
if (rc != CRYPT_SUCCESS) {
return rc;
}
sm9Ctx->cipherLen = sizeof(sm9Ctx->ciphertext);
BENCH_TIMES(
CRYPT_EAL_PkeyEncrypt(sm9Ctx->ctx, g_plaintext, sizeof(g_plaintext),
sm9Ctx->ciphertext, &sm9Ctx->cipherLen),
rc, CRYPT_SUCCESS, sizeof(g_plaintext), opts->times, "sm9 encrypt"
);
return rc;
}
static int32_t Sm9Dec(void *ctx, BenchCtx *bench, BenchOptions *opts)
{
Sm9Context *sm9Ctx = (Sm9Context *)ctx;
int rc = CRYPT_SUCCESS;
uint8_t decrypted[256];
uint32_t decryptLen = sizeof(decrypted);
// Need to reconfigure context for encryption (same as Enc)
BSL_Param params[3];
int32_t keyType = SM9_KEY_TYPE_ENC;
BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_SM9_MASTER_KEY, BSL_PARAM_TYPE_OCTETS,
g_enc_master_key, sizeof(g_enc_master_key));
BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_SM9_KEY_TYPE, BSL_PARAM_TYPE_INT32,
&keyType, sizeof(int32_t));
params[2] = (BSL_Param)BSL_PARAM_END;
rc = CRYPT_EAL_PkeySetPubEx(sm9Ctx->ctx, params);
if (rc != CRYPT_SUCCESS) {
return rc;
}
BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_SM9_USER_ID, BSL_PARAM_TYPE_OCTETS,
g_user_id, strlen((char*)g_user_id));
BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_SM9_KEY_TYPE, BSL_PARAM_TYPE_INT32,
&keyType, sizeof(int32_t));
params[2] = (BSL_Param)BSL_PARAM_END;
rc = CRYPT_EAL_PkeySetPrvEx(sm9Ctx->ctx, params);
if (rc != CRYPT_SUCCESS) {
return rc;
}
// First encrypt to get ciphertext
sm9Ctx->cipherLen = sizeof(sm9Ctx->ciphertext);
rc = CRYPT_EAL_PkeyEncrypt(sm9Ctx->ctx, g_plaintext, sizeof(g_plaintext),
sm9Ctx->ciphertext, &sm9Ctx->cipherLen);
if (rc != CRYPT_SUCCESS) {
printf("Failed to generate ciphertext for decrypt benchmark: %d\n", rc);
return rc;
}
BENCH_TIMES(
CRYPT_EAL_PkeyDecrypt(sm9Ctx->ctx, sm9Ctx->ciphertext, sm9Ctx->cipherLen,
decrypted, &decryptLen),
rc, CRYPT_SUCCESS, sizeof(g_plaintext), opts->times, "sm9 decrypt"
);
return rc;
}
static int32_t Sm9KeyDerive(void *ctx, BenchCtx *bench, BenchOptions *opts)
{
// SM9 key exchange/derivation would require two contexts
// For now, return success (can be implemented later if needed)
(void)ctx;
(void)bench;
(void)opts;
return CRYPT_SUCCESS;
}
DEFINE_OPS(Sm9, CRYPT_PKEY_SM9, 0);
DEFINE_BENCH_CTX_FIXLEN(Sm9);
| 2401_83913325/openHiTLS_1 | testcode/benchmark/sm9_bench.c | C | unknown | 9,923 |
/*
* 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 <signal.h>
#include <stdarg.h>
#include <unistd.h>
#include "securec.h"
#define BUF_SIZE (65536 * 17)
#define MAX_RAND_SIZE (1024 * 16)
#define MAX_PATH 1024
#define MAX_FILE_NAME 200
#define MAX_IN_CASES 100000
#define OUTPUT_LINE_LENGTH 60
#ifdef FAIL_REPEAT_RUN
#define FAIL_TRY_TIMES 3
#else
#define FAIL_TRY_TIMES 0
#endif
#define FUNCTION_LOG_FORMAT "./log/%s.%s.log"
#define SUITE_LOG_FORMAT "./log/%s.log"
#define LOCAL_DIR "./"
typedef struct {
char buf[MAX_DATA_LINE_LEN];
char *arg[MAX_ARGUMENT_COUNT];
char testVectorName[MAX_FILE_NAME];
uint32_t argLen;
} TestArgs;
typedef struct {
void *param[MAX_ARGUMENT_COUNT];
int paramCount;
int intParam[MAX_ARGUMENT_COUNT];
int intParamCount;
Hex hexParam[MAX_ARGUMENT_COUNT];
int hexParamCount;
} TestParam;
static TestArgs *g_executeCases[MAX_IN_CASES];
static int g_executeCount = 0;
static int ConvertStringCase(const TestArgs *arg)
{
for (uint32_t i = 1; i < arg->argLen; i += 2) {
if (strcmp(arg->arg[i], "char") == 0 || strcmp(arg->arg[i], "Hex") == 0) {
if (ConvertString((char **)&(arg->arg[i+1])) != 0) {
return 1;
}
}
}
return 0;
}
static int LoadDataFile(const char *fileName)
{
if (g_executeCount > 0) {
return 0;
}
FILE *fpDatax = fopen(fileName, "r");
if (fpDatax == NULL) {
Print("Error opening file\n");
return (-1);
}
int rt = 0;
for (int i = 0; i < MAX_IN_CASES; i++) {
g_executeCases[i] = (TestArgs *)malloc(sizeof(TestArgs));
if (g_executeCases[i] == NULL) {
rt = -1;
goto EXIT;
}
g_executeCases[i]->argLen = MAX_ARGUMENT_COUNT;
if (ReadLine(fpDatax, g_executeCases[i]->testVectorName, MAX_FILE_NAME, 1, 1) != 0) {
free(g_executeCases[i]);
goto EXIT;
}
if (ReadLine(fpDatax, g_executeCases[i]->buf, MAX_DATA_LINE_LEN, 1, 1) != 0) {
free(g_executeCases[i]);
Print("Read vector failed, test vector should have 2 lines, here there's only one\n");
rt = -1;
goto EXIT;
}
if (SplitArguments(g_executeCases[i]->buf, strlen(g_executeCases[i]->buf),
g_executeCases[i]->arg, &(g_executeCases[i]->argLen)) != 0) {
free(g_executeCases[i]);
rt = -1;
goto EXIT;
}
if (ConvertStringCase(g_executeCases[i]) == 1) {
free(g_executeCases[i]);
rt = -1;
goto EXIT;
}
g_executeCount += 1;
}
char tmpName[MAX_FILE_NAME];
if (ReadLine(fpDatax, tmpName, MAX_FILE_NAME, 1, 1) == 0) {
Print("More test cases than max case num %d\n", MAX_IN_CASES);
rt = -1;
}
EXIT:
if (rt != 0) {
for (int i = 0; i < g_executeCount; i++) {
free(g_executeCases[i]);
}
g_executeCount = 0;
}
(void)fclose(fpDatax);
return rt;
} | 2401_83913325/openHiTLS_1 | testcode/common/execute_base.c | C | unknown | 3,546 |
/*
* 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 <setjmp.h>
#include <time.h>
#include <sys/time.h>
static sigjmp_buf env;
static int isSubProc = 0;
int *GetJmpAddress(void)
{
return &isSubProc;
}
void handleSignal()
{
siglongjmp(env, 1);
}
static void PrintCaseName(FILE *logFile, bool showDetail, const char *name)
{
// print a minimum of 4 dots
int32_t dotCount = (OUTPUT_LINE_LENGTH - (int32_t)strlen(name) >= 4) ?
(OUTPUT_LINE_LENGTH - (int32_t)strlen(name)) : 4;
if (showDetail) {
Print("%s", name);
for (int32_t j = 0; j < dotCount; j++) {
Print(".");
}
}
(void)fprintf(logFile, "%s", name);
for (int32_t j = 0; j < dotCount; j++) {
(void)fprintf(logFile, ".");
}
}
static int ParseArgs(const TestArgs *arg, TestParam *info)
{
info->hexParamCount = 0;
info->intParamCount = 0;
info->paramCount = 0;
for (uint32_t i = 1; i < arg->argLen; i += 2) { // 2
if (strcmp(arg->arg[i], "int") == 0) {
if (ConvertInt(arg->arg[i + 1], &(info->intParam[info->intParamCount])) == 0) {
info->param[info->paramCount] = &(info->intParam[info->intParamCount]);
info->intParamCount++;
} else {
Print("\nERROR: Int param conversion failed for:\n\"%s\"\n", arg->arg[i + 1]);
return 1;
}
} else if (strcmp(arg->arg[i], "char") == 0) {
info->param[info->paramCount] = arg->arg[i+1];
} else if (strcmp(arg->arg[i], "Hex") == 0) {
if (ConvertHex(arg->arg[i + 1], &(info->hexParam[info->hexParamCount])) != 0) {
Print("\nERROR: Hex param conversion failed for:\n\"%s\"\n", arg->arg[i + 1]);
return 1;
}
info->param[info->paramCount] = &(info->hexParam[info->hexParamCount]);
info->hexParamCount++;
} else if (strcmp(arg->arg[i], "exp") == 0) {
int expId = 0;
if (ConvertInt(arg->arg[i + 1], &expId) != 0 ||
getExpression(expId, &(info->intParam[info->intParamCount])) != 0) {
Print("\nERROR: Macro param conversion failed\n");
return 1;
}
info->param[info->paramCount] = &(info->intParam[info->intParamCount]);
info->intParamCount++;
} else {
return 1;
}
info->paramCount++;
}
return 0;
}
static int PrintCaseNameResult(FILE *logFile, int vectorCount, int skipCount, int passCount, time_t beginTime)
{
char suitePrefix[OUTPUT_LINE_LENGTH] = {0};
(void)snprintf_truncated_s(suitePrefix, sizeof(suitePrefix), "%s", suiteName);
size_t leftSize = sizeof(suitePrefix) - 1 - strlen(suitePrefix);
if (leftSize > 0) {
(void)memset_s(suitePrefix + strlen(suitePrefix), sizeof(suitePrefix) - strlen(suitePrefix), '.', leftSize);
}
int failCount = vectorCount - passCount - skipCount;
if (failCount == 0) {
Print("%sPASS || Run %-6d testcases, passed: %-6d, skipped: %-6d, failed: %-6d useSec:%-5lu\n", suitePrefix,
vectorCount, passCount, skipCount, failCount, time(NULL) - beginTime);
} else {
Print("%sFAIL || Run %-6d testcases, passed: %-6d, skipped: %-6d, failed: %-6d useSec:%-5lu\n", suitePrefix,
vectorCount, passCount, skipCount, failCount, time(NULL) - beginTime);
}
time_t rawtime;
struct tm *timeinfo;
(void)time(&rawtime);
timeinfo = localtime(&rawtime);
(void)fprintf(logFile, "End time: %s", asctime(timeinfo));
(void)fprintf(logFile, "Result: Run %d tests, Passed: %d, Skipped: %d, Failed: %d\n", vectorCount, passCount,
skipCount, failCount);
return failCount;
}
static int ProcessCases(FILE *logFile, bool showDetail, int targetFuncId)
{
(void)logFile;
volatile int vectorCount = 0;
volatile int passCount = 0;
volatile int skipCount = 0;
volatile int tryNum;
time_t beginTime = time(NULL);
struct timespec start, end;
for (volatile int i = 0; i < g_executeCount; i++) {
int funcId = strtoul(g_executeCases[i]->arg[0], NULL, 10); // 10
if (funcId < 0 || funcId > ((int)(sizeof(test_funcs)/sizeof(TestWrapper)))) {
Print("funcId false!\n");
return 1;
}
if ((targetFuncId != -1) && (funcId != targetFuncId)) {
continue;
}
(void)fprintf(logFile, "%s ", funcName[funcId]);
PrintCaseName(logFile, showDetail, g_executeCases[i]->testVectorName);
TestParam io;
if (ParseArgs(g_executeCases[i], &io) != 0) {
return -1;
}
TestWrapper fp = test_funcs[funcId];
g_testResult.result = TEST_RESULT_SUCCEED;
tryNum = 0;
clock_gettime(CLOCK_REALTIME, &start);
do {
if (tryNum > 0) {
sleep(10);
g_testResult.result = TEST_RESULT_SUCCEED;
}
tryNum++;
#ifdef ASAN
fp(io.param);
#else
// Executing Function
if (signal(SIGSEGV, handleSignal) == SIG_ERR) {
return -1;
}
int r = sigsetjmp(env, 1);
if (r == 0) {
fp(io.param);
} else if (r == 1){
g_testResult.result = TEST_RESULT_FAILED;
}
if (isSubProc != 0) {
break;
}
#endif
} while ((g_testResult.result == TEST_RESULT_FAILED) && (tryNum < FAIL_TRY_TIMES));
if (g_testResult.result == TEST_RESULT_SUCCEED) {
passCount++;
} else if (g_testResult.result == TEST_RESULT_SKIPPED) {
skipCount++;
}
vectorCount++;
clock_gettime(CLOCK_REALTIME, &end);
uint64_t elapsedms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000;
PrintResult(showDetail, g_executeCases[i]->testVectorName, elapsedms);
PrintLog(logFile);
for (int j = 0; j < io.hexParamCount; j++) {
FreeHex(&io.hexParam[j]);
}
if (isSubProc != 0) {
break;
}
}
return PrintCaseNameResult(logFile, vectorCount, skipCount, passCount, beginTime);
}
static int ExecuteTest(const char *fileName, bool showDetail, int targetFuncId)
{
if (LoadDataFile(fileName) != 0) {
return -1;
}
FILE *logFile = NULL;
char logFileName[MAX_FILE_NAME] = {0};
if (targetFuncId == -1) {
if (sprintf_s(logFileName, MAX_FILE_NAME, SUITE_LOG_FORMAT, suiteName) <= 0) {
Print("An error occurred while creating the log file\n");
return (-1);
}
} else {
if (sprintf_s(logFileName, MAX_FILE_NAME, FUNCTION_LOG_FORMAT, suiteName, funcName[targetFuncId]) <= 0) {
Print("An error occurred while creating the log file\n");
return (-1);
}
}
time_t rawtime = time(NULL);
if (rawtime == 0) {
return -1;
}
logFile = fopen(logFileName, "w");
if (logFile != NULL) {
struct tm *timeinfo;
timeinfo = localtime(&rawtime);
if (fprintf(logFile, "Begin time: %s", asctime(timeinfo)) <= 0) {
fclose(logFile);
return -1;
}
}
int rt = ProcessCases(logFile, showDetail, targetFuncId);
if (logFile != NULL) {
fclose(logFile);
}
return rt;
}
int ProcessMutiArgs(int argc, char **argv, const char *fileName)
{
int printDetail = 1;
int curTestCnt = 0;
int ret = -1;
int testCnt = sizeof(test_funcs) / sizeof(test_funcs[0]);
int *funcIndex = malloc(sizeof(int) * testCnt);
int found;
if (funcIndex == NULL) {
return ret;
}
for (int i = 1; i < argc; i++) {
if (strcmp(argv[i], "NO_DETAIL") == 0) {
printDetail = 0;
continue;
}
found = 0;
for (int j = 0; j < testCnt; j++) {
if (strcmp(argv[i], funcName[j]) == 0) {
funcIndex[curTestCnt++] = j;
found = 1;
break;
}
}
if (found != 1) {
Print("test function '%s' do not exist\n", argv[i]);
goto EXIT;
}
}
if (curTestCnt == 0) {
ret = ExecuteTest(fileName, printDetail, -1);
goto EXIT;
}
for (int i = 0; i < curTestCnt; i++) {
if (ExecuteTest(fileName, printDetail, funcIndex[i]) != 0) {
goto EXIT;
}
}
ret = 0;
EXIT:
free(funcIndex);
return ret;
}
int main(int argc, char **argv)
{
signal(SIGTTOU, SIG_IGN);
signal(SIGTTIN, SIG_IGN);
int ret = 0;
#ifndef PRINT_TO_TERMINAL
char testOutputName[MAX_FILE_NAME] = {0};
if (sprintf_s(testOutputName, MAX_FILE_NAME, "%s.output", suiteName) <= 0) {
return 0;
}
FILE *fp = fopen(testOutputName, "w");
if (fp == NULL) {
return 1;
}
SetOutputFile(fp);
#endif
char testName[MAX_FILE_PATH_LEN];
if (sprintf_s(testName, MAX_FILE_PATH_LEN, "%s.datax", suiteName) <= 0) {
goto EXIT;
}
if (argc == 1) {
ret = ExecuteTest(testName, 1, -1);
} else {
ret = ProcessMutiArgs(argc, argv, testName);
}
if (ret != 0) {
Print("execute test failed\n");
}
for (int i = 0; i < g_executeCount; i++) {
free(g_executeCases[i]);
}
EXIT:
#ifndef PRINT_TO_TERMINAL
(void)fclose(fp);
#endif
return ret;
}
| 2401_83913325/openHiTLS_1 | testcode/common/execute_test.c | C | unknown | 9,967 |
# 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.
cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
project(demo)
message(status "HITLS_ROOT: ${HITLS_ROOT}")
set(HITLS_ROOT ../..)
set(HITLS_INCLUDE ${HITLS_ROOT}/include/bsl
${HITLS_ROOT}/include/crypto
${HITLS_ROOT}/include/tls
${HITLS_ROOT}/include/pki
${HITLS_ROOT}/include/auth
${HITLS_ROOT}/config/macro_config
${HITLS_ROOT}/platform/Secure_C/include)
if(CUSTOM_CFLAGS)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CUSTOM_CFLAGS}")
endif()
if(ENABLE_GCOV)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fprofile-arcs -ftest-coverage -lgcov")
endif()
if(ENABLE_ASAN)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address -fno-stack-protector -fno-omit-frame-pointer")
endif()
add_library(DEMO_INTF INTERFACE)
target_compile_options(DEMO_INTF INTERFACE -g)
target_link_directories(DEMO_INTF INTERFACE ${HITLS_ROOT}/build
${HITLS_ROOT}/platform/Secure_C/lib/)
target_link_libraries(DEMO_INTF INTERFACE hitls_tls hitls_pki hitls_auth hitls_crypto hitls_bsl boundscheck pthread dl)
target_include_directories(DEMO_INTF INTERFACE ${HITLS_INCLUDE})
file(GLOB TESTS "*.c")
foreach(testcase ${TESTS})
get_filename_component(testname ${testcase} NAME_WLE)
add_executable(${testname} ${testcase})
target_link_libraries(${testname} PRIVATE DEMO_INTF)
endforeach()
| 2401_83913325/openHiTLS_1 | testcode/demo/CMakeLists.txt | CMake | unknown | 1,948 |
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_err.h"
#include "crypt_eal_init.h"
#include "crypt_algid.h"
#include "crypt_eal_rand.h"
#include "hitls_error.h"
#include "hitls_config.h"
#include "hitls.h"
#include "hitls_cert_init.h"
#include "hitls_cert.h"
#include "hitls_crypt_init.h"
#include "hitls_pki_cert.h"
#include "crypt_errno.h"
#define CERTS_PATH "../../../testcode/testdata/tls/certificate/der/ecdsa_sha256/"
#define HTTP_BUF_MAXLEN (18 * 1024) /* 18KB */
int main(int32_t argc, char *argv[])
{
int32_t exitValue = -1;
int32_t ret = 0;
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
BSL_UIO *uio = NULL;
int fd = 0;
HITLS_X509_Cert *rootCA = NULL;
HITLS_X509_Cert *subCA = NULL;
ret = CRYPT_EAL_Init(CRYPT_EAL_INIT_ALL);
if (ret != CRYPT_SUCCESS) {
printf("CRYPT_EAL_Init: error code is %x\n", ret);
return ret;
}
HITLS_CertMethodInit();
HITLS_CryptMethodInit();
fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd == -1) {
printf("Create socket failed.\n");
goto EXIT;
}
int option = 1;
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option)) < 0) {
close(fd);
printf("setsockopt SO_REUSEADDR failed.\n");
goto EXIT;
}
// Set the protocol and port number
struct sockaddr_in serverAddr;
(void)memset_s(&serverAddr, sizeof(serverAddr), 0, sizeof(serverAddr));
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(12345);
serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
if (connect(fd, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) != 0) {
printf("connect failed.\n");
goto EXIT;
}
config = HITLS_CFG_NewTLS12Config();
if (config == NULL) {
printf("HITLS_CFG_NewTLS12Config failed.\n");
goto EXIT;
}
ret = HITLS_CFG_SetCheckKeyUsage(config, false); // disable cert keyusage check
if (ret != HITLS_SUCCESS) {
printf("Disable check KeyUsage failed.\n");
goto EXIT;
}
/* 加载证书：需要用户实现 */
ret = HITLS_X509_CertParseFile(BSL_FORMAT_ASN1, CERTS_PATH "ca.der", &rootCA);
if (ret != HITLS_SUCCESS) {
printf("Parse ca failed.\n");
goto EXIT;
}
ret = HITLS_X509_CertParseFile(BSL_FORMAT_ASN1, CERTS_PATH "inter.der", &subCA);
if (ret != HITLS_SUCCESS) {
printf("Parse subca failed.\n");
goto EXIT;
}
HITLS_CFG_AddCertToStore(config, rootCA, TLS_CERT_STORE_TYPE_DEFAULT, true);
HITLS_CFG_AddCertToStore(config, subCA, TLS_CERT_STORE_TYPE_DEFAULT, true);
/* 新建openHiTLS上下文 */
ctx = HITLS_New(config);
if (ctx == NULL) {
printf("HITLS_New failed.\n");
goto EXIT;
}
uio = BSL_UIO_New(BSL_UIO_TcpMethod());
if (uio == NULL) {
printf("BSL_UIO_New failed.\n");
goto EXIT;
}
ret = BSL_UIO_Ctrl(uio, BSL_UIO_SET_FD, (int32_t)sizeof(fd), &fd);
if (ret != HITLS_SUCCESS) {
BSL_UIO_Free(uio);
printf("BSL_UIO_SET_FD failed, fd = %u.\n", fd);
goto EXIT;
}
ret = HITLS_SetUio(ctx, uio);
if (ret != HITLS_SUCCESS) {
BSL_UIO_Free(uio);
printf("HITLS_SetUio failed. ret = 0x%x.\n", ret);
goto EXIT;
}
/* 进行TLS连接、用户需按实际场景考虑返回值 */
ret = HITLS_Connect(ctx);
if (ret != HITLS_SUCCESS) {
printf("HITLS_Connect failed, ret = 0x%x.\n", ret);
goto EXIT;
}
/* 向对端发送报文、用户需按实际场景考虑返回值 */
const uint8_t sndBuf[] = "Hi, this is client\n";
uint32_t writeLen = 0;
ret = HITLS_Write(ctx, sndBuf, sizeof(sndBuf), &writeLen);
if (ret != HITLS_SUCCESS) {
printf("HITLS_Write error:error code:%d\n", ret);
goto EXIT;
}
/* 读取对端报文、用户需按实际场景考虑返回值 */
uint8_t readBuf[HTTP_BUF_MAXLEN + 1] = {0};
uint32_t readLen = 0;
ret = HITLS_Read(ctx, readBuf, HTTP_BUF_MAXLEN, &readLen);
if (ret != HITLS_SUCCESS) {
printf("HITLS_Read failed, ret = 0x%x.\n", ret);
goto EXIT;
}
printf("get from server size:%u :%s\n", readLen, readBuf);
exitValue = 0;
EXIT:
HITLS_Close(ctx);
HITLS_Free(ctx);
HITLS_CFG_FreeConfig(config);
close(fd);
HITLS_X509_CertFree(rootCA);
HITLS_X509_CertFree(subCA);
BSL_UIO_Free(uio);
return exitValue;
} | 2401_83913325/openHiTLS_1 | testcode/demo/client.c | C | unknown | 4,608 |
/*
* 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 <stdint.h>
#include <string.h>
#include "crypt_types.h"
#include "bsl_sal.h"
#include "bsl_err.h"
#include "crypt_algid.h"
#include "crypt_eal_init.h"
#include "crypt_errno.h"
#include "crypt_eal_rand.h"
void PrintLastError(void) {
const char *file = NULL;
uint32_t line = 0;
BSL_ERR_GetLastErrorFileLine(&file, &line);
printf("failed at file %s at line %d\n", file, line);
}
int main(void)
{
int ret;
uint8_t output[100] = {0};
uint32_t len = 100;
ret = CRYPT_EAL_Init(CRYPT_EAL_INIT_ALL);
if (ret != CRYPT_SUCCESS) {
printf("CRYPT_EAL_Init: error code is %x\n", ret);
return ret;
}
// Obtain the random number sequence of the **len** value.
ret = CRYPT_EAL_RandbytesEx(NULL, output, len);
if (ret != CRYPT_SUCCESS) {
printf("CRYPT_EAL_Randbytes: error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
printf("random value is: "); // Output the random number.
for (uint32_t i = 0; i < len; i++) {
printf("%02x", output[i]);
}
printf("\n");
// Reseeding
ret = CRYPT_EAL_RandSeedEx(NULL);
if (ret != CRYPT_SUCCESS) {
printf("CRYPT_EAL_RandSeed: error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
// Obtain the random number sequence of the **len** value.
ret = CRYPT_EAL_RandbytesEx(NULL, output, len);
if (ret != CRYPT_SUCCESS) {
printf("CRYPT_EAL_Randbytes: error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
printf("random value is: "); // Output the random number.
for (uint32_t i = 0; i < len; i++) {
printf("%02x", output[i]);
}
printf("\n");
EXIT:
// Release the context memory.
CRYPT_EAL_RandDeinit();
BSL_ERR_DeInit();
return ret;
} | 2401_83913325/openHiTLS_1 | testcode/demo/drbg.c | C | unknown | 2,398 |
/*
* 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 <stdint.h>
#include <string.h>
#include "crypt_types.h"
#include "crypt_eal_pkey.h" // Header file for key exchange.
#include "bsl_sal.h"
#include "bsl_err.h"
#include "crypt_eal_init.h"
#include "crypt_algid.h"
#include "crypt_errno.h"
#include "crypt_eal_rand.h"
void PrintLastError(void) {
const char *file = NULL;
uint32_t line = 0;
BSL_ERR_GetLastErrorFileLine(&file, &line);
printf("failed at file %s at line %d\n", file, line);
}
int main(void)
{
int ret;
uint8_t prikey[] =
{0x7d, 0x7d, 0xc5, 0xf7, 0x1e, 0xb2, 0x9d, 0xda, 0xf8, 0x0d, 0x62, 0x14, 0x63, 0x2e, 0xea, 0xe0,
0x3d, 0x90, 0x58, 0xaf, 0x1f, 0xb6, 0xd2, 0x2e, 0xd8, 0x0b, 0xad, 0xb6, 0x2b, 0xc1, 0xa5, 0x34};
uint8_t pubkey[] =
{0x04, 0x70, 0x0c, 0x48, 0xf7, 0x7f, 0x56, 0x58, 0x4c, 0x5c, 0xc6, 0x32, 0xca, 0x65, 0x64, 0x0d, 0xb9,
0x1b, 0x6b, 0xac, 0xce, 0x3a, 0x4d, 0xf6, 0xb4, 0x2c, 0xe7, 0xcc, 0x83, 0x88, 0x33, 0xd2, 0x87,
0xdb, 0x71, 0xe5, 0x09, 0xe3, 0xfd, 0x9b, 0x06, 0x0d, 0xdb, 0x20, 0xba, 0x5c, 0x51, 0xdc, 0xc5,
0x94, 0x8d, 0x46, 0xfb, 0xf6, 0x40, 0xdf, 0xe0, 0x44, 0x17, 0x82, 0xca, 0xb8, 0x5f, 0xa4, 0xac};
uint8_t resSharekey[] =
{0x46, 0xfc, 0x62, 0x10, 0x64, 0x20, 0xff, 0x01, 0x2e, 0x54, 0xa4, 0x34, 0xfb, 0xdd, 0x2d, 0x25,
0xcc, 0xc5, 0x85, 0x20, 0x60, 0x56, 0x1e, 0x68, 0x04, 0x0d, 0xd7, 0x77, 0x89, 0x97, 0xbd, 0x7b};
CRYPT_EAL_PkeyPrv prvKey = {0};
CRYPT_EAL_PkeyPub pubKey = {0};
uint32_t shareLen;
uint8_t *shareKey;
CRYPT_EAL_PkeyCtx *prvCtx = NULL;
CRYPT_EAL_PkeyCtx *pubCtx = NULL;
CRYPT_PKEY_ParaId id = CRYPT_ECC_NISTP256;
ret = CRYPT_EAL_Init(CRYPT_EAL_INIT_ALL);
if (ret != CRYPT_SUCCESS) {
printf("CRYPT_EAL_Init: error code is %x\n", ret);
goto EXIT;
}
prvCtx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ECDH);
pubCtx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ECDH);
if (prvCtx == NULL || pubCtx == NULL) {
goto EXIT;
}
// Set the curve parameters.
ret = CRYPT_EAL_PkeySetParaById(prvCtx, id);
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
// Set the private key of one end.
prvKey.id = CRYPT_PKEY_ECDH;
prvKey.key.eccPrv.len = sizeof(prikey);
prvKey.key.eccPrv.data = prikey;
ret = CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey);
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
// Set the curve parameters.
ret = CRYPT_EAL_PkeySetParaById(pubCtx, id);
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
// Set the public key of the other end.
pubKey.id = CRYPT_PKEY_ECDH;
pubKey.key.eccPub.len = sizeof(pubkey);
pubKey.key.eccPub.data = pubkey;
ret = CRYPT_EAL_PkeySetPub(pubCtx, &pubKey);
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
// The shared key involves only the X axis. The length of the public key is not compressed in the returned results.
shareLen = CRYPT_EAL_PkeyGetKeyLen(prvCtx) / 2;
shareKey = (uint8_t *)BSL_SAL_Malloc(shareLen);
if (shareKey == NULL) {
ret = CRYPT_MEM_ALLOC_FAIL;
PrintLastError();
goto EXIT;
}
// Calculate the shared key.
ret = CRYPT_EAL_PkeyComputeShareKey(prvCtx, pubCtx, shareKey, &shareLen);
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
// Compare the calculation result with the expected one.
if (shareLen != sizeof(resSharekey) || memcmp(shareKey, resSharekey, shareLen) != 0) {
printf("failed to compare test results\n");
ret = -1;
goto EXIT;
}
printf("pass \n");
EXIT:
// Release the context memory.
CRYPT_EAL_RandDeinit();
CRYPT_EAL_PkeyFreeCtx(prvCtx);
CRYPT_EAL_PkeyFreeCtx(pubCtx);
BSL_SAL_Free(shareKey);
BSL_ERR_DeInit();
return ret;
} | 2401_83913325/openHiTLS_1 | testcode/demo/ecdh.c | C | unknown | 4,717 |
/*
* 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "crypt_errno.h"
#include "bsl_sal.h"
#include "bsl_err.h"
#include "crypt_algid.h"
#include "crypt_eal_md.h"
#define PBKDF2_PARAM_LEN (4)
void PrintLastError(void) {
const char *file = NULL;
uint32_t line = 0;
BSL_ERR_GetErrorFileLine(&file, &line);
printf("failed at file %s at line %d\n", file, line);
}
int main(void)
{
int ret = 0;
CRYPT_EAL_MdCTX *ctx = NULL;
uint8_t digest[32] = {0};
unsigned int digestLen = 32;
uint8_t data[] = {0x1b, 0x50, 0x3f, 0xb9, 0xa7, 0x3b, 0x16, 0xad, 0xa3,
0xfc, 0xf1, 0x04, 0x26, 0x23, 0xae, 0x76, 0x10};
uint8_t expResult[] = {0xd5, 0xc3, 0x03, 0x15, 0xf7, 0x2e, 0xd0, 0x5f, 0xe5, 0x19, 0xa1, 0xbf, 0x75,
0xab, 0x5f, 0xd0, 0xff, 0xec, 0x5a, 0xc1, 0xac, 0xb0, 0xda, 0xf6, 0x6b, 0x6b, 0x76, 0x95, 0x98,
0x59, 0x45, 0x09};
ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA256);
if (ctx == NULL) {
PrintLastError();
goto EXIT;
}
ret = CRYPT_EAL_MdInit(ctx);
if (ret != 0) {
PrintLastError();
goto EXIT;
}
ret = CRYPT_EAL_MdUpdate(ctx, data, sizeof(data));
if (ret != 0) {
PrintLastError();
goto EXIT;
}
ret = CRYPT_EAL_MdFinal(ctx, digest, &digestLen);
if (ret != 0) {
PrintLastError();
goto EXIT;
}
printf("hash result: ");
for (uint32_t i = 0; i < digestLen; i++) {
printf("%02x", digest[i]);
}
printf("\n");
// result compare
if (digestLen != sizeof(expResult) || memcmp(expResult, digest, digestLen) != 0) {
printf("hash result comparison failed\n");
goto EXIT;
}
printf("pass \n");
EXIT:
BSL_ERR_DeInit();
CRYPT_EAL_MdFreeCtx(ctx);
return ret;
} | 2401_83913325/openHiTLS_1 | testcode/demo/hash.c | C | unknown | 2,355 |
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <time.h>
#include <inttypes.h>
#include <string.h>
#include "auth_otp.h"
#include "auth_params.h"
#include "bsl_sal.h"
#include "bsl_err.h"
#include "crypt_eal_init.h"
#include "crypt_eal_rand.h"
#include "auth_errno.h"
#include "crypt_errno.h"
#include "securec.h"
void *StdMalloc(uint32_t len)
{
return malloc((size_t)len);
}
void PrintLastError(void)
{
const char *file = NULL;
uint32_t line = 0;
BSL_ERR_GetLastErrorFileLine(&file, &line);
printf("failed at file %s at line %d\n", file, line);
}
void PrintPlainHex(const uint8_t *data, uint32_t len)
{
for (uint32_t i = 0; i < len; i++) {
printf("%02X", data[i]);
}
printf("\n");
}
int32_t setHotpCtx(HITLS_AUTH_OtpCtx *ctx, uint8_t *key, uint32_t keyLen, uint32_t digits)
{
int32_t ret = HITLS_AUTH_OtpInit(ctx, key, keyLen);
if (ret != HITLS_AUTH_SUCCESS) {
return ret;
}
BSL_Param param[] = {{AUTH_PARAM_OTP_CTX_DIGITS, BSL_PARAM_TYPE_UINT32, &digits, sizeof(digits), sizeof(digits)},
BSL_PARAM_END};
return HITLS_AUTH_OtpCtxCtrl(ctx, HITLS_AUTH_OTP_SET_CTX_DIGITS, param, 0);
}
int32_t genHotp(HITLS_AUTH_OtpCtx *ctx, uint64_t counter, char *otp, uint32_t *otpLen)
{
BSL_Param param[] = {
{AUTH_PARAM_OTP_HOTP_COUNTER, BSL_PARAM_TYPE_OCTETS, &counter, sizeof(counter), sizeof(counter)},
BSL_PARAM_END};
return HITLS_AUTH_OtpGen(ctx, param, otp, otpLen);
}
int32_t validateHotp(HITLS_AUTH_OtpCtx *ctx, uint64_t counter, char *otp, uint32_t otpLen)
{
BSL_Param param[] = {
{AUTH_PARAM_OTP_HOTP_COUNTER, BSL_PARAM_TYPE_OCTETS, &counter, sizeof(counter), sizeof(counter)},
BSL_PARAM_END};
return HITLS_AUTH_OtpValidate(ctx, param, otp, otpLen, NULL);
}
int32_t setTotpCtx(HITLS_AUTH_OtpCtx *ctx, uint8_t *key, uint32_t keyLen, uint32_t digits,
HITLS_AUTH_OtpCryptAlgId hashAlgId, uint32_t timeStepSize, BslUnixTime startOffset,
uint32_t validWindow)
{
int32_t ret = HITLS_AUTH_OtpInit(ctx, key, keyLen);
if (ret != HITLS_AUTH_SUCCESS) {
return ret;
}
BSL_Param param[] = {
{AUTH_PARAM_OTP_CTX_DIGITS, BSL_PARAM_TYPE_UINT32, &digits, sizeof(digits), sizeof(digits)},
{AUTH_PARAM_OTP_CTX_HASHALGID, BSL_PARAM_TYPE_OCTETS, &hashAlgId, sizeof(hashAlgId), sizeof(hashAlgId)},
{AUTH_PARAM_OTP_CTX_TOTP_TIMESTEPSIZE, BSL_PARAM_TYPE_UINT32, &timeStepSize, sizeof(timeStepSize),
sizeof(timeStepSize)},
{AUTH_PARAM_OTP_CTX_TOTP_STARTOFFSET, BSL_PARAM_TYPE_OCTETS, &startOffset, sizeof(startOffset),
sizeof(startOffset)},
{AUTH_PARAM_OTP_CTX_TOTP_VALIDWINDOW, BSL_PARAM_TYPE_UINT32, &validWindow, sizeof(validWindow),
sizeof(validWindow)},
BSL_PARAM_END};
if ((ret = HITLS_AUTH_OtpCtxCtrl(ctx, HITLS_AUTH_OTP_SET_CTX_DIGITS, param, 0)) != HITLS_AUTH_SUCCESS ||
(ret = HITLS_AUTH_OtpCtxCtrl(ctx, HITLS_AUTH_OTP_SET_CTX_HASHALGID, param, 0)) != HITLS_AUTH_SUCCESS ||
(ret = HITLS_AUTH_OtpCtxCtrl(ctx, HITLS_AUTH_OTP_SET_CTX_TOTP_TIMESTEPSIZE, param, 0)) != HITLS_AUTH_SUCCESS ||
(ret = HITLS_AUTH_OtpCtxCtrl(ctx, HITLS_AUTH_OTP_SET_CTX_TOTP_STARTOFFSET, param, 0)) != HITLS_AUTH_SUCCESS ||
(ret = HITLS_AUTH_OtpCtxCtrl(ctx, HITLS_AUTH_OTP_SET_CTX_TOTP_VALIDWINDOW, param, 0)) != HITLS_AUTH_SUCCESS) {
return ret;
}
return HITLS_AUTH_SUCCESS;
}
int32_t genTotp(HITLS_AUTH_OtpCtx *ctx, BslUnixTime curTime, char *otp, uint32_t *otpLen)
{
BSL_Param param[] = {
{AUTH_PARAM_OTP_TOTP_CURTIME, BSL_PARAM_TYPE_OCTETS, &curTime, sizeof(curTime), sizeof(curTime)},
BSL_PARAM_END};
return HITLS_AUTH_OtpGen(ctx, param, otp, otpLen);
}
int32_t validateTotp(HITLS_AUTH_OtpCtx *ctx, BslUnixTime curTime, char *otp, uint32_t otpLen)
{
BSL_Param param[] = {
{AUTH_PARAM_OTP_TOTP_CURTIME, BSL_PARAM_TYPE_OCTETS, &curTime, sizeof(curTime), sizeof(curTime)},
BSL_PARAM_END};
return HITLS_AUTH_OtpValidate(ctx, param, otp, otpLen, NULL);
}
int main()
{
BSL_ERR_Init(); // Initialize error code module
BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_MALLOC, StdMalloc); // Register memory allocation function
BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_FREE, free); // Register memory free function
int32_t ret = 1;
uint8_t key20[] = "12345678901234567890";
uint8_t key32[] = "12345678901234567890123456789012";
uint8_t key64[] = "1234567890123456789012345678901234567890123456789012345678901234";
char otp[10] = {0};
uint32_t otpLen = sizeof(otp);
HITLS_AUTH_OtpCtx *hotpCtx = HITLS_AUTH_OtpNewCtx(HITLS_AUTH_OTP_HOTP);
HITLS_AUTH_OtpCtx *totpCtxSHA1 = HITLS_AUTH_OtpNewCtx(HITLS_AUTH_OTP_TOTP);
HITLS_AUTH_OtpCtx *totpCtxSHA256 = HITLS_AUTH_OtpNewCtx(HITLS_AUTH_OTP_TOTP);
HITLS_AUTH_OtpCtx *totpCtxSHA512 = HITLS_AUTH_OtpNewCtx(HITLS_AUTH_OTP_TOTP);
HITLS_AUTH_OtpCtx *hotpCtxRand = HITLS_AUTH_OtpNewCtx(HITLS_AUTH_OTP_HOTP);
if (!hotpCtx || !totpCtxSHA1 || !totpCtxSHA256 || !totpCtxSHA512 || !hotpCtxRand) {
printf("Failed to create hotp contexts\n");
PrintLastError();
goto EXIT;
}
/* HOTP example in RFC4226. */
char *hotpExpected[] = {"755224", "287082", "359152", "969429", "338314",
"254676", "287922", "162583", "399871", "520489"};
uint32_t hotpDigits = 6;
if (setHotpCtx(hotpCtx, key20, sizeof(key20), hotpDigits) != HITLS_AUTH_SUCCESS) {
printf("Failed to set hotp context\n");
PrintLastError();
goto EXIT;
}
for (uint64_t counter = 0; counter < sizeof(hotpExpected) / sizeof(hotpExpected[0]); counter++) {
if (genHotp(hotpCtx, counter, otp, &otpLen) != HITLS_AUTH_SUCCESS) {
printf("Failed to generate hotp\n");
PrintLastError();
goto EXIT;
}
printf("HOTP(%016" PRIX64 "): %.*s\n", counter, otpLen, otp);
if (strncmp(hotpExpected[counter], otp, strlen(hotpExpected[counter])) != 0) {
printf("Hotp mismatch\n");
PrintLastError();
goto EXIT;
}
if (validateHotp(hotpCtx, counter, otp, otpLen) != HITLS_AUTH_SUCCESS) {
printf("Failed to validate hotp\n");
PrintLastError();
goto EXIT;
}
otp[otpLen - 1] = otp[otpLen - 1] == '9' ? '0' : (otp[otpLen - 1] + 1);
if (validateHotp(hotpCtx, counter, otp, otpLen) != HITLS_AUTH_OTP_VALIDATE_MISMATCH) {
printf("Failed to validate invalid hotp\n");
PrintLastError();
goto EXIT;
}
}
/* TOTP example in RFC6238. */
char totpExpected[] = "+---------------+-----------------------+------------------+--------+--------+\n"
"| Time(sec) | Time (UTC format) | Value of T(Hex) | TOTP | Mode |\n"
"+---------------+-----------------------+------------------+--------+--------+\n"
"| 59 | 1970-01-01 00:00:59 | 0000000000000001 |94287082| SHA1 |\n"
"| 59 | 1970-01-01 00:00:59 | 0000000000000001 |46119246| SHA256 |\n"
"| 59 | 1970-01-01 00:00:59 | 0000000000000001 |90693936| SHA512 |\n"
"+---------------+-----------------------+------------------+--------+--------+\n"
"| 1111111109 | 2005-03-18 01:58:29 | 00000000023523EC |07081804| SHA1 |\n"
"| 1111111109 | 2005-03-18 01:58:29 | 00000000023523EC |68084774| SHA256 |\n"
"| 1111111109 | 2005-03-18 01:58:29 | 00000000023523EC |25091201| SHA512 |\n"
"+---------------+-----------------------+------------------+--------+--------+\n"
"| 1111111111 | 2005-03-18 01:58:31 | 00000000023523ED |14050471| SHA1 |\n"
"| 1111111111 | 2005-03-18 01:58:31 | 00000000023523ED |67062674| SHA256 |\n"
"| 1111111111 | 2005-03-18 01:58:31 | 00000000023523ED |99943326| SHA512 |\n"
"+---------------+-----------------------+------------------+--------+--------+\n"
"| 1234567890 | 2009-02-13 23:31:30 | 000000000273EF07 |89005924| SHA1 |\n"
"| 1234567890 | 2009-02-13 23:31:30 | 000000000273EF07 |91819424| SHA256 |\n"
"| 1234567890 | 2009-02-13 23:31:30 | 000000000273EF07 |93441116| SHA512 |\n"
"+---------------+-----------------------+------------------+--------+--------+\n"
"| 2000000000 | 2033-05-18 03:33:20 | 0000000003F940AA |69279037| SHA1 |\n"
"| 2000000000 | 2033-05-18 03:33:20 | 0000000003F940AA |90698825| SHA256 |\n"
"| 2000000000 | 2033-05-18 03:33:20 | 0000000003F940AA |38618901| SHA512 |\n"
"+---------------+-----------------------+------------------+--------+--------+\n"
"| 20000000000 | 2603-10-11 11:33:20 | 0000000027BC86AA |65353130| SHA1 |\n"
"| 20000000000 | 2603-10-11 11:33:20 | 0000000027BC86AA |77737706| SHA256 |\n"
"| 20000000000 | 2603-10-11 11:33:20 | 0000000027BC86AA |47863826| SHA512 |\n"
"+---------------+-----------------------+------------------+--------+--------+\n";
char actually[4096] = {0};
#define APPEND_SAFE(buffer, format, ...) \
do { \
size_t currentLen = strlen(buffer); \
size_t bufferSize = sizeof(buffer); \
size_t remaining = bufferSize - currentLen; \
if (remaining <= 0 || snprintf_s(buffer + currentLen, remaining, remaining, format, ##__VA_ARGS__) == -1) { \
printf("snprintf_s failed\n"); \
goto EXIT; \
} \
} while (0)
otpLen = sizeof(otp);
uint32_t totpDigits = 8;
uint32_t x = 30;
BslUnixTime t0 = 0L;
BslUnixTime ts[] = {59L, 1111111109L, 1111111111L, 1234567890L, 2000000000L, 20000000000L};
APPEND_SAFE(actually, "+---------------+-----------------------+------------------+--------+--------+\n");
APPEND_SAFE(actually, "| Time(sec) | Time (UTC format) | Value of T(Hex) | TOTP | Mode |\n");
APPEND_SAFE(actually, "+---------------+-----------------------+------------------+--------+--------+\n");
if (setTotpCtx(totpCtxSHA1, key20, sizeof(key20), totpDigits, HITLS_AUTH_OTP_CRYPTO_SHA1, x, t0, 1) !=
HITLS_AUTH_SUCCESS ||
setTotpCtx(totpCtxSHA256, key32, sizeof(key32), totpDigits, HITLS_AUTH_OTP_CRYPTO_SHA256, x, t0, 1) !=
HITLS_AUTH_SUCCESS ||
setTotpCtx(totpCtxSHA512, key64, sizeof(key64), totpDigits, HITLS_AUTH_OTP_CRYPTO_SHA512, x, t0, 1) !=
HITLS_AUTH_SUCCESS) {
printf("Failed to set totp context\n");
PrintLastError();
goto EXIT;
}
for (int i = 0; i < sizeof(ts) / sizeof(ts[0]); i++) {
long T = (ts[i] - t0) / x;
time_t timeVal = (time_t)ts[i];
struct tm *utcTime = gmtime(&timeVal);
char fmtTime[20] = {0};
if (strftime(fmtTime, sizeof(fmtTime), "%Y-%m-%d %H:%M:%S", utcTime) == 0) {
printf("strftime failed\n");
goto EXIT;
}
// SHA1
if (genTotp(totpCtxSHA1, ts[i], otp, &otpLen) != HITLS_AUTH_SUCCESS) {
printf("Failed to generate totp SHA1\n");
PrintLastError();
goto EXIT;
}
if (validateTotp(totpCtxSHA1, ts[i], otp, otpLen) != HITLS_AUTH_SUCCESS ||
validateTotp(totpCtxSHA1, ts[i] + x, otp, otpLen) != HITLS_AUTH_SUCCESS ||
validateTotp(totpCtxSHA1, ts[i] - x, otp, otpLen) != HITLS_AUTH_SUCCESS ||
validateTotp(totpCtxSHA1, ts[i] + x + x, otp, otpLen) != HITLS_AUTH_OTP_VALIDATE_MISMATCH ||
validateTotp(totpCtxSHA1, ts[i] - x - x, otp, otpLen) != HITLS_AUTH_OTP_VALIDATE_MISMATCH) {
printf("Failed to validate totp SHA1\n");
PrintLastError();
goto EXIT;
}
APPEND_SAFE(actually, "| %-11" PRId64 " | %s | %016" PRIX64 " |%.*s| SHA1 |\n", ts[i], fmtTime, T,
totpDigits, otp);
// SHA256
if (genTotp(totpCtxSHA256, ts[i], otp, &otpLen) != HITLS_AUTH_SUCCESS) {
printf("Failed to generate totp SHA256\n");
PrintLastError();
goto EXIT;
}
if (validateTotp(totpCtxSHA256, ts[i], otp, otpLen) != HITLS_AUTH_SUCCESS ||
validateTotp(totpCtxSHA256, ts[i] + x, otp, otpLen) != HITLS_AUTH_SUCCESS ||
validateTotp(totpCtxSHA256, ts[i] - x, otp, otpLen) != HITLS_AUTH_SUCCESS ||
validateTotp(totpCtxSHA256, ts[i] + x + x, otp, otpLen) != HITLS_AUTH_OTP_VALIDATE_MISMATCH ||
validateTotp(totpCtxSHA256, ts[i] - x - x, otp, otpLen) != HITLS_AUTH_OTP_VALIDATE_MISMATCH) {
printf("Failed to validate totp SHA256\n");
PrintLastError();
goto EXIT;
}
APPEND_SAFE(actually, "| %-11" PRId64 " | %s | %016" PRIX64 " |%.*s| SHA256 |\n", ts[i], fmtTime, T,
totpDigits, otp);
// SHA512
if (genTotp(totpCtxSHA512, ts[i], otp, &otpLen) != HITLS_AUTH_SUCCESS) {
printf("Failed to generate totp SHA512\n");
PrintLastError();
goto EXIT;
}
if (validateTotp(totpCtxSHA512, ts[i], otp, otpLen) != HITLS_AUTH_SUCCESS ||
validateTotp(totpCtxSHA512, ts[i] + x, otp, otpLen) != HITLS_AUTH_SUCCESS ||
validateTotp(totpCtxSHA512, ts[i] - x, otp, otpLen) != HITLS_AUTH_SUCCESS ||
validateTotp(totpCtxSHA512, ts[i] + x + x, otp, otpLen) != HITLS_AUTH_OTP_VALIDATE_MISMATCH ||
validateTotp(totpCtxSHA512, ts[i] - x - x, otp, otpLen) != HITLS_AUTH_OTP_VALIDATE_MISMATCH) {
printf("Failed to validate totp SHA512\n");
PrintLastError();
goto EXIT;
}
APPEND_SAFE(actually, "| %-11" PRId64 " | %s | %016" PRIX64 " |%.*s| SHA512 |\n", ts[i], fmtTime, T,
totpDigits, otp);
APPEND_SAFE(actually, "+---------------+-----------------------+------------------+--------+--------+\n");
}
printf("%s", actually);
if (strncmp(totpExpected, actually, strlen(totpExpected)) != 0) {
printf("Totp mismatch\n");
PrintLastError();
goto EXIT;
}
/* Key generation. */
if (CRYPT_EAL_ProviderRandInitCtx(NULL, CRYPT_RAND_SHA256, "provider=default", NULL, 0, NULL) != CRYPT_SUCCESS) {
printf("CRYPT_EAL_RandInit: error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
otpLen = sizeof(otp);
uint8_t key[20] = {0};
uint32_t keyLen = 20;
if (HITLS_AUTH_OtpInit(hotpCtxRand, NULL, keyLen) != HITLS_AUTH_SUCCESS) {
printf("Failed to generation random key\n");
PrintLastError();
goto EXIT;
}
BSL_Param paramCtrl[] = {{AUTH_PARAM_OTP_CTX_KEY, BSL_PARAM_TYPE_OCTETS_PTR, &key, sizeof(key), sizeof(key)},
BSL_PARAM_END};
if (HITLS_AUTH_OtpCtxCtrl(hotpCtxRand, HITLS_AUTH_OTP_GET_CTX_KEY, paramCtrl, 0) != HITLS_AUTH_SUCCESS) {
printf("Failed to get key\n");
PrintLastError();
goto EXIT;
}
printf("Random key: ");
PrintPlainHex(key, keyLen);
uint64_t counter = 0;
if (genHotp(hotpCtxRand, counter, otp, &otpLen) != HITLS_AUTH_SUCCESS) {
printf("Failed to generation hotp\n");
PrintLastError();
goto EXIT;
}
printf("HOTP(%016" PRIX64 "): %.*s\n", counter, otpLen, otp);
printf("Check it by: oathtool --hotp --counter %" PRIu64 " ", counter);
PrintPlainHex(key, keyLen);
printf("pass \n");
ret = HITLS_AUTH_SUCCESS;
EXIT:
HITLS_AUTH_OtpFreeCtx(hotpCtx);
HITLS_AUTH_OtpFreeCtx(totpCtxSHA1);
HITLS_AUTH_OtpFreeCtx(totpCtxSHA256);
HITLS_AUTH_OtpFreeCtx(totpCtxSHA512);
HITLS_AUTH_OtpFreeCtx(hotpCtxRand);
return ret;
} | 2401_83913325/openHiTLS_1 | testcode/demo/otp.c | C | unknown | 16,997 |
/*
* 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 <string.h>
#include "crypt_errno.h"
#include "bsl_sal.h"
#include "bsl_err.h"
#include "crypt_algid.h"
#include "crypt_eal_kdf.h"
#include "bsl_params.h"
#include "crypt_params_key.h"
#define PBKDF2_PARAM_LEN (4)
void PrintLastError(void) {
const char *file = NULL;
uint32_t line = 0;
BSL_ERR_GetLastErrorFileLine(&file, &line);
printf("failed at file %s at line %d\n", file, line);
}
int main(void)
{
int32_t ret;
uint8_t key[] = {0x50, 0x61, 0x73, 0x73, 0x77, 0x6f, 0x72, 0x64};
uint8_t salt[] = {0x4e, 0x61, 0x43, 0x6c};
uint32_t iterations = 80000;
uint8_t result[] = {
0x4d, 0xdc, 0xd8, 0xf6, 0x0b, 0x98, 0xbe, 0x21,
0x83, 0x0c, 0xee, 0x5e, 0xf2, 0x27, 0x01, 0xf9,
0x64, 0x1a, 0x44, 0x18, 0xd0, 0x4c, 0x04, 0x14,
0xae, 0xff, 0x08, 0x87, 0x6b, 0x34, 0xab, 0x56,
0xa1, 0xd4, 0x25, 0xa1, 0x22, 0x58, 0x33, 0x54,
0x9a, 0xdb, 0x84, 0x1b, 0x51, 0xc9, 0xb3, 0x17,
0x6a, 0x27, 0x2b, 0xde, 0xbb, 0xa1, 0xd0, 0x78,
0x47, 0x8f, 0x62, 0xb3, 0x97, 0xf3, 0x3c, 0x8d};
uint8_t out[sizeof(result)] = {0};
uint32_t outLen = sizeof(result);
CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_PBKDF2);
if (ctx == NULL) {
PrintLastError();
goto EXIT;
}
CRYPT_MAC_AlgId id = CRYPT_MAC_HMAC_SHA256;
BSL_Param params[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};
(void)BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32, &id, sizeof(id));
(void)BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS, key, sizeof(key));
(void)BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS, salt, sizeof(salt));
(void)BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_ITER, BSL_PARAM_TYPE_UINT32, &iterations, sizeof(iterations));
ret = CRYPT_EAL_KdfSetParam(ctx, params);
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
ret = CRYPT_EAL_KdfDerive(ctx, out, outLen);
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
if (memcmp(out, result, sizeof(result)) != 0) {
printf("failed to compare test results\n");
ret = -1;
goto EXIT;
}
printf("pass \n");
EXIT:
BSL_ERR_DeInit();
CRYPT_EAL_KdfFreeCtx(ctx);
return ret;
} | 2401_83913325/openHiTLS_1 | testcode/demo/pbkdf2.c | C | unknown | 3,047 |
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include "auth_privpass_token.h"
#include "auth_params.h"
#include "bsl_sal.h"
#include "bsl_err.h"
#include "crypt_eal_init.h"
#include "crypt_eal_rand.h"
#include "auth_errno.h"
#include "crypt_errno.h"
uint8_t pubKey[] = {0x30, 0x82, 0x01, 0x52, 0x30, 0x3d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01,
0x0a, 0x30, 0x30, 0xa0, 0x0d, 0x30, 0x0b, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04,
0x02, 0x02, 0xa1, 0x1a, 0x30, 0x18, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01,
0x08, 0x30, 0x0b, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0xa2, 0x03,
0x02, 0x01, 0x30, 0x03, 0x82, 0x01, 0x0f, 0x00, 0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01,
0x00, 0xcb, 0x1a, 0xed, 0x6b, 0x6a, 0x95, 0xf5, 0xb1, 0xce, 0x01, 0x3a, 0x4c, 0xfc, 0xab, 0x25,
0xb9, 0x4b, 0x2e, 0x64, 0xa2, 0x30, 0x34, 0xe4, 0x25, 0x0a, 0x7e, 0xab, 0x43, 0xc0, 0xdf, 0x3a,
0x8c, 0x12, 0x99, 0x3a, 0xf1, 0x2b, 0x11, 0x19, 0x08, 0xd4, 0xb4, 0x71, 0xbe, 0xc3, 0x1d, 0x4b,
0x6c, 0x9a, 0xd9, 0xcd, 0xda, 0x90, 0x61, 0x2a, 0x2e, 0xe9, 0x03, 0x52, 0x3e, 0x6d, 0xe5, 0xa2,
0x24, 0xd6, 0xb0, 0x2f, 0x09, 0xe5, 0xc3, 0x74, 0xd0, 0xcf, 0xe0, 0x1d, 0x8f, 0x52, 0x9c, 0x50,
0x0a, 0x78, 0xa2, 0xf6, 0x79, 0x08, 0xfa, 0x68, 0x2b, 0x5a, 0x2b, 0x43, 0x0c, 0x81, 0xea, 0xf1,
0xaf, 0x72, 0xd7, 0xb5, 0xe7, 0x94, 0xfc, 0x98, 0xa3, 0x13, 0x92, 0x76, 0x87, 0x97, 0x57, 0xce,
0x45, 0x3b, 0x52, 0x6e, 0xf9, 0xbf, 0x6c, 0xeb, 0x99, 0x97, 0x9b, 0x84, 0x23, 0xb9, 0x0f, 0x44,
0x61, 0xa2, 0x2a, 0xf3, 0x7a, 0xab, 0x0c, 0xf5, 0x73, 0x3f, 0x75, 0x97, 0xab, 0xe4, 0x4d, 0x31,
0xc7, 0x32, 0xdb, 0x68, 0xa1, 0x81, 0xc6, 0xcb, 0xbe, 0x60, 0x7d, 0x8c, 0x0e, 0x52, 0xe0, 0x65,
0x5f, 0xd9, 0x99, 0x6d, 0xc5, 0x84, 0xec, 0xa0, 0xbe, 0x87, 0xaf, 0xbc, 0xd7, 0x8a, 0x33, 0x7d,
0x17, 0xb1, 0xdb, 0xa9, 0xe8, 0x28, 0xbb, 0xd8, 0x1e, 0x29, 0x13, 0x17, 0x14, 0x4e, 0x7f, 0xf8,
0x9f, 0x55, 0x61, 0x97, 0x09, 0xb0, 0x96, 0xcb, 0xb9, 0xea, 0x47, 0x4c, 0xea, 0xd2, 0x64, 0xc2,
0x07, 0x3f, 0xe4, 0x97, 0x40, 0xc0, 0x1f, 0x00, 0xe1, 0x09, 0x10, 0x60, 0x66, 0x98, 0x3d, 0x21,
0xe5, 0xf8, 0x3f, 0x08, 0x6e, 0x2e, 0x82, 0x3c, 0x87, 0x9c, 0xd4, 0x3c, 0xef, 0x70, 0x0d, 0x2a,
0x35, 0x2a, 0x9b, 0xab, 0xd6, 0x12, 0xd0, 0x3c, 0xad, 0x02, 0xdb, 0x13, 0x4b, 0x7e, 0x22, 0x5a,
0x5f, 0x02, 0x03, 0x01, 0x00, 0x01};
uint8_t privKey[] = {0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x42, 0x45, 0x47, 0x49, 0x4E, 0x20, 0x50, 0x52, 0x49, 0x56, 0x41,
0x54, 0x45, 0x20, 0x4B, 0x45, 0x59, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x0A, 0x4D, 0x49, 0x49, 0x45,
0x76, 0x51, 0x49, 0x42, 0x41, 0x44, 0x41, 0x4E, 0x42, 0x67, 0x6B, 0x71, 0x68, 0x6B, 0x69, 0x47,
0x39, 0x77, 0x30, 0x42, 0x41, 0x51, 0x45, 0x46, 0x41, 0x41, 0x53, 0x43, 0x42, 0x4B, 0x63, 0x77,
0x67, 0x67, 0x53, 0x6A, 0x41, 0x67, 0x45, 0x41, 0x41, 0x6F, 0x49, 0x42, 0x41, 0x51, 0x44, 0x4C,
0x47, 0x75, 0x31, 0x72, 0x61, 0x70, 0x58, 0x31, 0x73, 0x63, 0x34, 0x42, 0x0A, 0x4F, 0x6B, 0x7A,
0x38, 0x71, 0x79, 0x57, 0x35, 0x53, 0x79, 0x35, 0x6B, 0x6F, 0x6A, 0x41, 0x30, 0x35, 0x43, 0x55,
0x4B, 0x66, 0x71, 0x74, 0x44, 0x77, 0x4E, 0x38, 0x36, 0x6A, 0x42, 0x4B, 0x5A, 0x4F, 0x76, 0x45,
0x72, 0x45, 0x52, 0x6B, 0x49, 0x31, 0x4C, 0x52, 0x78, 0x76, 0x73, 0x4D, 0x64, 0x53, 0x32, 0x79,
0x61, 0x32, 0x63, 0x33, 0x61, 0x6B, 0x47, 0x45, 0x71, 0x4C, 0x75, 0x6B, 0x44, 0x0A, 0x55, 0x6A,
0x35, 0x74, 0x35, 0x61, 0x49, 0x6B, 0x31, 0x72, 0x41, 0x76, 0x43, 0x65, 0x58, 0x44, 0x64, 0x4E,
0x44, 0x50, 0x34, 0x42, 0x32, 0x50, 0x55, 0x70, 0x78, 0x51, 0x43, 0x6E, 0x69, 0x69, 0x39, 0x6E,
0x6B, 0x49, 0x2B, 0x6D, 0x67, 0x72, 0x57, 0x69, 0x74, 0x44, 0x44, 0x49, 0x48, 0x71, 0x38, 0x61,
0x39, 0x79, 0x31, 0x37, 0x58, 0x6E, 0x6C, 0x50, 0x79, 0x59, 0x6F, 0x78, 0x4F, 0x53, 0x0A, 0x64,
0x6F, 0x65, 0x58, 0x56, 0x38, 0x35, 0x46, 0x4F, 0x31, 0x4A, 0x75, 0x2B, 0x62, 0x39, 0x73, 0x36,
0x35, 0x6D, 0x58, 0x6D, 0x34, 0x51, 0x6A, 0x75, 0x51, 0x39, 0x45, 0x59, 0x61, 0x49, 0x71, 0x38,
0x33, 0x71, 0x72, 0x44, 0x50, 0x56, 0x7A, 0x50, 0x33, 0x57, 0x58, 0x71, 0x2B, 0x52, 0x4E, 0x4D,
0x63, 0x63, 0x79, 0x32, 0x32, 0x69, 0x68, 0x67, 0x63, 0x62, 0x4C, 0x76, 0x6D, 0x42, 0x39, 0x0A,
0x6A, 0x41, 0x35, 0x53, 0x34, 0x47, 0x56, 0x66, 0x32, 0x5A, 0x6C, 0x74, 0x78, 0x59, 0x54, 0x73,
0x6F, 0x4C, 0x36, 0x48, 0x72, 0x37, 0x7A, 0x58, 0x69, 0x6A, 0x4E, 0x39, 0x46, 0x37, 0x48, 0x62,
0x71, 0x65, 0x67, 0x6F, 0x75, 0x39, 0x67, 0x65, 0x4B, 0x52, 0x4D, 0x58, 0x46, 0x45, 0x35, 0x2F,
0x2B, 0x4A, 0x39, 0x56, 0x59, 0x5A, 0x63, 0x4A, 0x73, 0x4A, 0x62, 0x4C, 0x75, 0x65, 0x70, 0x48,
0x0A, 0x54, 0x4F, 0x72, 0x53, 0x5A, 0x4D, 0x49, 0x48, 0x50, 0x2B, 0x53, 0x58, 0x51, 0x4D, 0x41,
0x66, 0x41, 0x4F, 0x45, 0x4A, 0x45, 0x47, 0x42, 0x6D, 0x6D, 0x44, 0x30, 0x68, 0x35, 0x66, 0x67,
0x2F, 0x43, 0x47, 0x34, 0x75, 0x67, 0x6A, 0x79, 0x48, 0x6E, 0x4E, 0x51, 0x38, 0x37, 0x33, 0x41,
0x4E, 0x4B, 0x6A, 0x55, 0x71, 0x6D, 0x36, 0x76, 0x57, 0x45, 0x74, 0x41, 0x38, 0x72, 0x51, 0x4C,
0x62, 0x0A, 0x45, 0x30, 0x74, 0x2B, 0x49, 0x6C, 0x70, 0x66, 0x41, 0x67, 0x4D, 0x42, 0x41, 0x41,
0x45, 0x43, 0x67, 0x67, 0x45, 0x41, 0x4C, 0x7A, 0x43, 0x62, 0x64, 0x7A, 0x69, 0x31, 0x6A, 0x50,
0x64, 0x35, 0x38, 0x4D, 0x6B, 0x56, 0x2B, 0x43, 0x4C, 0x66, 0x79, 0x66, 0x53, 0x51, 0x32, 0x2B,
0x72, 0x66, 0x48, 0x6E, 0x72, 0x66, 0x72, 0x46, 0x65, 0x50, 0x2F, 0x56, 0x63, 0x44, 0x78, 0x72,
0x75, 0x69, 0x0A, 0x32, 0x70, 0x31, 0x61, 0x53, 0x58, 0x4A, 0x59, 0x69, 0x62, 0x65, 0x36, 0x45,
0x53, 0x2B, 0x4D, 0x62, 0x2F, 0x4D, 0x46, 0x55, 0x64, 0x6C, 0x48, 0x50, 0x67, 0x41, 0x4C, 0x77,
0x31, 0x78, 0x51, 0x34, 0x57, 0x65, 0x72, 0x66, 0x36, 0x63, 0x36, 0x44, 0x43, 0x73, 0x68, 0x6C,
0x6C, 0x78, 0x4C, 0x57, 0x53, 0x56, 0x38, 0x47, 0x73, 0x42, 0x73, 0x76, 0x63, 0x38, 0x6F, 0x36,
0x47, 0x50, 0x32, 0x0A, 0x63, 0x59, 0x36, 0x6F, 0x77, 0x70, 0x42, 0x44, 0x77, 0x63, 0x62, 0x61,
0x68, 0x47, 0x4B, 0x55, 0x6B, 0x50, 0x30, 0x45, 0x6B, 0x62, 0x39, 0x53, 0x30, 0x58, 0x4C, 0x4A,
0x57, 0x63, 0x47, 0x53, 0x47, 0x35, 0x61, 0x55, 0x6E, 0x48, 0x4A, 0x58, 0x52, 0x37, 0x69, 0x6E,
0x78, 0x34, 0x63, 0x5A, 0x6C, 0x66, 0x6F, 0x4C, 0x6E, 0x72, 0x45, 0x51, 0x65, 0x36, 0x68, 0x55,
0x78, 0x73, 0x4D, 0x71, 0x0A, 0x62, 0x30, 0x64, 0x48, 0x78, 0x64, 0x48, 0x44, 0x42, 0x4D, 0x64,
0x47, 0x66, 0x56, 0x57, 0x77, 0x67, 0x4B, 0x6F, 0x6A, 0x4F, 0x6A, 0x70, 0x53, 0x2F, 0x39, 0x38,
0x6D, 0x45, 0x55, 0x79, 0x37, 0x56, 0x42, 0x2F, 0x36, 0x61, 0x32, 0x6C, 0x72, 0x65, 0x67, 0x6C,
0x76, 0x6A, 0x63, 0x2F, 0x32, 0x6E, 0x4B, 0x43, 0x4B, 0x74, 0x59, 0x37, 0x37, 0x44, 0x37, 0x64,
0x54, 0x71, 0x6C, 0x47, 0x46, 0x0A, 0x78, 0x7A, 0x41, 0x42, 0x61, 0x57, 0x75, 0x38, 0x36, 0x4D,
0x43, 0x5A, 0x34, 0x2F, 0x51, 0x31, 0x33, 0x4C, 0x76, 0x2B, 0x42, 0x65, 0x66, 0x62, 0x71, 0x74,
0x49, 0x39, 0x73, 0x71, 0x5A, 0x5A, 0x77, 0x6A, 0x72, 0x64, 0x55, 0x68, 0x51, 0x48, 0x38, 0x56,
0x43, 0x78, 0x72, 0x79, 0x32, 0x51, 0x56, 0x4D, 0x51, 0x57, 0x51, 0x69, 0x6E, 0x57, 0x68, 0x41,
0x74, 0x36, 0x4D, 0x71, 0x54, 0x34, 0x0A, 0x53, 0x42, 0x53, 0x54, 0x72, 0x6F, 0x6C, 0x5A, 0x7A,
0x77, 0x72, 0x71, 0x6A, 0x65, 0x38, 0x4D, 0x50, 0x4A, 0x39, 0x31, 0x75, 0x61, 0x4E, 0x4D, 0x64,
0x58, 0x47, 0x4C, 0x63, 0x48, 0x4C, 0x49, 0x32, 0x36, 0x73, 0x58, 0x7A, 0x76, 0x37, 0x4B, 0x53,
0x51, 0x4B, 0x42, 0x67, 0x51, 0x44, 0x76, 0x63, 0x77, 0x73, 0x50, 0x55, 0x55, 0x76, 0x41, 0x39,
0x5A, 0x32, 0x5A, 0x58, 0x39, 0x58, 0x35, 0x0A, 0x6D, 0x49, 0x78, 0x4D, 0x54, 0x42, 0x4E, 0x64,
0x45, 0x46, 0x7A, 0x56, 0x62, 0x55, 0x50, 0x75, 0x4B, 0x4B, 0x41, 0x31, 0x79, 0x57, 0x6E, 0x31,
0x55, 0x4D, 0x44, 0x4E, 0x63, 0x55, 0x6A, 0x71, 0x68, 0x2B, 0x7A, 0x65, 0x2F, 0x37, 0x6B, 0x33,
0x79, 0x46, 0x78, 0x6B, 0x68, 0x30, 0x51, 0x46, 0x33, 0x31, 0x62, 0x71, 0x36, 0x30, 0x65, 0x4C,
0x39, 0x30, 0x47, 0x49, 0x53, 0x69, 0x41, 0x4F, 0x0A, 0x35, 0x4B, 0x4F, 0x57, 0x4D, 0x39, 0x45,
0x4B, 0x6F, 0x2B, 0x78, 0x41, 0x51, 0x32, 0x62, 0x61, 0x4B, 0x31, 0x4D, 0x66, 0x4F, 0x59, 0x31,
0x47, 0x2B, 0x38, 0x6A, 0x7A, 0x42, 0x58, 0x55, 0x70, 0x42, 0x73, 0x39, 0x34, 0x6B, 0x35, 0x33,
0x53, 0x38, 0x38, 0x79, 0x58, 0x6D, 0x4B, 0x36, 0x6E, 0x79, 0x64, 0x67, 0x76, 0x37, 0x30, 0x42,
0x4A, 0x38, 0x5A, 0x68, 0x35, 0x66, 0x6B, 0x55, 0x71, 0x0A, 0x57, 0x32, 0x30, 0x6F, 0x53, 0x62,
0x68, 0x6B, 0x68, 0x6A, 0x52, 0x64, 0x53, 0x7A, 0x48, 0x32, 0x6B, 0x52, 0x47, 0x69, 0x72, 0x67,
0x2B, 0x55, 0x53, 0x77, 0x4B, 0x42, 0x67, 0x51, 0x44, 0x5A, 0x4A, 0x4D, 0x6E, 0x72, 0x79, 0x32,
0x45, 0x78, 0x61, 0x2F, 0x33, 0x45, 0x71, 0x37, 0x50, 0x62, 0x6F, 0x73, 0x78, 0x41, 0x50, 0x4D,
0x69, 0x59, 0x6E, 0x6B, 0x35, 0x4A, 0x41, 0x50, 0x53, 0x47, 0x0A, 0x79, 0x32, 0x7A, 0x30, 0x5A,
0x37, 0x54, 0x55, 0x62, 0x2B, 0x75, 0x48, 0x51, 0x4F, 0x2F, 0x2B, 0x78, 0x50, 0x4D, 0x37, 0x6E,
0x43, 0x30, 0x75, 0x79, 0x4C, 0x49, 0x4D, 0x44, 0x39, 0x6C, 0x61, 0x54, 0x4D, 0x48, 0x77, 0x6E,
0x36, 0x73, 0x37, 0x2F, 0x4C, 0x62, 0x47, 0x6F, 0x45, 0x50, 0x31, 0x57, 0x52, 0x67, 0x70, 0x6F,
0x59, 0x48, 0x2F, 0x42, 0x31, 0x34, 0x6B, 0x2F, 0x52, 0x6E, 0x36, 0x0A, 0x66, 0x75, 0x77, 0x52,
0x4E, 0x36, 0x32, 0x49, 0x6F, 0x39, 0x74, 0x63, 0x39, 0x2B, 0x41, 0x43, 0x4C, 0x74, 0x55, 0x42,
0x37, 0x76, 0x74, 0x47, 0x61, 0x79, 0x33, 0x2B, 0x67, 0x52, 0x77, 0x59, 0x74, 0x53, 0x43, 0x32,
0x62, 0x35, 0x65, 0x64, 0x38, 0x6C, 0x49, 0x69, 0x65, 0x67, 0x74, 0x54, 0x6B, 0x65, 0x61, 0x30,
0x68, 0x30, 0x75, 0x44, 0x53, 0x52, 0x78, 0x41, 0x74, 0x56, 0x73, 0x33, 0x0A, 0x6E, 0x35, 0x6B,
0x79, 0x61, 0x32, 0x51, 0x39, 0x76, 0x51, 0x4B, 0x42, 0x67, 0x46, 0x4A, 0x75, 0x46, 0x7A, 0x4F,
0x5A, 0x74, 0x2B, 0x74, 0x67, 0x59, 0x6E, 0x57, 0x6E, 0x51, 0x55, 0x45, 0x67, 0x57, 0x38, 0x50,
0x30, 0x4F, 0x49, 0x4A, 0x45, 0x48, 0x4D, 0x45, 0x34, 0x55, 0x54, 0x64, 0x4F, 0x63, 0x77, 0x43,
0x78, 0x4B, 0x72, 0x48, 0x52, 0x72, 0x39, 0x33, 0x4A, 0x6A, 0x75, 0x46, 0x32, 0x0A, 0x45, 0x33,
0x77, 0x64, 0x4B, 0x6F, 0x54, 0x69, 0x69, 0x37, 0x50, 0x72, 0x77, 0x4F, 0x59, 0x49, 0x6F, 0x61,
0x4A, 0x54, 0x68, 0x70, 0x6A, 0x50, 0x63, 0x4A, 0x62, 0x62, 0x64, 0x62, 0x66, 0x4B, 0x79, 0x2B,
0x6E, 0x73, 0x51, 0x70, 0x31, 0x59, 0x47, 0x76, 0x39, 0x77, 0x64, 0x4A, 0x72, 0x4D, 0x61, 0x56,
0x77, 0x4A, 0x63, 0x76, 0x49, 0x70, 0x77, 0x56, 0x36, 0x76, 0x31, 0x55, 0x70, 0x66, 0x0A, 0x56,
0x74, 0x4C, 0x61, 0x64, 0x6D, 0x31, 0x6C, 0x6B, 0x6C, 0x76, 0x70, 0x71, 0x73, 0x36, 0x47, 0x4E,
0x4D, 0x38, 0x6A, 0x6E, 0x4D, 0x30, 0x58, 0x78, 0x33, 0x61, 0x6A, 0x6D, 0x6D, 0x6E, 0x66, 0x65,
0x57, 0x39, 0x79, 0x47, 0x58, 0x45, 0x35, 0x70, 0x68, 0x4D, 0x72, 0x7A, 0x4C, 0x4A, 0x6C, 0x39,
0x46, 0x30, 0x39, 0x63, 0x49, 0x32, 0x4C, 0x41, 0x6F, 0x47, 0x42, 0x41, 0x4E, 0x58, 0x76, 0x0A,
0x75, 0x67, 0x56, 0x58, 0x72, 0x70, 0x32, 0x62, 0x73, 0x54, 0x31, 0x6F, 0x6B, 0x64, 0x36, 0x75,
0x53, 0x61, 0x42, 0x73, 0x67, 0x70, 0x4A, 0x6A, 0x50, 0x65, 0x77, 0x4E, 0x52, 0x64, 0x33, 0x63,
0x5A, 0x4B, 0x39, 0x7A, 0x30, 0x61, 0x53, 0x50, 0x31, 0x44, 0x54, 0x41, 0x31, 0x50, 0x4E, 0x6B,
0x70, 0x65, 0x51, 0x77, 0x48, 0x67, 0x2F, 0x2B, 0x36, 0x66, 0x53, 0x61, 0x56, 0x4F, 0x48, 0x7A,
0x0A, 0x79, 0x41, 0x78, 0x44, 0x73, 0x39, 0x68, 0x35, 0x52, 0x72, 0x62, 0x78, 0x52, 0x61, 0x4E,
0x66, 0x73, 0x54, 0x2B, 0x72, 0x41, 0x55, 0x48, 0x37, 0x78, 0x31, 0x53, 0x59, 0x44, 0x56, 0x56,
0x51, 0x59, 0x56, 0x4D, 0x68, 0x55, 0x52, 0x62, 0x54, 0x6F, 0x5A, 0x65, 0x36, 0x47, 0x2F, 0x6A,
0x71, 0x6E, 0x54, 0x43, 0x33, 0x66, 0x4E, 0x66, 0x48, 0x56, 0x31, 0x78, 0x74, 0x5A, 0x66, 0x6F,
0x74, 0x0A, 0x30, 0x6C, 0x6F, 0x4D, 0x48, 0x67, 0x77, 0x65, 0x70, 0x36, 0x2B, 0x53, 0x49, 0x4D,
0x43, 0x6F, 0x65, 0x65, 0x32, 0x5A, 0x63, 0x74, 0x75, 0x5A, 0x56, 0x33, 0x32, 0x6C, 0x63, 0x49,
0x61, 0x66, 0x39, 0x72, 0x62, 0x48, 0x4F, 0x63, 0x37, 0x64, 0x41, 0x6F, 0x47, 0x41, 0x65, 0x51,
0x38, 0x6B, 0x38, 0x53, 0x49, 0x4C, 0x4E, 0x47, 0x36, 0x44, 0x4F, 0x41, 0x33, 0x31, 0x54, 0x45,
0x35, 0x50, 0x0A, 0x6D, 0x30, 0x31, 0x41, 0x4A, 0x49, 0x59, 0x77, 0x37, 0x41, 0x6C, 0x52, 0x33,
0x75, 0x6F, 0x2F, 0x52, 0x4E, 0x61, 0x43, 0x2B, 0x78, 0x59, 0x64, 0x50, 0x55, 0x33, 0x54, 0x73,
0x6B, 0x75, 0x41, 0x4C, 0x78, 0x78, 0x69, 0x44, 0x52, 0x2F, 0x57, 0x73, 0x4C, 0x45, 0x51, 0x42,
0x43, 0x6A, 0x6B, 0x46, 0x57, 0x6D, 0x6D, 0x4A, 0x41, 0x57, 0x6E, 0x51, 0x55, 0x44, 0x74, 0x62,
0x6E, 0x59, 0x4E, 0x0A, 0x53, 0x63, 0x77, 0x52, 0x38, 0x47, 0x32, 0x4A, 0x36, 0x46, 0x6E, 0x72,
0x45, 0x43, 0x74, 0x62, 0x74, 0x79, 0x73, 0x37, 0x33, 0x57, 0x41, 0x56, 0x47, 0x6F, 0x6F, 0x46,
0x5A, 0x6E, 0x63, 0x6D, 0x50, 0x4C, 0x50, 0x38, 0x6C, 0x78, 0x4C, 0x79, 0x62, 0x6C, 0x53, 0x42,
0x44, 0x45, 0x4C, 0x79, 0x61, 0x5A, 0x76, 0x2F, 0x62, 0x41, 0x73, 0x50, 0x6C, 0x4D, 0x4F, 0x39,
0x62, 0x44, 0x35, 0x63, 0x0A, 0x4A, 0x2B, 0x4E, 0x53, 0x42, 0x61, 0x61, 0x2B, 0x6F, 0x69, 0x4C,
0x6C, 0x31, 0x77, 0x6D, 0x43, 0x61, 0x35, 0x4D, 0x43, 0x66, 0x6C, 0x63, 0x3D, 0x0A, 0x2D, 0x2D,
0x2D, 0x2D, 0x2D, 0x45, 0x4E, 0x44, 0x20, 0x50, 0x52, 0x49, 0x56, 0x41, 0x54, 0x45, 0x20, 0x4B,
0x45, 0x59, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x0A};
void PrintLastError(void) {
const char *file = NULL;
uint32_t line = 0;
BSL_ERR_GetLastErrorFileLine(&file, &line);
printf("failed at file %s at line %d\n", file, line);
}
void PrintHex(const uint8_t* data, uint32_t len) {
for (uint32_t i = 0; i < len; i++) {
printf("%02X", data[i]);
if ((i + 1) % 16 == 0 && i + 1 < len) {
printf("\n");
} else {
printf(" ");
}
}
printf("\n");
}
int main(void) {
int32_t ret = 1;
HITLS_AUTH_PrivPassCtx *client = NULL;
HITLS_AUTH_PrivPassCtx *issuer = NULL;
HITLS_AUTH_PrivPassCtx *server = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge = NULL;
HITLS_AUTH_PrivPassToken *tokenRequest = NULL;
HITLS_AUTH_PrivPassToken *tokenResponse = NULL;
HITLS_AUTH_PrivPassToken *finalToken = NULL;
uint8_t *tokenChallengeBuff = NULL;
uint32_t tokenChallengeLen = 0;
uint8_t *tokenRequestBuff = NULL;
uint32_t tokenRequestLen = 0;
uint8_t *tokenResponseBuff = NULL;
uint32_t tokenResponseLen = 0;
uint8_t *finalTokenBuff = NULL;
uint32_t finalTokenLen = 0;
// Construct parameter structure
uint16_t tokenTypeValue = 0x0002;
uint8_t issuerName[] = "Example Issuer";
uint8_t redemption[] = ""; // Length must be 0 or 32
uint8_t originInfo[] = "Example Origin";
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, sizeof(issuerName),
sizeof(issuerName)},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemption, 0, 0},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ORIGININFO, BSL_PARAM_TYPE_OCTETS_PTR, originInfo, sizeof(originInfo),
sizeof(originInfo)},
BSL_PARAM_END
};
ret = CRYPT_EAL_Init(CRYPT_EAL_INIT_ALL);
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
client = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
issuer = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
server = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
if (!client || !issuer || !server) {
printf("Failed to create contexts\n");
PrintLastError();
goto EXIT;
}
// Set keys
if (HITLS_AUTH_PrivPassSetPubkey(client, pubKey, sizeof(pubKey)) != HITLS_AUTH_SUCCESS ||
HITLS_AUTH_PrivPassSetPubkey(issuer, pubKey, sizeof(pubKey)) != HITLS_AUTH_SUCCESS ||
HITLS_AUTH_PrivPassSetPrvkey(issuer, NULL, privKey, sizeof(privKey)) != HITLS_AUTH_SUCCESS ||
HITLS_AUTH_PrivPassSetPubkey(server, pubKey, sizeof(pubKey)) != HITLS_AUTH_SUCCESS) {
printf("Failed to set keys\n");
PrintLastError();
goto EXIT;
}
printf("\ntokenChallenge: server ------> client\n");
if (HITLS_AUTH_PrivPassGenTokenChallenge(server, param, &tokenChallenge) != HITLS_AUTH_SUCCESS) {
printf("Failed to generate token challenge\n");
PrintLastError();
goto EXIT;
}
if (HITLS_AUTH_PrivPassSerialization(server, tokenChallenge, NULL, &tokenChallengeLen) != HITLS_AUTH_SUCCESS) {
printf("Failed to serialize token challenge\n");
PrintLastError();
goto EXIT;
}
tokenChallengeBuff = BSL_SAL_Malloc(tokenChallengeLen);
if (tokenChallengeBuff == NULL) {
printf("Failed to allocate memory for token challenge\n");
PrintLastError();
goto EXIT;
}
if (HITLS_AUTH_PrivPassSerialization(server, tokenChallenge, tokenChallengeBuff, &tokenChallengeLen) !=
HITLS_AUTH_SUCCESS) {
printf("Failed to serialize token challenge\n");
PrintLastError();
goto EXIT;
}
PrintHex(tokenChallengeBuff, tokenChallengeLen);
printf("\ntokenRequest: client ------> issuer\n");
if (HITLS_AUTH_PrivPassGenTokenReq(client, tokenChallenge, &tokenRequest) != HITLS_AUTH_SUCCESS) {
printf("Failed to generate token request\n");
PrintLastError();
goto EXIT;
}
if (HITLS_AUTH_PrivPassSerialization(client, tokenRequest, NULL, &tokenRequestLen) != HITLS_AUTH_SUCCESS) {
printf("Failed to serialize token request\n");
PrintLastError();
goto EXIT;
}
tokenRequestBuff = BSL_SAL_Malloc(tokenRequestLen);
if (tokenRequestBuff == NULL) {
printf("Failed to allocate memory for token request\n");
PrintLastError();
goto EXIT;
}
if (HITLS_AUTH_PrivPassSerialization(client, tokenRequest, tokenRequestBuff, &tokenRequestLen)
!= HITLS_AUTH_SUCCESS) {
printf("Failed to serialize token request\n");
PrintLastError();
goto EXIT;
}
PrintHex(tokenRequestBuff, tokenRequestLen);
printf("\ntokenResponse: issuer ------> client\n");
if (HITLS_AUTH_PrivPassGenTokenResponse(issuer, tokenRequest, &tokenResponse) != HITLS_AUTH_SUCCESS) {
printf("Failed to generate token response\n");
PrintLastError();
goto EXIT;
}
if (HITLS_AUTH_PrivPassSerialization(client, tokenResponse, NULL, &tokenResponseLen) != HITLS_AUTH_SUCCESS) {
printf("Failed to serialize token response\n");
PrintLastError();
goto EXIT;
}
tokenResponseBuff = BSL_SAL_Malloc(tokenResponseLen);
if (tokenResponseBuff == NULL) {
printf("Failed to allocate memory for token response\n");
PrintLastError();
goto EXIT;
}
if (HITLS_AUTH_PrivPassSerialization(client, tokenResponse, tokenResponseBuff, &tokenResponseLen) !=
HITLS_AUTH_SUCCESS) {
printf("Failed to serialize token response\n");
PrintLastError();
goto EXIT;
}
PrintHex(tokenResponseBuff, tokenResponseLen);
printf("\nfinalToken: client ------> server\n");
if (HITLS_AUTH_PrivPassGenToken(client, tokenChallenge, tokenResponse, &finalToken) != HITLS_AUTH_SUCCESS) {
printf("Failed to generate final token\n");
PrintLastError();
goto EXIT;
}
if (HITLS_AUTH_PrivPassSerialization(client, finalToken, NULL, &finalTokenLen) != HITLS_AUTH_SUCCESS) {
printf("Failed to serialize final token\n");
PrintLastError();
goto EXIT;
}
finalTokenBuff = BSL_SAL_Malloc(finalTokenLen);
if (finalTokenBuff == NULL) {
printf("Failed to allocate memory for final token\n");
PrintLastError();
goto EXIT;
}
if (HITLS_AUTH_PrivPassSerialization(client, finalToken, finalTokenBuff, &finalTokenLen) != HITLS_AUTH_SUCCESS) {
printf("Failed to serialize final token\n");
PrintLastError();
goto EXIT;
}
PrintHex(finalTokenBuff, finalTokenLen);
printf("\nverifyToken: server\n");
if (HITLS_AUTH_PrivPassVerifyToken(server, tokenChallenge, finalToken) != HITLS_AUTH_SUCCESS) {
printf("Token verification failed\n");
PrintLastError();
goto EXIT;
}
printf("Privacy pass public token verify process completed successfully!\n");
ret = HITLS_AUTH_SUCCESS;
EXIT:
HITLS_AUTH_PrivPassFreeToken(tokenChallenge);
HITLS_AUTH_PrivPassFreeToken(tokenRequest);
HITLS_AUTH_PrivPassFreeToken(tokenResponse);
HITLS_AUTH_PrivPassFreeToken(finalToken);
HITLS_AUTH_PrivPassFreeCtx(client);
HITLS_AUTH_PrivPassFreeCtx(issuer);
HITLS_AUTH_PrivPassFreeCtx(server);
BSL_SAL_FREE(tokenChallengeBuff);
BSL_SAL_FREE(tokenRequestBuff);
BSL_SAL_FREE(tokenResponseBuff);
BSL_SAL_FREE(finalTokenBuff);
return ret;
}
| 2401_83913325/openHiTLS_1 | testcode/demo/privpass_token.c | C | unknown | 20,588 |
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_err.h"
#include "crypt_algid.h"
#include "crypt_eal_init.h"
#include "crypt_eal_rand.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_codecs.h"
#include "hitls_error.h"
#include "hitls_config.h"
#include "hitls.h"
#include "hitls_cert_init.h"
#include "hitls_cert.h"
#include "hitls_crypt_init.h"
#include "hitls_pki_cert.h"
#include "crypt_errno.h"
#define CERTS_PATH "../../../testcode/testdata/tls/certificate/der/ecdsa_sha256/"
#define HTTP_BUF_MAXLEN (18 * 1024) /* 18KB */
int main(int32_t argc, char *argv[])
{
int32_t exitValue = -1;
int32_t ret = 0;
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
BSL_UIO *uio = NULL;
int fd = 0;
int infd = 0;
HITLS_X509_Cert *rootCA = NULL;
HITLS_X509_Cert *subCA = NULL;
HITLS_X509_Cert *serverCert = NULL;
CRYPT_EAL_PkeyCtx *pkey = NULL;
ret = CRYPT_EAL_Init(CRYPT_EAL_INIT_ALL);
if (ret != CRYPT_SUCCESS) {
printf("CRYPT_EAL_Init: error code is %x\n", ret);
return -1;
}
HITLS_CertMethodInit();
HITLS_CryptMethodInit();
fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd == -1) {
printf("Create socket failed.\n");
return -1;
}
int option = 1;
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option)) < 0) {
printf("setsockopt SO_REUSEADDR failed.\n");
goto EXIT;
}
struct sockaddr_in serverAddr;
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(12345);
serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(fd, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) != 0) {
printf("bind failed.\n");
goto EXIT;
}
if (listen(fd, 5) != 0) {
printf("listen socket fail\n");
goto EXIT;
}
struct sockaddr_in clientAddr;
unsigned int len = sizeof(struct sockaddr_in);
infd = accept(fd, (struct sockaddr *)&clientAddr, &len);
if (infd < 0) {
printf("accept failed.\n");
goto EXIT;
}
config = HITLS_CFG_NewTLS12Config();
if (config == NULL) {
printf("HITLS_CFG_NewTLS12Config failed.\n");
goto EXIT;
}
ret = HITLS_CFG_SetClientVerifySupport(config, false); // disable peer verify
if (ret != HITLS_SUCCESS) {
printf("Disable peer verify faild.\n");
goto EXIT;
}
/* 加载证书：需要用户实现 */
ret = HITLS_X509_CertParseFile(BSL_FORMAT_ASN1, CERTS_PATH "ca.der", &rootCA);
if (ret != HITLS_SUCCESS) {
printf("Parse ca failed.\n");
goto EXIT;
}
ret = HITLS_X509_CertParseFile(BSL_FORMAT_ASN1, CERTS_PATH "inter.der", &subCA);
if (ret != HITLS_SUCCESS) {
printf("Parse subca failed.\n");
goto EXIT;
}
HITLS_CFG_AddCertToStore(config, rootCA, TLS_CERT_STORE_TYPE_DEFAULT, true);
HITLS_CFG_AddCertToStore(config, subCA, TLS_CERT_STORE_TYPE_DEFAULT, true);
HITLS_CFG_LoadCertFile(config, CERTS_PATH "server.der", TLS_PARSE_FORMAT_ASN1);
HITLS_CFG_LoadKeyFile(config, CERTS_PATH "server.key.der", TLS_PARSE_FORMAT_ASN1);
/* 新建openHiTLS上下文 */
ctx = HITLS_New(config);
if (ctx == NULL) {
printf("HITLS_New failed.\n");
goto EXIT;
}
/* 用户可按需实现method */
uio = BSL_UIO_New(BSL_UIO_TcpMethod());
if (uio == NULL) {
printf("BSL_UIO_New failed.\n");
goto EXIT;
}
ret = BSL_UIO_Ctrl(uio, BSL_UIO_SET_FD, (int32_t)sizeof(fd), &infd);
if (ret != HITLS_SUCCESS) {
BSL_UIO_Free(uio);
printf("BSL_UIO_SET_FD failed, fd = %u.\n", fd);
goto EXIT;
}
ret = HITLS_SetUio(ctx, uio);
if (ret != HITLS_SUCCESS) {
BSL_UIO_Free(uio);
printf("HITLS_SetUio failed. ret = 0x%x.\n", ret);
goto EXIT;
}
/* 进行TLS连接、用户需按实际场景考虑返回值 */
ret = HITLS_Accept(ctx);
if (ret != HITLS_SUCCESS) {
printf("HITLS_Accept failed, ret = 0x%x.\n", ret);
goto EXIT;
}
/* 读取对端报文、用户需按实际场景考虑返回值 */
uint8_t readBuf[HTTP_BUF_MAXLEN + 1] = {0};
uint32_t readLen = 0;
ret = HITLS_Read(ctx, readBuf, HTTP_BUF_MAXLEN, &readLen);
if (ret != HITLS_SUCCESS) {
printf("HITLS_Read failed, ret = 0x%x.\n", ret);
goto EXIT;
}
printf("get from client size:%u :%s\n", readLen, readBuf);
/* 向对端发送报文、用户需按实际场景考虑返回值 */
const uint8_t sndBuf[] = "Hi, this is server\n";
uint32_t writeLen = 0;
ret = HITLS_Write(ctx, sndBuf, sizeof(sndBuf), &writeLen);
if (ret != HITLS_SUCCESS) {
printf("HITLS_Write error:error code:%d\n", ret);
goto EXIT;
}
exitValue = 0;
EXIT:
HITLS_Close(ctx);
HITLS_Free(ctx);
HITLS_CFG_FreeConfig(config);
close(fd);
close(infd);
HITLS_X509_CertFree(rootCA);
HITLS_X509_CertFree(subCA);
HITLS_X509_CertFree(serverCert);
CRYPT_EAL_PkeyFreeCtx(pkey);
BSL_UIO_Free(uio);
return exitValue;
} | 2401_83913325/openHiTLS_1 | testcode/demo/server.c | C | unknown | 5,224 |
/*
* 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 <stdint.h>
#include <string.h>
#include "crypt_eal_pkey.h" // Header file of the interfaces for asymmetric encryption and decryption.
#include "bsl_sal.h"
#include "bsl_err.h"
#include "crypt_algid.h"
#include "crypt_errno.h"
#include "crypt_eal_rand.h"
#include "crypt_eal_init.h"
#include "crypt_types.h"
void *StdMalloc(uint32_t len) {
return malloc((uint32_t)len);
}
void PrintLastError(void) {
const char *file = NULL;
uint32_t line = 0;
BSL_ERR_GetLastErrorFileLine(&file, &line);
printf("failed at file %s at line %d\n", file, line);
}
int main(void) {
int32_t ret;
ret = CRYPT_EAL_Init(CRYPT_EAL_INIT_ALL);
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
CRYPT_EAL_PkeyCtx *pkey = NULL;
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SM2);
if (pkey == NULL) {
PrintLastError();
goto EXIT;
}
// Generate a key pair.
ret = CRYPT_EAL_PkeyGen(pkey);
if (ret != CRYPT_SUCCESS) {
printf("CRYPT_EAL_PkeyGen: error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
// Data to be encrypted.
char *data = "test enc data";
uint32_t dataLen = 12;
uint8_t ecrypt[125] = {0};
uint32_t ecryptLen = 125;
uint8_t dcrypt[125] = {0};
uint32_t dcryptLen = 125;
// Encrypt data.
ret = CRYPT_EAL_PkeyEncrypt(pkey, (const uint8_t *)data, dataLen, ecrypt, &ecryptLen);
if (ret != CRYPT_SUCCESS) {
printf("CRYPT_EAL_PkeyEncrypt: error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
// Decrypt data.
ret = CRYPT_EAL_PkeyDecrypt(pkey, ecrypt, ecryptLen, dcrypt, &dcryptLen);
if (ret != CRYPT_SUCCESS) {
printf("CRYPT_EAL_PkeyDecrypt: error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
if (memcmp(dcrypt, data, dataLen) == 0) {
printf("encrypt and decrypt success\n");
} else {
ret = -1;
}
EXIT:
// Release the context memory.
CRYPT_EAL_PkeyFreeCtx(pkey);
CRYPT_EAL_RandDeinit();
BSL_ERR_DeInit();
return ret;
} | 2401_83913325/openHiTLS_1 | testcode/demo/sm2enc.c | C | unknown | 2,729 |
/*
* 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 <stdint.h>
#include <string.h>
#include "crypt_eal_pkey.h" // Header file for signature verification.
#include "bsl_sal.h"
#include "bsl_err.h"
#include "crypt_algid.h"
#include "crypt_errno.h"
#include "crypt_eal_rand.h"
#include "crypt_eal_init.h"
void PrintLastError(void) {
const char *file = NULL;
uint32_t line = 0;
BSL_ERR_GetLastErrorFileLine(&file, &line);// Obtain the name and number of lines of the error file.
printf("failed at file %s at line %d\n", file, line);
}
int main(void)
{
int ret;
uint8_t userId[32] = {0};
uint8_t key[32] = {0};
uint8_t msg[32] = {0};
uint8_t signBuf[100] = {0};
uint32_t signLen = sizeof(signBuf);
CRYPT_EAL_PkeyPrv prv = {0};
CRYPT_EAL_PkeyPub pub = {0};
CRYPT_EAL_PkeyCtx *ctx = NULL;
ret = CRYPT_EAL_Init(CRYPT_EAL_INIT_ALL);
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
goto EXIT;
}
ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SM2);
if (ctx == NULL) {
goto EXIT;
}
// Set a user ID.
ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, userId, sizeof(userId));
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
// Generate a key pair.
ret = CRYPT_EAL_PkeyGen(ctx);
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
// Sign.
ret = CRYPT_EAL_PkeySign(ctx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, &signLen);
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
// Verify the signature.
ret = CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_SM3, msg, sizeof(msg), signBuf, signLen);
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
printf("pass \n");
EXIT:
// Release the context memory.
CRYPT_EAL_PkeyFreeCtx(ctx);
CRYPT_EAL_RandDeinit();
BSL_ERR_DeInit();
return ret;
} | 2401_83913325/openHiTLS_1 | testcode/demo/sm2sign.c | C | unknown | 2,679 |
/*
* 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 <stdint.h>
#include <string.h>
#include "crypt_eal_cipher.h" // Header file of the interfaces for symmetric encryption and decryption.
#include "bsl_sal.h"
#include "bsl_err.h"
#include "crypt_algid.h" // Algorithm ID list.
#include "crypt_errno.h" // Error code list.
void *StdMalloc(uint32_t len) {
return malloc((size_t)len);
}
void PrintLastError(void) {
const char *file = NULL;
uint32_t line = 0;
BSL_ERR_GetLastErrorFileLine(&file, &line); // Obtain the name and number of lines of the error file.
printf("failed at file %s at line %d\n", file, line);
}
int main(void)
{
uint8_t data[10] = {0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x1c, 0x14};
uint8_t iv[16] = {0};
uint8_t key[16] = {0};
uint32_t dataLen = sizeof(data);
uint8_t cipherText[100];
uint8_t plainText[100];
uint32_t outTotalLen = 0;
uint32_t outLen = sizeof(cipherText);
uint32_t cipherTextLen;
int32_t ret;
printf("plain text to be encrypted: ");
for (uint32_t i = 0; i < dataLen; i++) {
printf("%02x", data[i]);
}
printf("\n");
// Create a context.
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_SM4_CBC);
if (ctx == NULL) {
PrintLastError();
BSL_ERR_DeInit();
return 1;
}
/*
* During initialization, the last input parameter can be true or false. true indicates encryption,
* and false indicates decryption.
*/
ret = CRYPT_EAL_CipherInit(ctx, key, sizeof(key), iv, sizeof(iv), true);
if (ret != CRYPT_SUCCESS) {
// Output the error code. You can find the error information in **crypt_errno.h** based on the error code.
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
// Set the padding mode.
ret = CRYPT_EAL_CipherSetPadding(ctx, CRYPT_PADDING_PKCS7);
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
/**
* Enter the data to be calculated. This interface can be called for multiple times.
* The input value of **outLen** is the length of the ciphertext,
* and the output value is the amount of processed data.
*
*/
ret = CRYPT_EAL_CipherUpdate(ctx, data, dataLen, cipherText, &outLen);
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
outTotalLen += outLen;
outLen = sizeof(cipherText) - outTotalLen;
ret = CRYPT_EAL_CipherFinal(ctx, cipherText + outTotalLen, &outLen);
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
outTotalLen += outLen;
printf("cipher text value is: ");
for (uint32_t i = 0; i < outTotalLen; i++) {
printf("%02x", cipherText[i]);
}
printf("\n");
// Start decryption.
cipherTextLen = outTotalLen;
outTotalLen = 0;
outLen = sizeof(plainText);
// When initializing the decryption function, set the last input parameter to false.
ret = CRYPT_EAL_CipherInit(ctx, key, sizeof(key), iv, sizeof(iv), false);
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
// Set the padding mode, which must be the same as that for encryption.
ret = CRYPT_EAL_CipherSetPadding(ctx, CRYPT_PADDING_PKCS7);
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
// Enter the ciphertext data.
ret = CRYPT_EAL_CipherUpdate(ctx, cipherText, cipherTextLen, plainText, &outLen);
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
outTotalLen += outLen;
outLen = sizeof(plainText) - outTotalLen;
// Decrypt the last segment of data and remove the filled content.
ret = CRYPT_EAL_CipherFinal(ctx, plainText + outTotalLen, &outLen);
if (ret != CRYPT_SUCCESS) {
printf("error code is %x\n", ret);
PrintLastError();
goto EXIT;
}
outTotalLen += outLen;
printf("decrypted plain text value is: ");
for (uint32_t i = 0; i < outTotalLen; i++) {
printf("%02x", plainText[i]);
}
printf("\n");
if (outTotalLen != dataLen || memcmp(plainText, data, dataLen) != 0) {
printf("plaintext comparison failed\n");
goto EXIT;
}
printf("pass \n");
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
BSL_ERR_DeInit();
return ret;
} | 2401_83913325/openHiTLS_1 | testcode/demo/sm4cbc.c | C | unknown | 5,187 |
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_err.h"
#include "crypt_eal_init.h"
#include "crypt_algid.h"
#include "crypt_eal_rand.h"
#include "hitls_error.h"
#include "hitls_config.h"
#include "hitls.h"
#include "hitls_cert_init.h"
#include "hitls_cert.h"
#include "hitls_crypt_init.h"
#include "hitls_pki_cert.h"
#include "crypt_errno.h"
#include "bsl_log.h"
#define CERTS_PATH "../../../testcode/testdata/tls/certificate/der/sm2_with_userid/"
#define HTTP_BUF_MAXLEN (18 * 1024) /* 18KB */
static int32_t HiTLSInit()
{
// Registration certificate, crypto callback
int32_t ret = CRYPT_EAL_Init(CRYPT_EAL_INIT_ALL);
if (ret != CRYPT_SUCCESS) {
printf("CRYPT_EAL_Init: error code is %x\n", ret);
return -1;
}
HITLS_CertMethodInit();
HITLS_CryptMethodInit();
return 0;
}
int main(int32_t argc, char *argv[])
{
int32_t exitValue = -1;
int32_t ret = 0;
int32_t port = 12345;
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
BSL_UIO *uio = NULL;
int fd = 0;
HITLS_X509_Cert *rootCA = NULL;
HITLS_X509_Cert *subCA = NULL;
if (HiTLSInit() != 0) {
goto EXIT;
}
fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd == -1) {
printf("Create socket failed.\n");
goto EXIT;
}
int option = 1;
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option)) < 0) {
close(fd);
printf("setsockopt SO_REUSEADDR failed.\n");
goto EXIT;
}
// Set the protocol and port number
struct sockaddr_in serverAddr;
(void)memset_s(&serverAddr, sizeof(serverAddr), 0, sizeof(serverAddr));
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(port);
serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
if (connect(fd, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) != 0) {
printf("connect failed.\n");
goto EXIT;
}
config = HITLS_CFG_NewTLCPConfig();
if (config == NULL) {
printf("HITLS_CFG_NewTLS12Config failed.\n");
goto EXIT;
}
ret = HITLS_CFG_SetCheckKeyUsage(config, false); // disable cert keyusage check
if (ret != HITLS_SUCCESS) {
printf("Disable check KeyUsage failed.\n");
goto EXIT;
}
/* Load root certificate and intermediate certificate */
ret = HITLS_X509_CertParseFile(BSL_FORMAT_PEM, CERTS_PATH "ca.crt", &rootCA);
if (ret != HITLS_SUCCESS) {
printf("Parse ca failed.\n");
goto EXIT;
}
ret = HITLS_X509_CertParseFile(BSL_FORMAT_PEM, CERTS_PATH "inter.crt", &subCA);
if (ret != HITLS_SUCCESS) {
printf("Parse subca failed.\n");
goto EXIT;
}
HITLS_CFG_AddCertToStore(config, rootCA, TLS_CERT_STORE_TYPE_DEFAULT, true);
HITLS_CFG_AddCertToStore(config, subCA, TLS_CERT_STORE_TYPE_DEFAULT, true);
// Load signature certificate
HITLS_CERT_X509 *signCert = NULL;
HITLS_CERT_X509 *signPkey = NULL;
signCert = HITLS_CFG_ParseCert(config, (const uint8_t *)(CERTS_PATH "sign.crt"),
strlen(CERTS_PATH "sign.crt"), TLS_PARSE_TYPE_FILE, TLS_PARSE_FORMAT_PEM);
if (signCert == NULL) {
printf("Parse signCert failed.\n");
goto EXIT;
}
signPkey = HITLS_CFG_ParseKey(config, (const uint8_t *)(CERTS_PATH "sign.key"),
strlen(CERTS_PATH "sign.key"), TLS_PARSE_TYPE_FILE, TLS_PARSE_FORMAT_PEM);
if (signPkey == NULL) {
printf("Parse signPkey failed.\n");
goto EXIT;
}
HITLS_CFG_SetTlcpCertificate(config, signCert, TLS_PARSE_FORMAT_ASN1, false);
HITLS_CFG_SetTlcpPrivateKey(config, signPkey, TLS_PARSE_FORMAT_ASN1, false);
// Load encryption certificate
HITLS_CERT_X509 *encCert = NULL;
HITLS_CERT_X509 *encPkey = NULL;
encCert = HITLS_CFG_ParseCert(config, (const uint8_t *)(CERTS_PATH "enc.crt"),
strlen(CERTS_PATH "enc.crt"), TLS_PARSE_TYPE_FILE, TLS_PARSE_FORMAT_PEM);
if (encCert == NULL) {
printf("Parse encCert failed.\n");
goto EXIT;
}
encPkey = HITLS_CFG_ParseKey(config, (const uint8_t *)(CERTS_PATH "enc.key"),
strlen(CERTS_PATH "enc.key"), TLS_PARSE_TYPE_FILE, TLS_PARSE_FORMAT_PEM);
if (encPkey == NULL) {
printf("Parse encPkey failed.\n");
goto EXIT;
}
HITLS_CFG_SetTlcpCertificate(config, encCert, TLS_PARSE_FORMAT_ASN1, true);
HITLS_CFG_SetTlcpPrivateKey(config, encPkey, TLS_PARSE_FORMAT_ASN1, true);
/* Create a new openHiTLS ctx */
ctx = HITLS_New(config);
if (ctx == NULL) {
printf("HITLS_New failed.\n");
goto EXIT;
}
uio = BSL_UIO_New(BSL_UIO_TcpMethod());
if (uio == NULL) {
printf("BSL_UIO_New failed.\n");
goto EXIT;
}
ret = BSL_UIO_Ctrl(uio, BSL_UIO_SET_FD, (int32_t)sizeof(fd), &fd);
if (ret != HITLS_SUCCESS) {
BSL_UIO_Free(uio);
printf("BSL_UIO_SET_FD failed, fd = %u.\n", fd);
goto EXIT;
}
ret = HITLS_SetUio(ctx, uio);
if (ret != HITLS_SUCCESS) {
BSL_UIO_Free(uio);
printf("HITLS_SetUio failed. ret = 0x%x.\n", ret);
goto EXIT;
}
/* To establish a TLS connection, users need to consider the return value based on the actual scenario */
ret = HITLS_Connect(ctx);
if (ret != HITLS_SUCCESS) {
printf("HITLS_Connect failed, ret = 0x%x.\n", ret);
goto EXIT;
}
/* Sending messages to the other end, users need to consider the return value according to the actual scenario */
const uint8_t sndBuf[] = "Hi, this is tlcp client\n";
uint32_t writeLen = 0;
ret = HITLS_Write(ctx, sndBuf, sizeof(sndBuf), &writeLen);
if (ret != HITLS_SUCCESS) {
printf("HITLS_Write error:error code:%d\n", ret);
goto EXIT;
}
/* Read the message from the other end, and the user needs to consider the return value according to the actual
scenario */
uint8_t readBuf[HTTP_BUF_MAXLEN + 1] = {0};
uint32_t readLen = 0;
ret = HITLS_Read(ctx, readBuf, HTTP_BUF_MAXLEN, &readLen);
if (ret != HITLS_SUCCESS) {
printf("HITLS_Read failed, ret = 0x%x.\n", ret);
goto EXIT;
}
printf("get from server size:%u :%s\n", readLen, readBuf);
exitValue = 0;
EXIT:
HITLS_Close(ctx);
HITLS_Free(ctx);
HITLS_CFG_FreeConfig(config);
close(fd);
HITLS_X509_CertFree(rootCA);
HITLS_X509_CertFree(subCA);
BSL_UIO_Free(uio);
return exitValue;
} | 2401_83913325/openHiTLS_1 | testcode/demo/tlcp_client.c | C | unknown | 6,570 |
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_err.h"
#include "crypt_algid.h"
#include "crypt_eal_init.h"
#include "crypt_eal_rand.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_codecs.h"
#include "hitls_error.h"
#include "hitls_config.h"
#include "hitls.h"
#include "hitls_cert_init.h"
#include "hitls_cert.h"
#include "hitls_crypt_init.h"
#include "hitls_pki_cert.h"
#include "crypt_errno.h"
#include "bsl_log.h"
#define CERTS_PATH "../../../testcode/testdata/tls/certificate/der/sm2_with_userid/"
#define HTTP_BUF_MAXLEN (18 * 1024) /* 18KB */
static int32_t HiTLSInit()
{
// Registration certificate, crypto callback
int32_t ret = CRYPT_EAL_Init(CRYPT_EAL_INIT_ALL);
if (ret != CRYPT_SUCCESS) {
printf("CRYPT_EAL_Init: error code is %x\n", ret);
return -1;
}
HITLS_CertMethodInit();
HITLS_CryptMethodInit();
return 0;
}
int main(int32_t argc, char *argv[])
{
int32_t exitValue = -1;
int32_t ret = 0;
int32_t port = 12345;
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
BSL_UIO *uio = NULL;
int fd = 0;
int infd = 0;
HITLS_X509_Cert *rootCA = NULL;
HITLS_X509_Cert *subCA = NULL;
HITLS_X509_Cert *serverCert = NULL;
CRYPT_EAL_PkeyCtx *pkey = NULL;
if (HiTLSInit() != 0) {
goto EXIT;
}
fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd == -1) {
printf("Create socket failed.\n");
return -1;
}
int option = 1;
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option)) < 0) {
printf("setsockopt SO_REUSEADDR failed.\n");
goto EXIT;
}
struct sockaddr_in serverAddr;
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(port);
serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(fd, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) != 0) {
printf("bind failed.\n");
goto EXIT;
}
if (listen(fd, 5) != 0) {
printf("listen socket fail\n");
goto EXIT;
}
struct sockaddr_in clientAddr;
unsigned int len = sizeof(struct sockaddr_in);
infd = accept(fd, (struct sockaddr *)&clientAddr, &len);
if (infd < 0) {
printf("accept failed.\n");
goto EXIT;
}
config = HITLS_CFG_NewTLCPConfig();
if (config == NULL) {
printf("HITLS_CFG_NewTLS12Config failed.\n");
goto EXIT;
}
ret = HITLS_CFG_SetClientVerifySupport(config, false); // disable peer verify
if (ret != HITLS_SUCCESS) {
printf("Disable peer verify faild.\n");
goto EXIT;
}
/* Load root certificate and intermediate certificate */
ret = HITLS_X509_CertParseFile(BSL_FORMAT_PEM, CERTS_PATH "ca.crt", &rootCA);
if (ret != HITLS_SUCCESS) {
printf("Parse ca failed.\n");
goto EXIT;
}
ret = HITLS_X509_CertParseFile(BSL_FORMAT_PEM, CERTS_PATH "inter.crt", &subCA);
if (ret != HITLS_SUCCESS) {
printf("Parse subca failed.\n");
goto EXIT;
}
HITLS_CFG_AddCertToStore(config, rootCA, TLS_CERT_STORE_TYPE_DEFAULT, true);
HITLS_CFG_AddCertToStore(config, subCA, TLS_CERT_STORE_TYPE_DEFAULT, true);
// Load signature certificate
HITLS_CERT_X509 *signCert = NULL;
HITLS_CERT_X509 *signPkey = NULL;
signCert = HITLS_CFG_ParseCert(config, (const uint8_t *)(CERTS_PATH "sign.crt"),
strlen(CERTS_PATH "sign.crt"), TLS_PARSE_TYPE_FILE, TLS_PARSE_FORMAT_PEM);
if (signCert == NULL) {
printf("Parse signCert failed.\n");
goto EXIT;
}
signPkey = HITLS_CFG_ParseKey(config, (const uint8_t *)(CERTS_PATH "sign.key"),
strlen(CERTS_PATH "sign.key"), TLS_PARSE_TYPE_FILE, TLS_PARSE_FORMAT_PEM);
if (signPkey == NULL) {
printf("Parse signPkey failed.\n");
goto EXIT;
}
HITLS_CFG_SetTlcpCertificate(config, signCert, TLS_PARSE_FORMAT_ASN1, false);
HITLS_CFG_SetTlcpPrivateKey(config, signPkey, TLS_PARSE_FORMAT_ASN1, false);
// Load encryption certificate
HITLS_CERT_X509 *encCert = NULL;
HITLS_CERT_X509 *encPkey = NULL;
encCert = HITLS_CFG_ParseCert(config, (const uint8_t *)(CERTS_PATH "enc.crt"),
strlen(CERTS_PATH "enc.crt"), TLS_PARSE_TYPE_FILE, TLS_PARSE_FORMAT_PEM);
if (encCert == NULL) {
printf("Parse encCert failed.\n");
goto EXIT;
}
encPkey = HITLS_CFG_ParseKey(config, (const uint8_t *)(CERTS_PATH "enc.key"),
strlen(CERTS_PATH "enc.key"), TLS_PARSE_TYPE_FILE, TLS_PARSE_FORMAT_PEM);
if (encPkey == NULL) {
printf("Parse encPkey failed.\n");
goto EXIT;
}
HITLS_CFG_SetTlcpCertificate(config, encCert, TLS_PARSE_FORMAT_ASN1, true);
HITLS_CFG_SetTlcpPrivateKey(config, encPkey, TLS_PARSE_FORMAT_ASN1, true);
/* Create a new openHiTLS ctx */
ctx = HITLS_New(config);
if (ctx == NULL) {
printf("HITLS_New failed.\n");
goto EXIT;
}
/* Users can implement methods as needed */
uio = BSL_UIO_New(BSL_UIO_TcpMethod());
if (uio == NULL) {
printf("BSL_UIO_New failed.\n");
goto EXIT;
}
ret = BSL_UIO_Ctrl(uio, BSL_UIO_SET_FD, (int32_t)sizeof(fd), &infd);
if (ret != HITLS_SUCCESS) {
BSL_UIO_Free(uio);
printf("BSL_UIO_SET_FD failed, fd = %u.\n", fd);
goto EXIT;
}
ret = HITLS_SetUio(ctx, uio);
if (ret != HITLS_SUCCESS) {
BSL_UIO_Free(uio);
printf("HITLS_SetUio failed. ret = 0x%x.\n", ret);
goto EXIT;
}
/* To establish a TLS connection, users need to consider the return value based on the actual scenario */
ret = HITLS_Accept(ctx);
if (ret != HITLS_SUCCESS) {
printf("HITLS_Accept failed, ret = 0x%x.\n", ret);
goto EXIT;
}
/* Sending messages to the other end, users need to consider the return value according to the actual scenario */
uint8_t readBuf[HTTP_BUF_MAXLEN + 1] = {0};
uint32_t readLen = 0;
ret = HITLS_Read(ctx, readBuf, HTTP_BUF_MAXLEN, &readLen);
if (ret != HITLS_SUCCESS) {
printf("HITLS_Read failed, ret = 0x%x.\n", ret);
goto EXIT;
}
printf("get from client size:%u :%s\n", readLen, readBuf);
/* Read the message from the other end, and the user needs to consider the return value according to the actual
scenario */
const uint8_t sndBuf[] = "Hi, this is tlcp server\n";
uint32_t writeLen = 0;
ret = HITLS_Write(ctx, sndBuf, sizeof(sndBuf), &writeLen);
if (ret != HITLS_SUCCESS) {
printf("HITLS_Write error:error code:%d\n", ret);
goto EXIT;
}
exitValue = 0;
EXIT:
HITLS_Close(ctx);
HITLS_Free(ctx);
HITLS_CFG_FreeConfig(config);
close(fd);
close(infd);
HITLS_X509_CertFree(rootCA);
HITLS_X509_CertFree(subCA);
HITLS_X509_CertFree(serverCert);
CRYPT_EAL_PkeyFreeCtx(pkey);
BSL_UIO_Free(uio);
return exitValue;
} | 2401_83913325/openHiTLS_1 | testcode/demo/tlcp_server.c | C | unknown | 7,027 |
/*
* 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 <stdbool.h>
#include "helper.h"
#include "crypt_algid.h"
#include "hitls_build.h"
#include "crypto_test_util.h"
#define ERR_ID (-1)
typedef struct {
int id;
int offset;
} MdAlgMap;
static MdAlgMap g_mdAlgMap[] = {
{ CRYPT_MD_MD5, 0 },
{ CRYPT_MD_SHA1, 1 },
{ CRYPT_MD_SHA224, 2 },
{ CRYPT_MD_SHA256, 3 },
{ CRYPT_MD_SHA384, 4 },
{ CRYPT_MD_SHA512, 5 },
{ CRYPT_MD_SHA3_224, 6 },
{ CRYPT_MD_SHA3_256, 7 },
{ CRYPT_MD_SHA3_384, 8 },
{ CRYPT_MD_SHA3_512, 9 },
{ CRYPT_MD_SHAKE128, 10 },
{ CRYPT_MD_SHAKE256, 11 },
{ CRYPT_MD_SM3, 12 },
};
#define MD_ALG_MAP_CNT ((int)(sizeof(g_mdAlgMap) / sizeof(MdAlgMap)))
// All MD algorithms are available by default.
static int g_mdDisableTable[MD_ALG_MAP_CNT] = { 0 };
static bool g_isInitMd = false;
static int g_avlRandAlg = -1;
static bool g_isInitRandAlg = false;
static void InitMdTable(void)
{
if (g_isInitMd) {
return;
}
#ifndef HITLS_CRYPTO_MD5
g_mdDisableTable[0] = 1;
#endif
#ifndef HITLS_CRYPTO_SHA1
g_mdDisableTable[1] = 1;
#endif
#ifndef HITLS_CRYPTO_SHA224
g_mdDisableTable[2] = 1;
#endif
#ifndef HITLS_CRYPTO_SHA256
g_mdDisableTable[3] = 1;
#endif
#ifndef HITLS_CRYPTO_SHA384
g_mdDisableTable[4] = 1;
#endif
#ifndef HITLS_CRYPTO_SHA512
g_mdDisableTable[5] = 1;
#endif
#ifndef HITLS_CRYPTO_SHA3
g_mdDisableTable[6] = 1;
g_mdDisableTable[7] = 1;
g_mdDisableTable[8] = 1;
g_mdDisableTable[9] = 1;
g_mdDisableTable[10] = 1;
g_mdDisableTable[11] = 1;
#endif
#ifndef HITLS_CRYPTO_SM3
g_mdDisableTable[12] = 1;
#endif
g_isInitMd = true;
}
static bool IsDrbgHashDisabled(void)
{
#ifdef HITLS_CRYPTO_DRBG_HASH
return false;
#else
return true;
#endif
}
static bool IsDrbgHmacDisabled(void)
{
#ifdef HITLS_CRYPTO_DRBG_HMAC
return false;
#else
return true;
#endif
}
static bool IsDrbgCtrDisabled(void)
{
#ifdef HITLS_CRYPTO_DRBG_CTR
return false;
#else
return true;
#endif
}
static bool IsDrbgCtrSm4Disabled()
{
#if defined(HITLS_CRYPTO_DRBG_CTR) && defined(HITLS_CRYPTO_DRBG_GM) && defined(HITLS_CRYPTO_SM4)
return false;
#else
return true;
#endif
}
static int GetDrbgHashAlgId(void)
{
InitMdTable();
// CRYPT_RAND_SHA256 is preferred (224 depends on 256).
if (g_mdDisableTable[3] == 0) {
return CRYPT_RAND_SHA256;
}
if (g_mdDisableTable[5] == 0) {
return CRYPT_RAND_SHA512;
}
if (g_mdDisableTable[1] == 0) {
return CRYPT_RAND_SHA1;
}
if (g_mdDisableTable[12] == 0) {
return CRYPT_RAND_SM3;
}
return ERR_ID;
}
static int GetDrbgHmacAlgId(void)
{
InitMdTable();
if (g_mdDisableTable[3] == 0) {
return CRYPT_RAND_HMAC_SHA256;
}
if (g_mdDisableTable[5] == 0) {
return CRYPT_RAND_HMAC_SHA512;
}
if (g_mdDisableTable[1] == 0) {
return CRYPT_RAND_HMAC_SHA1;
}
return ERR_ID;
}
bool IsMdAlgDisabled(int id)
{
InitMdTable();
bool res = false; // By default, this algorithm is not disabled.
for (int i = 0; i < MD_ALG_MAP_CNT; i++) {
if (id == g_mdAlgMap[i].id) {
res = g_mdDisableTable[g_mdAlgMap[i].offset] == 1;
break;
}
}
return res;
}
bool IsHmacAlgDisabled(int id)
{
#ifdef HITLS_CRYPTO_HMAC
InitMdTable();
switch (id) {
case CRYPT_MAC_HMAC_MD5:
return g_mdDisableTable[0] == 1;
case CRYPT_MAC_HMAC_SHA1:
return g_mdDisableTable[1] == 1;
case CRYPT_MAC_HMAC_SHA224:
return g_mdDisableTable[2] == 1;
case CRYPT_MAC_HMAC_SHA256:
return g_mdDisableTable[3] == 1;
case CRYPT_MAC_HMAC_SHA384:
return g_mdDisableTable[4] == 1;
case CRYPT_MAC_HMAC_SHA512:
return g_mdDisableTable[5] == 1;
case CRYPT_MAC_HMAC_SHA3_224:
return g_mdDisableTable[6] == 1;
case CRYPT_MAC_HMAC_SHA3_256:
return g_mdDisableTable[7] == 1;
case CRYPT_MAC_HMAC_SHA3_384:
return g_mdDisableTable[8] == 1;
case CRYPT_MAC_HMAC_SHA3_512:
return g_mdDisableTable[9] == 1;
case CRYPT_MAC_HMAC_SM3:
return g_mdDisableTable[12] == 1;
default:
return false;
}
#else
(void)id;
return false;
#endif
}
bool IsMacAlgDisabled(int id)
{
switch (id) {
case CRYPT_MAC_HMAC_MD5:
case CRYPT_MAC_HMAC_SHA1:
case CRYPT_MAC_HMAC_SHA224:
case CRYPT_MAC_HMAC_SHA256:
case CRYPT_MAC_HMAC_SHA384:
case CRYPT_MAC_HMAC_SHA512:
case CRYPT_MAC_HMAC_SM3:
return IsHmacAlgDisabled(id);
case CRYPT_MAC_CBC_MAC_SM4:
#ifdef HITLS_CRYPTO_CBC_MAC
return false;
#else
return true;
#endif
default:
return false;
}
}
bool IsDrbgHashAlgDisabled(int id)
{
if (IsDrbgHashDisabled()) {
return true;
}
InitMdTable();
switch (id) {
case CRYPT_RAND_SHA1:
return g_mdDisableTable[1] == 1;
case CRYPT_RAND_SHA224:
return g_mdDisableTable[2] == 1;
case CRYPT_RAND_SHA256:
return g_mdDisableTable[3] == 1;
case CRYPT_RAND_SHA384:
return g_mdDisableTable[4] == 1;
case CRYPT_RAND_SHA512:
return g_mdDisableTable[5] == 1;
case CRYPT_RAND_SM3:
#ifdef HITLS_CRYPTO_DRBG_GM
return g_mdDisableTable[12] == 1;
#else
return true;
#endif
default:
return false;
}
}
bool IsDrbgHmacAlgDisabled(int id)
{
if (IsDrbgHmacDisabled()) {
return true;
}
InitMdTable();
switch (id) {
case CRYPT_RAND_HMAC_SHA1:
return g_mdDisableTable[1] == 1;
case CRYPT_RAND_HMAC_SHA224:
return g_mdDisableTable[2] == 1;
case CRYPT_RAND_HMAC_SHA256:
return g_mdDisableTable[3] == 1;
case CRYPT_RAND_HMAC_SHA384:
return g_mdDisableTable[4] == 1;
case CRYPT_RAND_HMAC_SHA512:
return g_mdDisableTable[5] == 1;
default:
return false;
}
}
int GetAvailableRandAlgId(void)
{
if (g_isInitRandAlg) {
return g_avlRandAlg;
}
g_isInitRandAlg = true;
if (!IsDrbgHashDisabled()) {
g_avlRandAlg = GetDrbgHashAlgId();
if (g_avlRandAlg != ERR_ID) {
return g_avlRandAlg;
}
}
if (!IsDrbgHmacDisabled()) {
g_avlRandAlg = GetDrbgHmacAlgId();
if (g_avlRandAlg != ERR_ID) {
return g_avlRandAlg;
}
}
if (!IsDrbgCtrDisabled()) {
g_avlRandAlg = CRYPT_RAND_AES256_CTR;
return g_avlRandAlg;
}
return g_avlRandAlg;
}
bool IsRandAlgDisabled(int id)
{
switch (id) {
case CRYPT_RAND_SHA1:
case CRYPT_RAND_SHA224:
case CRYPT_RAND_SHA256:
case CRYPT_RAND_SHA384:
case CRYPT_RAND_SHA512:
case CRYPT_RAND_SM3:
return IsDrbgHashAlgDisabled(id);
case CRYPT_RAND_HMAC_SHA1:
case CRYPT_RAND_HMAC_SHA224:
case CRYPT_RAND_HMAC_SHA256:
case CRYPT_RAND_HMAC_SHA384:
case CRYPT_RAND_HMAC_SHA512:
return IsDrbgHmacAlgDisabled(id);
case CRYPT_RAND_AES128_CTR:
case CRYPT_RAND_AES192_CTR:
case CRYPT_RAND_AES256_CTR:
case CRYPT_RAND_AES128_CTR_DF:
case CRYPT_RAND_AES192_CTR_DF:
case CRYPT_RAND_AES256_CTR_DF:
return IsDrbgCtrDisabled();
case CRYPT_RAND_SM4_CTR_DF:
return IsDrbgCtrSm4Disabled();
default:
return false;
}
return false;
}
bool IsAesAlgDisabled(int id)
{
#ifdef HITLS_CRYPTO_AES
switch (id) {
#ifndef HITLS_CRYPTO_CBC
case CRYPT_CIPHER_AES128_CBC:
case CRYPT_CIPHER_AES192_CBC:
case CRYPT_CIPHER_AES256_CBC:
return true;
#endif
#ifndef HITLS_CRYPTO_ECB
case CRYPT_CIPHER_AES128_ECB:
case CRYPT_CIPHER_AES192_ECB:
case CRYPT_CIPHER_AES256_ECB:
return true;
#endif
#ifndef HITLS_CRYPTO_CTR
case CRYPT_CIPHER_AES128_CTR:
case CRYPT_CIPHER_AES192_CTR:
case CRYPT_CIPHER_AES256_CTR:
return true;
#endif
#ifndef HITLS_CRYPTO_CCM
case CRYPT_CIPHER_AES128_CCM:
case CRYPT_CIPHER_AES192_CCM:
case CRYPT_CIPHER_AES256_CCM:
return true;
#endif
#ifndef HITLS_CRYPTO_GCM
case CRYPT_CIPHER_AES128_GCM:
case CRYPT_CIPHER_AES192_GCM:
case CRYPT_CIPHER_AES256_GCM:
return true;
#endif
#ifndef HITLS_CRYPTO_CFB
case CRYPT_CIPHER_AES128_CFB:
case CRYPT_CIPHER_AES192_CFB:
case CRYPT_CIPHER_AES256_CFB:
return true;
#endif
#ifndef HITLS_CRYPTO_OFB
case CRYPT_CIPHER_AES128_OFB:
case CRYPT_CIPHER_AES192_OFB:
case CRYPT_CIPHER_AES256_OFB:
return true;
#endif
#ifndef HITLS_CRYPTO_XTS
case CRYPT_CIPHER_AES128_XTS:
case CRYPT_CIPHER_AES256_XTS:
return true;
#endif
default:
return false; // Unsupported algorithm ID
}
#else
(void)id;
return true;
#endif
}
bool IsSm4AlgDisabled(int id)
{
#ifdef HITLS_CRYPTO_SM4
switch (id) {
#ifndef HITLS_CRYPTO_XTS
case CRYPT_CIPHER_SM4_XTS:
return true;
#endif
#ifndef HITLS_CRYPTO_CBC
case CRYPT_CIPHER_SM4_CBC:
return true;
#endif
#ifndef HITLS_CRYPTO_ECB
case CRYPT_CIPHER_SM4_ECB:
return true;
#endif
#ifndef HITLS_CRYPTO_CTR
case CRYPT_CIPHER_SM4_CTR:
return true;
#endif
#ifndef HITLS_CRYPTO_GCM
case CRYPT_CIPHER_SM4_GCM:
return true;
#endif
#ifndef HITLS_CRYPTO_CFB
case CRYPT_CIPHER_SM4_CFB:
return true;
#endif
#ifndef HITLS_CRYPTO_OFB
case CRYPT_CIPHER_SM4_OFB:
return true;
#endif
#ifndef HITLS_CRYPTO_HCTR
case CRYPT_CIPHER_SM4_HCTR:
return true;
#endif
default:
return false; // Unsupported algorithm ID
}
#else
(void)id;
return true;
#endif
}
bool IsCipherAlgDisabled(int id)
{
switch (id) {
case CRYPT_CIPHER_AES128_CBC:
case CRYPT_CIPHER_AES192_CBC:
case CRYPT_CIPHER_AES256_CBC:
case CRYPT_CIPHER_AES128_CTR:
case CRYPT_CIPHER_AES192_CTR:
case CRYPT_CIPHER_AES256_CTR:
case CRYPT_CIPHER_AES128_CCM:
case CRYPT_CIPHER_AES192_CCM:
case CRYPT_CIPHER_AES256_CCM:
case CRYPT_CIPHER_AES128_GCM:
case CRYPT_CIPHER_AES192_GCM:
case CRYPT_CIPHER_AES256_GCM:
case CRYPT_CIPHER_AES128_CFB:
case CRYPT_CIPHER_AES192_CFB:
case CRYPT_CIPHER_AES256_CFB:
case CRYPT_CIPHER_AES128_OFB:
case CRYPT_CIPHER_AES192_OFB:
case CRYPT_CIPHER_AES256_OFB:
return IsAesAlgDisabled(id);
case CRYPT_CIPHER_CHACHA20_POLY1305:
#if !defined(HITLS_CRYPTO_CHACHA20) && !defined(HITLS_CRYPTO_CHACHA20POLY1305)
return true;
#else
return false;
#endif
case CRYPT_CIPHER_SM4_XTS:
case CRYPT_CIPHER_SM4_CBC:
case CRYPT_CIPHER_SM4_CTR:
case CRYPT_CIPHER_SM4_GCM:
case CRYPT_CIPHER_SM4_CFB:
case CRYPT_CIPHER_SM4_OFB:
case CRYPT_CIPHER_SM4_HCTR:
return IsSm4AlgDisabled(id);
default:
return false;
}
}
bool IsCmacAlgDisabled(int id)
{
#ifdef HITLS_CRYPTO_CMAC
switch (id) {
#ifndef HITLS_CRYPTO_CMAC_AES
case CRYPT_MAC_CMAC_AES128:
case CRYPT_MAC_CMAC_AES192:
case CRYPT_MAC_CMAC_AES256:
return true;
#endif
#ifndef HITLS_CRYPTO_CMAC_SM4
case CRYPT_MAC_CMAC_SM4:
return true;
#endif
default:
return false; // Unsupported algorithm ID
}
#else
(void)id;
return true;
#endif
}
bool IsCurveDisabled(int eccId)
{
switch (eccId) {
#ifdef HITLS_CRYPTO_CURVE_NISTP224
case CRYPT_ECC_NISTP224:
return false;
#endif
#ifdef HITLS_CRYPTO_CURVE_NISTP256
case CRYPT_ECC_NISTP256:
return false;
#endif
#ifdef HITLS_CRYPTO_CURVE_NISTP384
case CRYPT_ECC_NISTP384:
return false;
#endif
#ifdef HITLS_CRYPTO_CURVE_NISTP521
case CRYPT_ECC_NISTP521:
return false;
#endif
#ifdef HITLS_CRYPTO_CURVE_BP256R1
case CRYPT_ECC_BRAINPOOLP256R1:
return false;
#endif
#ifdef HITLS_CRYPTO_CURVE_BP384R1
case CRYPT_ECC_BRAINPOOLP384R1:
return false;
#endif
#ifdef HITLS_CRYPTO_CURVE_BP512R1
case CRYPT_ECC_BRAINPOOLP512R1:
return false;
#endif
#ifdef HITLS_CRYPTO_CURVE_192WAPI
case CRYPT_ECC_192WAPI:
return false;
#endif
default:
return true;
}
}
bool IsCurve25519AlgDisabled(int id)
{
if (id == CRYPT_PKEY_ED25519) {
#ifndef HITLS_CRYPTO_ED25519
return true;
#else
return false;
#endif
}
if (id == CRYPT_PKEY_X25519) {
#ifndef HITLS_CRYPTO_X25519
return true;
#else
return false;
#endif
}
return false; // Unsupported algorithm ID
} | 2401_83913325/openHiTLS_1 | testcode/framework/crypto/alg_check.c | C | unknown | 13,734 |
/*
* 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 <pthread.h>
#include <unistd.h>
#include <fcntl.h>
#include "hitls_build.h"
#include "bsl_sal.h"
#include "bsl_errno.h"
#include "crypt_errno.h"
#include "crypt_types.h"
#include "crypt_eal_md.h"
#include "eal_md_local.h"
#include "crypt_eal_rand.h"
#include "crypt_eal_mac.h"
#include "crypt_eal_init.h"
#include "test.h"
#include "helper.h"
#include "crypto_test_util.h"
#include "securec.h"
#include "crypt_util_rand.h"
#ifndef HITLS_BSL_SAL_MEM
void *TestMalloc(uint32_t len)
{
return malloc((size_t)len);
}
#endif
void TestMemInit(void)
{
#ifdef HITLS_BSL_SAL_MEM
return;
#else
BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_MALLOC, TestMalloc);
BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_FREE, free);
#endif
}
#if defined(HITLS_CRYPTO_EAL) && defined(HITLS_CRYPTO_DRBG)
typedef struct {
CRYPT_Data *entropy;
CRYPT_Data *nonce;
CRYPT_Data *pers;
CRYPT_Data *addin1;
CRYPT_Data *entropyPR1;
CRYPT_Data *addin2;
CRYPT_Data *entropyPR2;
CRYPT_Data *retBits;
} DRBG_Vec_t;
#ifndef HITLS_CRYPTO_ENTROPY
static int32_t GetEntropy(void *ctx, CRYPT_Data *entropy, uint32_t strength, CRYPT_Range *lenRange)
{
if (lenRange == NULL) {
Print("getEntropy Error lenRange NULL\n");
return CRYPT_NULL_INPUT;
}
if (ctx == NULL || entropy == NULL) {
Print("getEntropy Error\n");
lenRange->max = strength;
return CRYPT_NULL_INPUT;
}
DRBG_Vec_t *seedCtx = (DRBG_Vec_t *)ctx;
entropy->data = seedCtx->entropy->data;
entropy->len = seedCtx->entropy->len;
return CRYPT_SUCCESS;
}
static void CleanEntropy(void *ctx, CRYPT_Data *entropy)
{
(void)ctx;
(void)entropy;
return;
}
#endif
int32_t TestSimpleRand(uint8_t *buff, uint32_t len)
{
int rand = open("/dev/urandom", O_RDONLY);
if (rand < 0) {
printf("open /dev/urandom failed.\n");
return -1;
}
int l = read(rand, buff, len);
if (l < 0) {
printf("read from /dev/urandom failed. errno: %d.\n", errno);
close(rand);
return -1;
}
close(rand);
return 0;
}
int32_t TestSimpleRandEx(void *libCtx, uint8_t *buff, uint32_t len)
{
(void)libCtx;
return TestSimpleRand(buff, len);
}
int TestRandInitEx(void *libCtx)
{
(void)libCtx;
int drbgAlgId = GetAvailableRandAlgId();
int32_t ret;
if (drbgAlgId == -1) {
Print("Drbg algs are disabled.");
return CRYPT_NOT_SUPPORT;
}
#ifndef HITLS_CRYPTO_ENTROPY
CRYPT_RandSeedMethod seedMeth = {GetEntropy, CleanEntropy, NULL, NULL};
uint8_t entropy[64] = {0};
CRYPT_Data tempEntropy = {entropy, sizeof(entropy)};
DRBG_Vec_t seedCtx = {0};
seedCtx.entropy = &tempEntropy;
#endif
#ifdef HITLS_CRYPTO_PROVIDER
#ifndef HITLS_CRYPTO_ENTROPY
BSL_Param param[4] = {0};
(void)BSL_PARAM_InitValue(¶m[0], CRYPT_PARAM_RAND_SEEDCTX, BSL_PARAM_TYPE_CTX_PTR, &seedCtx, 0);
(void)BSL_PARAM_InitValue(¶m[1], CRYPT_PARAM_RAND_SEED_GETENTROPY, BSL_PARAM_TYPE_FUNC_PTR,
seedMeth.getEntropy, 0);
(void)BSL_PARAM_InitValue(¶m[2], CRYPT_PARAM_RAND_SEED_CLEANENTROPY, BSL_PARAM_TYPE_FUNC_PTR,
seedMeth.cleanEntropy, 0);
ret = CRYPT_EAL_ProviderRandInitCtx(NULL, (CRYPT_RAND_AlgId)drbgAlgId, "provider=default", NULL, 0, param);
#else
ret = CRYPT_EAL_ProviderRandInitCtx(libCtx, (CRYPT_RAND_AlgId)drbgAlgId, "provider=default", NULL, 0, NULL);
#endif
#else
#ifndef HITLS_CRYPTO_ENTROPY
ret = CRYPT_EAL_RandInit(drbgAlgId, &seedMeth, (void *)&seedCtx, NULL, 0);
#else
ret = CRYPT_EAL_RandInit(drbgAlgId, NULL, NULL, NULL, 0);
#endif
#endif
if (ret == CRYPT_EAL_ERR_DRBG_REPEAT_INIT) {
ret = CRYPT_SUCCESS;
}
return ret;
}
int TestRandInit(void)
{
int32_t ret = TestRandInitEx(NULL);
if (ret != CRYPT_SUCCESS) {
return ret;
}
CRYPT_RandRegist(TestSimpleRand);
#ifdef HITLS_CRYPTO_PROVIDER
CRYPT_RandRegistEx(TestSimpleRandEx);
#endif
return CRYPT_SUCCESS;
}
void TestRandDeInit(void)
{
CRYPT_RandRegist(NULL);
#ifdef HITLS_CRYPTO_PROVIDER
CRYPT_RandRegistEx(NULL);
#endif
#ifdef HITLS_CRYPTO_PROVIDER
CRYPT_EAL_RandDeinitEx(NULL);
#else
CRYPT_EAL_RandDeinit();
#endif
}
#endif
#if defined(HITLS_CRYPTO_EAL) && defined(HITLS_CRYPTO_MAC)
uint32_t TestGetMacLen(int algId)
{
switch (algId) {
case CRYPT_MAC_HMAC_MD5:
return 16;
case CRYPT_MAC_HMAC_SHA1:
return 20;
case CRYPT_MAC_HMAC_SHA224:
case CRYPT_MAC_HMAC_SHA3_224:
return 28;
case CRYPT_MAC_HMAC_SHA256:
case CRYPT_MAC_HMAC_SHA3_256:
return 32;
case CRYPT_MAC_HMAC_SHA384:
case CRYPT_MAC_HMAC_SHA3_384:
return 48;
case CRYPT_MAC_HMAC_SHA512:
case CRYPT_MAC_HMAC_SHA3_512:
return 64;
case CRYPT_MAC_HMAC_SM3:
return 32;
case CRYPT_MAC_CMAC_AES128:
case CRYPT_MAC_CMAC_AES192:
case CRYPT_MAC_CMAC_AES256:
return 16; // AES block size
case CRYPT_MAC_CMAC_SM4:
return 16;// SM4 block size
case CRYPT_MAC_CBC_MAC_SM4:
return 16;// SM4 block size
case CRYPT_MAC_SIPHASH64:
return 8;
case CRYPT_MAC_SIPHASH128:
return 16;
default:
return 0;
}
}
void TestMacSameAddr(int algId, Hex *key, Hex *data, Hex *mac)
{
uint32_t outLen = data->len > mac->len ? data->len : mac->len;
uint8_t out[outLen];
CRYPT_EAL_MacCtx *ctx = NULL;
int padType = CRYPT_PADDING_ZEROS;
ASSERT_EQ(memcpy_s(out, outLen, data->x, data->len), 0);
TestMemInit();
ASSERT_TRUE((ctx = CRYPT_EAL_MacNewCtx(algId)) != NULL);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, key->x, key->len), CRYPT_SUCCESS);
if (algId == CRYPT_MAC_CBC_MAC_SM4) {
ASSERT_EQ(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_CBC_MAC_PADDING, &padType, sizeof(int)), CRYPT_SUCCESS);
}
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, out, data->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, out, &outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("mac result cmp", out, outLen, mac->x, mac->len);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
void TestMacAddrNotAlign(int algId, Hex *key, Hex *data, Hex *mac)
{
uint32_t outLen = data->len > mac->len ? data->len : mac->len;
uint8_t out[outLen];
CRYPT_EAL_MacCtx *ctx = NULL;
int padType = CRYPT_PADDING_ZEROS;
uint8_t keyTmp[key->len + 1] __attribute__((aligned(8)));
uint8_t dataTmp[data->len + 1] __attribute__((aligned(8)));
uint8_t *pKey = keyTmp + 1;
uint8_t *pData = dataTmp + 1;
ASSERT_TRUE(memcpy_s(pKey, key->len, key->x, key->len) == EOK);
ASSERT_TRUE(memcpy_s(pData, data->len, data->x, data->len) == EOK);
TestMemInit();
ASSERT_TRUE((ctx = CRYPT_EAL_MacNewCtx(algId)) != NULL);
ASSERT_EQ(CRYPT_EAL_MacInit(ctx, pKey, key->len), CRYPT_SUCCESS);
if (algId == CRYPT_MAC_CBC_MAC_SM4) {
ASSERT_EQ(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_CBC_MAC_PADDING, &padType, sizeof(int)), CRYPT_SUCCESS);
}
ASSERT_EQ(CRYPT_EAL_MacUpdate(ctx, pData, data->len), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_MacFinal(ctx, out, &outLen), CRYPT_SUCCESS);
ASSERT_COMPARE("mac result cmp", out, outLen, mac->x, mac->len);
EXIT:
CRYPT_EAL_MacFreeCtx(ctx);
}
#endif
#ifdef HITLS_CRYPTO_CIPHER
CRYPT_EAL_CipherCtx *TestCipherNewCtx(CRYPT_EAL_LibCtx *libCtx, int32_t id, const char *attrName, int isProvider)
{
#ifdef HITLS_CRYPTO_PROVIDER
if (isProvider == 1) {
if (CRYPT_EAL_Init(0) != CRYPT_SUCCESS) {
return NULL;
}
return CRYPT_EAL_ProviderCipherNewCtx(libCtx, id, attrName);
} else {
return CRYPT_EAL_CipherNewCtx(id);
}
#else
(void)libCtx;
(void)attrName;
(void)isProvider;
return CRYPT_EAL_CipherNewCtx(id);
#endif
}
#endif
#ifdef HITLS_CRYPTO_PKEY
CRYPT_EAL_PkeyCtx *TestPkeyNewCtx(
CRYPT_EAL_LibCtx *libCtx, int32_t id, uint32_t operType, const char *attrName, int isProvider)
{
#ifdef HITLS_CRYPTO_PROVIDER
if (isProvider == 1) {
#ifdef HITLS_CRYPTO_EALINIT
if (CRYPT_EAL_Init(0) != CRYPT_SUCCESS) {
return NULL;
}
#endif
return CRYPT_EAL_ProviderPkeyNewCtx(libCtx, id, operType, attrName);
} else {
return CRYPT_EAL_PkeyNewCtx(id);
}
#else
(void)libCtx;
(void)operType;
(void)attrName;
(void)isProvider;
return CRYPT_EAL_PkeyNewCtx(id);
#endif
}
#endif
| 2401_83913325/openHiTLS_1 | testcode/framework/crypto/crypto_test_util.c | C | unknown | 9,064 |
/*
* 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 CRYPTO_TEST_UTIL_H
#define CRYPTO_TEST_UTIL_H
#include "hitls_build.h"
#include "crypt_eal_cipher.h"
#include "crypt_eal_pkey.h"
#ifdef __cplusplus
extern "C" {
#endif
void TestMemInit(void);
int TestRandInit(void);
int TestRandInitEx(void *libCtx);
void TestRandDeInit(void);
bool IsMdAlgDisabled(int id);
bool IsHmacAlgDisabled(int id);
bool IsMacAlgDisabled(int id);
bool IsDrbgHashAlgDisabled(int id);
bool IsDrbgHmacAlgDisabled(int id);
int GetAvailableRandAlgId(void);
bool IsRandAlgDisabled(int id);
bool IsAesAlgDisabled(int id);
bool IsSm4AlgDisabled(int id);
bool IsCipherAlgDisabled(int id);
bool IsCmacAlgDisabled(int id);
bool IsCurveDisabled(int eccId);
bool IsCurve25519AlgDisabled(int id);
int32_t TestSimpleRand(uint8_t *buff, uint32_t len);
int32_t TestSimpleRandEx(void *libCtx, uint8_t *buff, uint32_t len);
#if defined(HITLS_CRYPTO_EAL) && defined(HITLS_CRYPTO_MAC)
uint32_t TestGetMacLen(int algId);
void TestMacSameAddr(int algId, Hex *key, Hex *data, Hex *mac);
void TestMacAddrNotAlign(int algId, Hex *key, Hex *data, Hex *mac);
#endif
#ifdef HITLS_CRYPTO_CIPHER
CRYPT_EAL_CipherCtx *TestCipherNewCtx(CRYPT_EAL_LibCtx *libCtx, int32_t id, const char *attrName, int isProvider);
#endif
#ifdef HITLS_CRYPTO_PKEY
CRYPT_EAL_PkeyCtx *TestPkeyNewCtx(
CRYPT_EAL_LibCtx *libCtx, int32_t id, uint32_t operType, const char *attrName, int isProvider);
#endif
#ifdef __cplusplus
}
#endif
#endif // CRYPTO_TEST_UTIL_H | 2401_83913325/openHiTLS_1 | testcode/framework/crypto/crypto_test_util.h | C | unknown | 2,009 |
# 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.
cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
project(GEN_TEST)
set(GEN_TESTCASE "gen_testcase")
set(HITLS_SRC ${PROJECT_SOURCE_DIR}/../../..)
set(EXECUTABLE_OUTPUT_PATH ${HITLS_SRC}/testcode/output)
set(SECURTE_INCLUDE ${HITLS_SRC}/platform/Secure_C/include)
set(GEN_SOURCE_SRC
${PROJECT_SOURCE_DIR}/main.c
${PROJECT_SOURCE_DIR}/helper.c
${PROJECT_SOURCE_DIR}/test.c
)
include_directories(${SECURTE_INCLUDE}
${HITLS_SRC}/testcode/framework/include
${HITLS_SRC}/testcode/framework/crypto
${HITLS_SRC}/config/macro_config
${HITLS_SRC}/crypto/include
${HITLS_SRC}/include/crypto
${HITLS_SRC}/include/bsl
${HITLS_SRC}/bsl/err/include
)
add_executable(${GEN_TESTCASE} ${GEN_SOURCE_SRC})
if(PRINT_TO_TERMINAL)
target_compile_options(${GEN_TESTCASE} PRIVATE -DPRINT_TO_TERMINAL)
endif()
# Use find_library to support cross-platform static library extensions (.a on Unix, .lib on Windows)
find_library(BOUNDSCHECK_STATIC_LIB
NAMES libboundscheck.a boundscheck # Try .a explicitly first, then let CMake find static version
PATHS ${HITLS_SRC}/platform/Secure_C/lib
NO_DEFAULT_PATH
NO_CMAKE_FIND_ROOT_PATH
)
if(NOT BOUNDSCHECK_STATIC_LIB)
message(FATAL_ERROR "Could not find static boundscheck library at ${HITLS_SRC}/platform/Secure_C/lib")
endif()
target_link_libraries(${GEN_TESTCASE} ${BOUNDSCHECK_STATIC_LIB})
| 2401_83913325/openHiTLS_1 | testcode/framework/gen_test/CMakeLists.txt | CMake | unknown | 1,903 |
/*
* 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 "helper.h"
#include <dirent.h>
#include "securec.h"
#include "crypt_utils.h"
#define INCLUDE_BASE "/* INCLUDE_BASE"
#define BEGIN_HEADER "/* BEGIN_HEADER */"
#define END_HEADER "/* END_HEADER */"
#define BEGIN_CASE "/* BEGIN_CASE */"
#define END_CASE "/* END_CASE */"
#define PRINT_TESTSUITES_TAG "</testsuites>\n"
#define PRINT_TESTSUITE_TAG " </testsuite>\n"
#define PRINT_TESTCASE_TAG " </testcase>\n"
#define PRINT_TESTCASE_LIST_TAG " <testcase name=\"%s\" status=\"run\" time=\"0\" classname=\"%s\" />\n"
#define PRINT_FAILURE_TAG " <failure message=\"failed\" type=\"\" />\n"
#define LINE_BREAK_SYMBOL '\n'
#define LINE_HEAD_SYMBOL '\r'
FunctionTable g_testFunc[MAX_TEST_FUCNTION_COUNT];
int g_testFuncCount = 0;
char g_expTable[MAX_EXPRESSION_COUNT][MAX_EXPRESSION_LEN];
int g_expCount = 0;
FILE *g_fpOutput = NULL;
int g_lineCount = 0;
char g_suiteFileName[MAX_FILE_PATH_LEN];
void SetOutputFile(FILE *fp)
{
g_fpOutput = fp;
}
FILE *GetOutputFile(void)
{
return g_fpOutput;
}
void FreeHex(Hex *data)
{
if (data == NULL) {
return;
}
data->len = 0;
if (data->x != NULL) {
free(data->x);
data->x = NULL;
}
}
Hex *NewHex(void)
{
Hex *data = (Hex *)malloc(sizeof(Hex));
if (data == NULL) {
return NULL;
}
data->len = 0;
data->x = NULL;
return data;
}
int IsInt(const char *str)
{
uint32_t i = 0;
if (str[0] == '-') {
i = 1;
}
for (; i < strlen(str); i++) {
if (str[i] > '9' || str[i] < '0') {
return 0;
}
}
return 1;
}
void Print(const char *fmt, ...)
{
#ifdef PRINT_TO_TERMINAL
va_list args;
va_start(args, fmt);
vprintf(fmt, args);
va_end(args);
#else
va_list args;
va_start(args, fmt);
(void)vfprintf(g_fpOutput, fmt, args);
va_end(args);
#endif
}
int ReadLine(FILE *file, char *buf, uint32_t bufLen, bool skipHash, bool skipEmptyLine)
{
int foundLine = 0;
int i;
char *ret = NULL;
while (!foundLine) {
ret = fgets(buf, bufLen, file);
if (ret == NULL) {
return -1;
}
g_lineCount++;
int len = strlen(buf);
if ((buf[0] == '#') && skipHash) {
continue;
}
if (!skipEmptyLine) {
foundLine = 1;
}
for (i = 0; i < len; i++) {
char cur = buf[i];
if (cur != ' ' && cur != LINE_BREAK_SYMBOL && cur != LINE_HEAD_SYMBOL) {
foundLine = 1;
}
if (cur == LINE_BREAK_SYMBOL || cur == LINE_HEAD_SYMBOL) {
buf[i] = '\0';
break;
}
}
}
return 0;
}
int SplitArguments(char *inStr, uint32_t inLen, char **outParam, uint32_t *paramLen)
{
uint32_t cur = 0;
uint32_t count = 0;
bool inString = false;
char *in = inStr;
char **param = outParam;
param[count] = &in[cur];
count++;
cur++;
if (count > *paramLen) {
return 1;
}
while (cur < inLen && in[cur] != '\0') {
if (in[cur] == '\"') {
inString = !inString;
}
if (in[cur] == ':' && !inString) {
if (cur == inLen - 1) {
param[count] = &in[cur];
} else {
param[count] = &in[cur + 1];
count++;
}
if (count > *paramLen) {
printf("Exceed maximum param limit, expect num %u, actual num %u\n",
*paramLen, count);
return 1;
}
in[cur] = '\0';
}
cur++;
}
if (in[cur - 1] == '\n') {
in[cur - 1] = '\0';
}
*paramLen = count;
if (inString) {
return 1;
}
return 0;
}
static int g_fuzzEnd = 0;
int CheckTag(char *in, uint32_t len)
{
char *cur = in;
while (*cur == ' ') {
cur++;
}
uint32_t beginHeaderLen = strlen(BEGIN_HEADER);
uint32_t endHeaderLen = strlen(END_HEADER);
uint32_t beginCaseLen = strlen(BEGIN_CASE);
uint32_t endCaseLen = strlen(END_CASE);
uint32_t includeBaseLen = strlen(INCLUDE_BASE);
if ((len >= beginHeaderLen) && (strlen(cur) >= beginHeaderLen) &&
(strncmp(cur, BEGIN_HEADER, beginHeaderLen) == 0)) {
return TAG_BEGIN_HEADER;
} else if ((len >= endHeaderLen) && (strlen(cur) >= endHeaderLen) &&
(strncmp(cur, END_HEADER, endHeaderLen) == 0)) {
return TAG_END_HEADER;
} else if ((len >= beginCaseLen) && (strlen(cur) >= beginCaseLen) &&
(strncmp(cur, BEGIN_CASE, beginCaseLen) == 0)) {
return TAG_BEGIN_CASE;
} else if ((len >= endCaseLen) && (strlen(cur) >= endCaseLen) &&
(strncmp(cur, END_CASE, endCaseLen) == 0)) {
return TAG_END_CASE;
} else if ((len >= includeBaseLen) && (strlen(cur) >= includeBaseLen) &&
(strncmp(cur, INCLUDE_BASE, includeBaseLen) == 0)) {
return TAG_INCLUDE_BASE;
}
return TAG_NOT_TAG;
}
static int ClearVoid(const char *in, const uint32_t inLen, uint32_t *cur, uint32_t *prev)
{
uint32_t localCur = *cur;
uint32_t localPrev;
while (localCur < inLen && in[localCur] == ' ') {
localCur++;
}
localPrev = localCur;
if (strncmp(&in[localCur], "void", strlen("void")) != 0) {
return 1;
}
localCur += strlen("void");
while (localCur < inLen && in[localCur] == ' ') {
localCur++;
}
localPrev = localCur;
*cur = localCur;
*prev = localPrev;
return 0;
}
static int NextArgument(const char *in, const uint32_t inLen, uint32_t *cur)
{
uint32_t localCur = *cur;
while (localCur < inLen && in[localCur] != ',' && in[localCur] != ')') {
localCur++;
}
if (localCur >= inLen) {
return 1;
}
*cur = localCur;
return 0;
}
static int CheckType(const char *in, const uint32_t cur, const uint32_t prev, int *outType)
{
int *type = outType;
if ((cur - prev == strlen("int")) && (strncmp(&in[prev], "int", strlen("int")) == 0)) {
*type = ARG_TYPE_INT;
} else if ((cur - prev == strlen("Hex")) && (strncmp(&in[prev], "Hex", strlen("Hex")) == 0)) {
*type = ARG_TYPE_HEX;
} else if ((cur - prev == strlen("char")) && (strncmp(&in[prev], "char", strlen("char")) == 0)) {
*type = ARG_TYPE_STR;
} else {
return 1;
}
return 0;
}
int ReadFunction(const char *in, const uint32_t inLen, char *outFuncName, uint32_t outLen, int argv[MAX_ARGUMENT_COUNT],
uint32_t *argCount)
{
uint32_t cur = 0;
uint32_t prev = 0;
char *funcName = outFuncName;
if (ClearVoid(in, inLen, &cur, &prev) != 0) {
return 1;
}
// get function name
while (cur < inLen && in[cur] != '(') {
cur++;
}
if (cur >= inLen) {
return 1;
}
if (strncpy_s(funcName, outLen, &in[prev], cur - prev) != 0) {
return 1;
}
funcName[cur - prev] = '\0';
cur++;
// get argument types
uint32_t count = 0;
while (cur < inLen) {
while (cur < inLen && in[cur] == ' ') {
cur++;
}
prev = cur;
while (cur < inLen && in[cur] != ' ' && in[cur] != ',' && in[cur] != '*' && in[cur] != ')') {
cur++;
}
if (in[cur] == ')') {
break;
}
if (cur == inLen || in[cur] == ',') {
return 1;
}
int type = -1;
if (CheckType(in, cur, prev, &type) != 0) {
Print("******\nERROR: check type failed at: \n");
return 1;
}
argv[count] = type;
count++;
if (NextArgument(in, inLen, &cur) != 0) {
return 1;
}
if (in[cur] == ')') {
break;
}
cur++;
}
*argCount = count;
return 0;
}
int AddFunction(const char *funcName, int argv[MAX_ARGUMENT_COUNT], const uint32_t argCount)
{
if (g_testFuncCount >= MAX_TEST_FUCNTION_COUNT || argCount > MAX_ARGUMENT_COUNT) {
return 1;
}
if (strcpy_s(g_testFunc[g_testFuncCount].name, MAX_TEST_FUNCTION_NAME, funcName) != 0) {
return 1;
}
g_testFunc[g_testFuncCount].argCount = argCount;
for (uint32_t i = 0; i < argCount; i++) {
g_testFunc[g_testFuncCount].argType[i] = argv[i];
}
g_testFunc[g_testFuncCount].id = g_testFuncCount;
g_testFuncCount++;
return 0;
}
int GenFunctionWrapper(FILE *file, FunctionTable *function)
{
int ret;
ret = fprintf(file, "void %s_wrapper(void **param)\n", function->name);
if (ret < 0) {
return 1;
}
ret = fprintf(file, "{\n");
if (ret < 0) {
return 1;
}
ret = fprintf(file, " (void)signal(SIGALRM, handleAlarmSignal);\n");
if (ret < 0) {
return 1;
}
ret = fprintf(file, " alarm(600u);\n");
if (ret < 0) {
return 1;
}
if (function->argCount == 0) {
ret = fprintf(file, " (void) param;\n");
if (ret < 0) {
return 1;
}
}
ret = fprintf(file, " %s(", function->name);
if (ret < 0) {
return 1;
}
for (uint32_t i = 0; i < function->argCount; i++) {
if (function->argType[i] == ARG_TYPE_INT) {
ret = fprintf(file, "*((int*)param[%d])", (int)i);
if (ret < 0) {
return 1;
}
} else if (function->argType[i] == ARG_TYPE_STR) {
ret = fprintf(file, "(char*)param[%d]", (int)i);
if (ret < 0) {
return 1;
}
} else if (function->argType[i] == ARG_TYPE_HEX) {
ret = fprintf(file, "(Hex*)param[%d]", (int)i);
if (ret < 0) {
return 1;
}
}
if (i != function->argCount - 1) {
ret = fprintf(file, ", ");
if (ret < 0) {
return 1;
}
}
}
ret = fprintf(file, ");\n}\n\n");
if (ret < 0) {
return 1;
}
return 0;
}
int GenFunctionPointer(FILE *file)
{
if (file == NULL) {
return 1;
}
int ret;
ret = fprintf(file, "%s\n\n", "typedef void (*TestWrapper)(void **param);");
if (ret < 0) {
return 1;
}
ret = fprintf(file, "%s\n%s\n", "TestWrapper test_funcs[] = ", "{");
if (ret < 0) {
return 1;
}
for (int i = 0; i < g_testFuncCount; i++) {
ret = fprintf(file, " %s_wrapper, \n", g_testFunc[i].name);
if (ret < 0) {
return 1;
}
}
ret = fprintf(file, "%s\n", "};");
if (ret < 0) {
return 1;
}
return 0;
}
static int ConnectFunction(char *lineBuf, uint32_t bufLen, FILE *fp)
{
char buf[MAX_FUNCTION_LINE_LEN];
bool reachEnd = false;
int ret = 0;
while (!reachEnd) {
for (int i = 0; lineBuf[i] != '\0'; i++) {
if (lineBuf[i] == ')') {
ret = 0;
reachEnd = true;
}
if (lineBuf[i] == '{') {
ret = 1;
reachEnd = true;
}
}
if (reachEnd) {
break;
}
if (ReadLine(fp, buf, MAX_FUNCTION_LINE_LEN, 0, 0) == 0) {
if (strcat_s(lineBuf, bufLen, buf) != 0) {
return 1;
}
} else {
return 1;
}
}
return ret;
}
int ScanAllFunction(FILE *inFile, FILE *outFile)
{
char buf[MAX_FUNCTION_LINE_LEN];
int ret = 0;
uint32_t len = MAX_ARGUMENT_COUNT;
bool inFunction = false;
bool isDeclaration = true;
int arguments[MAX_ARGUMENT_COUNT];
char funcName[MAX_TEST_FUNCTION_NAME];
while (ReadLine(inFile, buf, MAX_FUNCTION_LINE_LEN, 0, 0) == 0) {
int curTag = CheckTag(buf, strlen(buf));
if (curTag == TAG_NOT_TAG) {
if (!inFunction) {
fprintf(outFile, "%s\n", buf);
continue;
}
} else if (curTag == TAG_BEGIN_CASE) {
if (!inFunction) {
inFunction = true;
isDeclaration = true;
continue;
}
Print("ERROR: missing end case tag\n");
return 1;
} else if (curTag == TAG_END_CASE) {
if (inFunction) {
inFunction = false;
fprintf(outFile, "\n");
continue;
}
return 1;
} else {
return 1;
}
if (isDeclaration) {
if (ConnectFunction(buf, sizeof(buf), inFile) != 0) {
Print("******\nERROR: connect function failed at: \n");
Print("%s\n", buf);
return 1;
}
ret = ReadFunction(buf, strlen(buf), funcName, sizeof(funcName), arguments, &len);
if (ret != 0) {
Print("*******\nERROR: Read function failed at: \n");
Print("%s\n", buf);
return ret;
}
ret = AddFunction(funcName, arguments, len);
if (ret != 0) {
return ret;
}
isDeclaration = false;
len = MAX_ARGUMENT_COUNT;
}
(void)fprintf(outFile, "%s\n", buf);
}
return 0;
}
static int IncludeBase(char *line, uint32_t len, FILE *outFile, const char *dir)
{
if (len < strlen(INCLUDE_BASE)) {
return 1;
}
char *name = &line[strlen(INCLUDE_BASE)];
while (*name == ' ') {
name++;
}
if (*name == '\0') {
return 1;
}
char *end = name;
while (*end != ' ') {
end++;
}
*end = '\0';
char fileBuf[MAX_FILE_PATH_LEN];
if (snprintf_s(fileBuf, MAX_FILE_PATH_LEN, MAX_FILE_PATH_LEN, BASE_FILE_FORMAT, dir, name) == -1) {
return 1;
}
g_lineCount = 0;
FILE *fpBase = fopen(fileBuf, "r");
if (fpBase == NULL) {
Print("ERROR:Open the base file. %s An error occurred when\n", fileBuf);
return 1;
}
int ret;
char buf[MAX_FUNCTION_LINE_LEN];
while (ReadLine(fpBase, buf, MAX_FUNCTION_LINE_LEN, 0, 0) == 0) {
ret = fprintf(outFile, "%s\n", buf);
if (ret < 0) {
goto EXIT;
}
}
EXIT:
if (fclose(fpBase) != 0) {
Print("base file close failed\n");
}
return 0;
}
int WriteHeader(FILE *outFile)
{
if (fprintf(outFile, "#include \"helper.h\"\n#include \"test.h\"\n#include <time.h>\n#include <unistd.h>\n") < 0) {
return 1;
}
return 0;
}
int ScanHeader(FILE *inFile, FILE *outFile, const char *dir)
{
char buf[MAX_FUNCTION_LINE_LEN];
bool inHeader = false;
while (ReadLine(inFile, buf, MAX_FUNCTION_LINE_LEN, 0, !inHeader) == 0) {
int curTag = CheckTag(buf, strlen(buf));
if (curTag == TAG_BEGIN_HEADER) {
if (!inHeader) {
inHeader = true;
} else {
Print("******\nERROR: duplicate begin header tag\n");
return 1;
}
} else if (curTag == TAG_END_HEADER) {
if (inHeader) {
(void)fprintf(outFile, "%s\n", buf);
return 0;
} else {
Print("******\nERROR: found end header without begin\n");
return 1;
}
} else if (curTag == TAG_INCLUDE_BASE) {
int tmpLineCount = g_lineCount;
if (IncludeBase(buf, strlen(buf), outFile, dir) != 0) {
Print("******\nERROR: include base file failed\n");
return 1;
}
g_lineCount = tmpLineCount;
continue;
} else if (curTag != TAG_NOT_TAG) {
Print("******\nERROR: missing end header tag\n");
return 1;
}
(void)fprintf(outFile, "%s\n", buf);
}
return 0;
}
static int AddExp(const char *exp)
{
if (g_expCount >= MAX_EXPRESSION_COUNT) {
Print("Too much macros. Max macro count is %d\n", MAX_EXPRESSION_COUNT);
return -1;
}
for (int i = 0; i < g_expCount; i++) {
if (strcmp(exp, g_expTable[i]) == 0) {
return i;
}
}
if (strcpy_s(g_expTable[g_expCount], MAX_EXPRESSION_LEN, exp) != 0) {
Print("Macro too long, max length is %d\n", MAX_EXPRESSION_LEN);
return -1;
}
g_expCount++;
return g_expCount - 1;
}
static int GetFuncIdByName(const char *name, uint32_t len)
{
int funcId = -1;
for (int i = 0; i < g_testFuncCount; i++) {
if ((len < MAX_TEST_FUNCTION_NAME) && (strcmp(name, g_testFunc[i].name) == 0)) {
funcId = i;
break;
}
}
return funcId;
}
int GenDatax(FILE *inFile, FILE *outFile)
{
char buf[MAX_DATA_LINE_LEN];
char title[MAX_DATA_LINE_LEN];
int ret;
int funcId = -1;
char *param[MAX_ARGUMENT_COUNT];
uint32_t paramLen = MAX_ARGUMENT_COUNT;
while (ReadLine(inFile, title, MAX_DATA_LINE_LEN, 1, 1) == 0) {
ret = fprintf(outFile, "%s\n", title);
if (ret < 0) {
return 1;
}
if ((ReadLine(inFile, buf, MAX_DATA_LINE_LEN, 1, 1) != 0)) {
return 1;
}
paramLen = MAX_ARGUMENT_COUNT;
ret = SplitArguments(buf, strlen(buf), param, ¶mLen);
if (ret != 0) {
Print("******\nERROR: Generate datax failed: split argument failed at testcase:\n");
Print("%s\n", title);
return ret;
}
funcId = GetFuncIdByName(param[0], strlen(param[0]));
if (funcId == -1) {
Print("******\nERROR: Generate datax failed: no function id for %s at testcase:\n", param[0]);
Print("%s\n", title);
return 1;
}
if (paramLen != g_testFunc[funcId].argCount + 1) {
Print("******\nERROR: Generate datax failed: invalid argument count for function %s at testcase:\n",
param[0]);
Print("%s\n", title);
return 1;
}
ret = fprintf(outFile, "%d:", funcId);
if (ret < 0) {
return 1;
}
int expId = 0;
for (uint32_t i = 0; i < g_testFunc[funcId].argCount; i++) {
if (g_testFunc[funcId].argType[i] == ARG_TYPE_INT && (IsInt(param[i + 1]) == 1)) {
ret = fprintf(outFile, "int:%s", param[i + 1]);
} else if (g_testFunc[funcId].argType[i] == ARG_TYPE_INT && (!IsInt(param[i + 1]))) {
expId = AddExp(param[i + 1]);
ret = fprintf(outFile, "exp:%d", expId);
} else if (g_testFunc[funcId].argType[i] == ARG_TYPE_STR) {
ret = fprintf(outFile, "char:%s", param[i + 1]);
} else if (g_testFunc[funcId].argType[i] == ARG_TYPE_HEX) {
ret = fprintf(outFile, "Hex:%s", param[i + 1]);
} else {
Print("invalid argument type\n");
return 1;
}
if (ret < 0) {
return 1;
}
if (i != g_testFunc[funcId].argCount - 1) {
ret = fprintf(outFile, ":");
}
if (expId == -1) {
return 1;
}
expId = 0;
}
ret = fprintf(outFile, "\n\n");
if (ret < 0) {
return 1;
}
}
return 0;
}
int GenExpTable(FILE *outFile)
{
int ret;
ret = fprintf(outFile, "int getExpression(int expId, int *out)\n{\n");
if (ret < 0) {
return 1;
}
if (g_expCount == 0) {
ret = fprintf(outFile, " (void) out;\n (void) expId;\n");
if (ret < 0) {
return 1;
}
}
ret = fprintf(outFile, " int ret = 0;\n");
if (ret < 0) {
return 1;
}
ret = fprintf(outFile, " switch (expId)\n {\n");
if (ret < 0) {
return 1;
}
for (int i = 0; i < g_expCount; i++) {
ret = fprintf(outFile, " case %d:\n", i);
if (ret < 0) {
return 1;
}
ret = fprintf(outFile, " *out = %s;\n", g_expTable[i]);
if (ret < 0) {
return 1;
}
ret = fprintf(outFile, " break;\n");
if (ret < 0) {
return 1;
}
}
ret = fprintf(outFile, " default:\n");
if (ret < 0) {
return 1;
}
ret = fprintf(outFile, " ret = 1;\n");
if (ret < 0) {
return 1;
}
ret = fprintf(outFile, " break;\n");
if (ret < 0) {
return 1;
}
ret = fprintf(outFile, " }\n return ret;\n}\n");
if (ret < 0) {
return 1;
}
return 0;
}
int LoadFunctionName(FILE *outFile)
{
int ret;
ret = fprintf(outFile, "const char * funcName[] = {\n");
if (ret < 0) {
return 1;
}
for (int i = 0; i < g_testFuncCount; i++) {
ret = fprintf(outFile, " \"%s\",\n", g_testFunc[i].name);
if (ret < 0) {
return 1;
}
}
ret = fprintf(outFile, "};\n\n");
if (ret < 0) {
return 1;
}
return 0;
}
int LoadHelper(FILE *inFile, FILE *outFile)
{
int ret;
char buf[MAX_FUNCTION_LINE_LEN];
if (inFile == NULL || outFile == NULL) {
return 1;
}
while (fgets(buf, MAX_FUNCTION_LINE_LEN, inFile) != NULL) {
ret = fprintf(outFile, "%s", buf);
if (ret < 0) {
return 1;
}
}
(void)fprintf(outFile, "\n\n");
return 0;
}
int SplitHex(Hex *src, Hex *dest, int max)
{
uint32_t blocks = src->len / SPILT_HEX_BLOCK_SIZE;
uint32_t remain = src->len % SPILT_HEX_BLOCK_SIZE;
uint32_t i;
if (blocks + 1 > (uint32_t)max) {
return 0;
}
for (i = 0; i < blocks; i++) {
dest[i].x = src->x + i * SPILT_HEX_BLOCK_SIZE;
dest[i].len = SPILT_HEX_BLOCK_SIZE;
}
if (remain == 0) {
return blocks;
} else {
dest[i].x = src->x + i * SPILT_HEX_BLOCK_SIZE;
dest[i].len = remain;
return blocks + 1;
}
}
int SplitHexRand(Hex *src, Hex *dest, int max)
{
uint32_t left = src->len;
int id = 0;
if (left <= 3) {
dest[id].x = src->x;
dest[id].len = left;
id++;
return id;
}
while (left > 3) {
dest[id].x = src->x + (src->len - left);
uint16_t clen = GET_UINT16_LE(dest[id].x, 0);
dest[id].len = clen > left ? left : clen;
left -= dest[id].len;
id++;
if (id > max - 1) {
break;
}
}
if (left > 0) {
dest[id - 1].len += left;
}
return id;
}
FILE *OpenFile(const char *name, const char *option, const char *format)
{
FILE *fp = NULL;
char fileBuf[MAX_FILE_PATH_LEN];
if (snprintf_s(fileBuf, MAX_FILE_PATH_LEN, MAX_FILE_PATH_LEN, format, name) == -1) {
Print("argument too long\n");
return NULL;
}
fp = fopen(fileBuf, option);
return fp;
}
int StripDir(const char *in, char *suiteName, const uint32_t suiteNameLen, char *dir, const uint32_t dirNameLen)
{
int len = strlen(in);
int begin = len - 1;
char *localDir = dir;
char *localSuiteName = suiteName;
while (begin >= 0 && in[begin] != '/') {
begin--;
}
if (begin < 0) {
return 1;
}
if (strncpy_s(localDir, dirNameLen, in, begin) != 0) {
return 1;
}
if (strcpy_s(localSuiteName, suiteNameLen, &in[begin + 1]) != 0) {
return 1;
}
if (strcpy_s(g_suiteFileName, MAX_FILE_PATH_LEN, &in[begin + 1]) != 0) {
return 1;
}
return 0;
}
int ScanFunctionFile(FILE *fpIn, FILE *fpOut, const char *dir)
{
int ret;
ret = ScanHeader(fpIn, fpOut, dir);
if (ret != 0) {
Print("scan header failed\n");
return 1;
}
ret = ScanAllFunction(fpIn, fpOut);
if (ret != 0) {
Print("scan function failed\n");
return 1;
}
if (fprintf(fpOut, "\n void handleAlarmSignal(int signum)\n{\n\
(void)signum; \n\
fprintf(stderr, \"timeout 600\\n\");\n\
exit(-1);\n}\n") < 0) {
return 1;
}
for (int i = 0; i < g_testFuncCount; i++) {
ret = GenFunctionWrapper(fpOut, &g_testFunc[i]);
if (ret < 0) {
Print("generate function wrapper failed\n");
return 1;
}
}
if (g_fuzzEnd == 1) {
ret = fprintf(fpOut, "#define FREE_FUZZ_TC 1\n\n");
} else {
ret = fprintf(fpOut, "#define FREE_FUZZ_TC 0\n\n");
}
if (ret < 0) {
return 1;
}
return 0;
}
static bool IsSuite(char *buf, uint32_t bufLen)
{
uint32_t beginTagLen = strlen("Begin time:");
uint32_t endTagLen = strlen("End time:");
uint32_t resultTagLen = strlen("Result:");
uint32_t atTagLen = strlen("at:");
if (bufLen >= beginTagLen && strncmp(buf, "Begin time:", beginTagLen) == 0) {
return false;
} else if (bufLen >= endTagLen && strncmp(buf, "End time:", endTagLen) == 0) {
return false;
} else if (bufLen >= resultTagLen && strncmp(buf, "Result:", resultTagLen) == 0) {
return false;
} else if (bufLen >= atTagLen && strncmp(buf, "at:", atTagLen) == 0) {
return false;
}
return true;
}
static int ReadAllLogFile(DIR *logDir, int *totalSuiteCount, FILE *outFile, TestSuiteResult *result, int resultLen)
{
struct dirent *dir = NULL;
int suiteCount = 0;
int cur;
DIR *localLogDir = logDir;
// Stores the execution results of all test cases.
FILE *fpAllLog = OpenFile("result.log", "w+", "%s");
if (fpAllLog == NULL) {
return 1;
}
FILE *fpLog = NULL;
while ((dir = readdir(localLogDir)) != NULL) {
char buf[MAX_LOG_LEN];
uint32_t bufLen = sizeof(buf);
if (strcmp(dir->d_name, ".") == 0 || strcmp(dir->d_name, "..") == 0) {
continue;
}
// len of ".log" is 4
if (strlen(dir->d_name) <= 4 || strlen(dir->d_name) > MAX_FILE_PATH_LEN - 1) {
(void)fclose(fpAllLog);
return 1;
}
fpLog = OpenFile(dir->d_name, "r", LOG_FILE_FORMAT);
if (fpLog == NULL) {
(void)fclose(fpAllLog);
return 1;
}
if (suiteCount >= resultLen) {
Print("Reached maximum suite count\n");
(void)fclose(fpLog);
(void)fclose(fpAllLog);
return 1;
}
if (strcpy_s(result[suiteCount].name, MAX_TEST_FUNCTION_NAME - 1, dir->d_name) != EOK) {
Print("Dir's Name is too long\n");
(void)fclose(fpLog);
(void)fclose(fpAllLog);
return 1;
}
// len of ".log" is 4
result[suiteCount].name[strlen(dir->d_name) - 4] = '\0';
result[suiteCount].total = 0;
result[suiteCount].pass = 0;
result[suiteCount].skip = 0;
result[suiteCount].line = 0;
while (ReadLine(fpLog, buf, bufLen, 0, 0) == 0) {
char testCaseName[MAX_TEST_FUNCTION_NAME];
memset_s(testCaseName, MAX_TEST_FUNCTION_NAME, 0, MAX_TEST_FUNCTION_NAME);
if (!IsSuite(buf, strlen(buf))) {
continue;
}
result[suiteCount].total++;
cur = 0;
while (buf[cur] != '\0' && !(buf[cur] == '.' && buf[cur + 1] == '.')) {
cur++;
}
if (buf[cur] == '\0') {
Print("Read log file %s failed\n", dir->d_name);
(void)fclose(fpLog);
(void)fclose(fpAllLog);
return 1;
}
if (strncpy_s(testCaseName, sizeof(testCaseName) - 1, buf, cur) != EOK) {
Print("TestCaseName is too long\n");
(void)fclose(fpLog);
(void)fclose(fpAllLog);
return 1;
}
testCaseName[cur] = '\0';
while (buf[cur] == '.') {
cur++;
}
if (strncmp(&buf[cur], "pass", strlen("pass")) == 0) {
result[suiteCount].pass++;
result[suiteCount].line++;
(void)fprintf(outFile, PRINT_TESTCASE_LIST_TAG, testCaseName, result[suiteCount].name);
(void)fprintf(fpAllLog, "%s %s\n", testCaseName, "PASS");
} else if (strncmp(&buf[cur], "skip", strlen("skip")) == 0) {
result[suiteCount].skip++;
result[suiteCount].line++;
(void)fprintf(outFile, PRINT_TESTCASE_LIST_TAG, testCaseName, result[suiteCount].name);
(void)fprintf(fpAllLog, "%s %s\n", testCaseName, "SKIP");
} else {
result[suiteCount].line += 3; // Incorrect test case requires 3 lines
(void)fprintf(outFile, PRINT_TESTCASE_LIST_TAG, testCaseName, result[suiteCount].name);
(void)fprintf(fpAllLog, "%s %s\n", testCaseName, "FAIL");
(void)fprintf(outFile, PRINT_FAILURE_TAG);
(void)fprintf(outFile, PRINT_TESTCASE_TAG);
}
}
suiteCount++;
cur = 0;
(void)fclose(fpLog);
}
*totalSuiteCount = suiteCount;
(void)fclose(fpAllLog);
return 0;
}
static int GenResultFile(FILE *in, FILE *out, TestSuiteResult result[MAX_SUITE_COUNT], int testSuiteCount)
{
int totalTests = 0;
int totalPass = 0;
int totalSkip = 0;
if (testSuiteCount >= MAX_SUITE_COUNT) {
Print("suites count too great\n");
return 1;
}
for (int i = 0; i < testSuiteCount; i++) {
totalTests += result[i].total;
totalPass += result[i].pass;
totalSkip += result[i].skip;
}
(void)fprintf(out, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
(void)fprintf(out, "<testsuites tests=\"%d\" failures=\"%d\" disabled=\"%d\" errors=\"0\" ", totalTests,
totalTests - totalPass - totalSkip, totalSkip);
(void)fprintf(out, "timestamp=\"0000-00-00T00:00:00\" time=\"0\" name=\"AllTests\">\n");
for (int i = 0; i < testSuiteCount; i++) {
(void)fprintf(out,
" <testsuite name=\"%s\" tests=\"%d\" skips = \"%d\" failures=\"%d\" ",
result[i].name, result[i].total, result[i].skip,
result[i].total - result[i].pass - result[i].skip);
(void)fprintf(out, "disabled=\"0\" errors=\"0\" time=\"0\">\n");
for (int j = 0; j < result[i].line; j++) {
char buf[MAX_LOG_LEN];
if (fgets(buf, sizeof(buf), in) != NULL) {
(void)fputs(buf, out);
} else {
return 1;
}
}
(void)fprintf(out, PRINT_TESTSUITE_TAG);
}
(void)fprintf(out, PRINT_TESTSUITES_TAG);
return 0;
}
int GenResult(void)
{
int ret;
TestSuiteResult result[MAX_SUITE_COUNT];
int testSuiteCount = 0;
DIR *logDir = NULL;
logDir = opendir(LOG_FILE_DIR);
if (logDir == NULL) {
Print("fail to open log directory\n");
return 1;
}
FILE *fpTmp = NULL;
fpTmp = fopen("tmp.txt", "w+");
if (fpTmp == NULL) {
Print("open tmp.txt failed\n");
(void)closedir(logDir);
return 1;
}
FILE *fpResult = NULL;
fpResult = fopen("result.xml", "w");
if (fpResult == NULL) {
Print("open result.xml failed\n");
(void)closedir(logDir);
(void)fclose(fpTmp);
(void)remove("tmp.txt");
return 1;
}
ret = ReadAllLogFile(logDir, &testSuiteCount, fpTmp, result, sizeof(result));
if (ret != 0) {
Print("read log failed\n");
goto EXIT;
}
rewind(fpTmp);
ret = GenResultFile(fpTmp, fpResult, result, testSuiteCount);
if (ret != 0) {
Print("gen result failed\n");
goto EXIT;
}
EXIT:
(void)closedir(logDir);
(void)fclose(fpTmp);
(void)fclose(fpResult);
(void)remove("tmp.txt");
return ret;
}
| 2401_83913325/openHiTLS_1 | testcode/framework/gen_test/helper.c | C | unknown | 32,462 |
/*
* 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 "helper.h"
#define EXECUTE_BASE_FILE "../common/execute_base.c"
#define EXECUTE_TEST_FILE "../common/execute_test.c"
typedef struct {
char suiteName[MAX_FILE_PATH_LEN];
char dir[MAX_FILE_PATH_LEN];
FILE *fpIn;
FILE *fpOut;
FILE *fpData;
FILE *fpBase;
FILE *fpDatax;
FILE *fpHelper;
} GenTestParams;
int WriteToFile(GenTestParams *genParam)
{
int ret = 0;
ret = WriteHeader(genParam->fpOut);
if (ret != 0) {
return ret;
}
// Scanned test_suite_xxx.c, and write fpOut
ret = ScanFunctionFile(genParam->fpIn, genParam->fpOut, genParam->dir);
if (ret != 0) {
return ret;
}
ret = GenFunctionPointer(genParam->fpOut);
if (ret != 0) {
return ret;
}
ret = GenDatax(genParam->fpData, genParam->fpDatax);
if (ret != 0) {
Print("gen datax failed\n");
return ret;
}
ret = GenExpTable(genParam->fpOut);
if (ret != 0) {
return ret;
}
ret = LoadFunctionName(genParam->fpOut);
if (ret != 0) {
return ret;
}
(void)fprintf(genParam->fpOut, "char suiteName[200] = \"%s\";\n\n", genParam->suiteName);
// Write execute_base.c to fpOut
ret = LoadHelper(genParam->fpBase, genParam->fpOut);
if (ret != 0) {
return ret;
}
// Write execute_test.c to fpOut
return LoadHelper(genParam->fpHelper, genParam->fpOut);
}
int main(int argc, char **argv)
{
(void)argc;
#ifndef PRINT_TO_TERMINAL
FILE *fp = fopen("GenTest.output", "a");
if (fp == NULL) {
return 1;
}
SetOutputFile(fp);
#endif
if (strcmp(argv[1], "GenReport") == 0) {
int resultRet = GenResult();
#ifndef PRINT_TO_TERMINAL
(void)fclose(fp);
#endif
return resultRet;
}
int ret = 0;
GenTestParams genParam = {0};
StripDir(argv[1], genParam.suiteName, MAX_FILE_PATH_LEN, genParam.dir, MAX_FILE_PATH_LEN);
// Read test_suite_xxx.c
genParam.fpIn = OpenFile(argv[1], "r", "%s.c");
if (genParam.fpIn == NULL) {
Print("Open %s.c error occurred while file\n", argv[1]);
#ifndef PRINT_TO_TERMINAL
(void)fclose(fp);
#endif
return -1;
}
// Output file testcode/output/test_suite_xxx.c
genParam.fpOut = OpenFile(genParam.suiteName, "w", "%s.c");
if (genParam.fpOut == NULL) {
Print("Error generating c file\n");
ret = 1;
goto END_FP_IN;
}
genParam.fpData = OpenFile(argv[1], "r", "%s.data");
if (genParam.fpData == NULL) {
Print("An error occurred while opening the data file.\n");
ret = 1;
goto END_FP_OUT;
}
genParam.fpDatax = OpenFile(genParam.suiteName, "w", "%s.datax");
if (genParam.fpDatax == NULL) {
Print("Error generating datax file\n");
ret = 1;
goto END_FP_DATA;
}
genParam.fpBase = fopen(EXECUTE_BASE_FILE, "r");
if (genParam.fpBase == NULL) {
Print("An error occurred when opening the base file.\n");
ret = 1;
goto END_FP_DATAX;
}
genParam.fpHelper = fopen(EXECUTE_TEST_FILE, "r");
if (genParam.fpHelper == NULL) {
Print("Error opening secondary file\n");
ret = 1;
goto END_FP_BASE;
}
ret = WriteToFile(&genParam);
(void)fclose(genParam.fpHelper);
END_FP_BASE:
(void)fclose(genParam.fpBase);
END_FP_DATAX:
(void)fclose(genParam.fpDatax);
END_FP_DATA:
(void)fclose(genParam.fpData);
END_FP_OUT:
(void)fclose(genParam.fpOut);
END_FP_IN:
(void)fclose(genParam.fpIn);
#ifndef PRINT_TO_TERMINAL
(void)fclose(fp);
#endif
return ret;
}
| 2401_83913325/openHiTLS_1 | testcode/framework/gen_test/main.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.
*/
#include "securec.h"
#include "helper.h"
#include "test.h"
TestInfo g_testResult;
int ConvertInt(const char *intStr, int *outNum)
{
int *num = outNum;
uint32_t i = 0;
if (intStr[0] == '-') {
i = 1;
}
for (; i < strlen(intStr); i++) {
if (intStr[i] > '9' || intStr[i] < '0') {
return 1;
}
}
// Decimal
*num = strtol(intStr, NULL, 10);
return 0;
}
int ConvertString(char **str)
{
if ((*str)[0] != '"') {
return 1;
}
uint32_t back = strlen(*str) - 1;
if ((*str)[back] != '"') {
back--;
if ((*str)[back] != '"') {
return 1;
}
}
(*str)[back] = '\0';
(*str)++;
return 0;
}
int IsValidHexChar(char c)
{
if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) {
return 0;
}
return 1;
}
int ConvertHex(const char *str, Hex *output)
{
uint32_t len = strlen(str);
if (len == 0) {
output->x = NULL;
output->len = 0;
return 0;
}
// The length of a hex string must be a multiple of 2.
if (len % 2 != 0) {
return 1;
}
// Length of the hex string/2 = Length of the byte stream
len = len / 2;
output->x = (uint8_t *)malloc(len * sizeof(uint8_t));
if (output->x == NULL) {
return 1;
}
output->len = len;
// Every 2 bytes in a group
for (uint32_t i = 0; i < 2 * len; i += 2) {
if ((IsValidHexChar(str[i]) == 1) || (IsValidHexChar(str[i + 1]) == 1)) {
goto ERR;
}
// hex to int formulas: (Hex % 32 + 9) % 25 = int, hex
output->x[i / 2] = (str[i] % 32 + 9) % 25 * 16 + (str[i + 1] % 32 + 9) % 25;
}
return 0;
ERR:
free(output->x);
output->len = 0;
return 1;
}
void RecordFailure(const char *test, const char *filename)
{
g_testResult.result = TEST_RESULT_FAILED;
if (strcpy_s(g_testResult.test, sizeof(g_testResult.test), test) != 0) {
Print("failure log failed: message too long\n");
}
if (strcpy_s(g_testResult.filename, sizeof(g_testResult.filename), filename) != 0) {
Print("failure log failed: filename too long\n");
}
}
void SkipTest(const char *filename)
{
g_testResult.result = TEST_RESULT_SKIPPED;
if (strcpy_s(g_testResult.filename, sizeof(g_testResult.filename), filename) != 0) {
Print("failure log failed: filename too long\n");
}
}
void PrintResult(bool showDetail, char *vectorName, uint64_t useTime)
{
if (showDetail) {
if (g_testResult.result == TEST_RESULT_SUCCEED) {
Print("pass. use ms: %ld\n", useTime);
} else if (g_testResult.result == TEST_RESULT_SKIPPED) {
Print("skip\n");
} else {
Print("failed\n");
Print("at: (%s) in %s\n", g_testResult.test, g_testResult.filename);
}
} else if (g_testResult.result == TEST_RESULT_FAILED) {
Print("\nfailed at vector: %s\n", vectorName);
Print("at: (%s) in %s\n", g_testResult.test, g_testResult.filename);
}
}
void PrintLog(FILE *logFile)
{
int ret;
if (g_testResult.result == TEST_RESULT_SUCCEED) {
ret = fprintf(logFile, "pass\n");
if (ret < 0) {
Print("write to log file failed\n");
}
} else if (g_testResult.result == TEST_RESULT_SKIPPED) {
ret = fprintf(logFile, "skip\n");
if (ret < 0) {
Print("write to log file failed\n");
}
} else {
ret = fprintf(logFile, "failed\n");
if (ret < 0) {
Print("write to log file failed\n");
}
ret = fprintf(logFile, "at: (%s) in in %s\n", g_testResult.test, g_testResult.filename);
if (ret < 0) {
Print("write to log file failed\n");
}
}
}
void PrintDiff(const uint8_t *str1, uint32_t size1, const uint8_t *str2, uint32_t size2)
{
Print("\nCompare different:\nstr1: ");
uint32_t i;
for (i = 0; i < size1; i++) {
Print("%02X ", str1[i]);
}
Print("\nstr2: ");
for (i = 0; i < size2; i++) {
Print("%02X ", str2[i]);
}
Print("\n");
} | 2401_83913325/openHiTLS_1 | testcode/framework/gen_test/test.c | C | unknown | 4,697 |
/*
* 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 HELPER_H
#define HELPER_H
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdarg.h>
#ifdef __cplusplus
extern "C" {
#endif
#define MAX_TEST_FUCNTION_COUNT 100
#define MAX_TEST_FUNCTION_NAME 500
#define MAX_ARGUMENT_COUNT 50
#define MAX_EXPRESSION_COUNT 100
#define MAX_EXPRESSION_LEN 100
#define MAX_DATA_LINE_LEN 120000
#define MAX_FUNCTION_LINE_LEN 512
#define MAX_FILE_PATH_LEN 300
#define MAX_SUITE_COUNT 600
#define MAX_LOG_LEN 500
#define TAG_NOT_TAG 0
#define TAG_BEGIN_HEADER 1
#define TAG_END_HEADER 2
#define TAG_BEGIN_CASE 3
#define TAG_END_CASE 4
#define TAG_INCLUDE_BASE 5
#define SPILT_HEX_BLOCK_SIZE 4
#define ARG_TYPE_INT 1
#define ARG_TYPE_STR 2
#define ARG_TYPE_HEX 3
#define BASE_FILE_FORMAT "%s/%s.base.c"
#define LOG_FILE_DIR "./log/"
#define LOG_FILE_FORMAT "./log/%s"
#define FUZZ_PRINT_EXECUTES "\r%d"
typedef struct {
char name[MAX_FILE_PATH_LEN];
int total;
int pass;
int skip;
int line;
} TestSuiteResult;
typedef struct {
char name[MAX_TEST_FUNCTION_NAME];
int id;
int argType[MAX_ARGUMENT_COUNT];
uint32_t argCount;
} FunctionTable;
typedef struct {
uint8_t *x;
uint32_t len;
} Hex;
extern FunctionTable g_testFunc[MAX_TEST_FUCNTION_COUNT];
extern int g_testFuncCount;
extern char g_expTable[MAX_EXPRESSION_COUNT][MAX_EXPRESSION_LEN];
extern int g_expCount;
void Print(const char *fmt, ...);
void SetOutputFile(FILE *fp);
FILE *GetOutputFile(void);
void FreeHex(Hex *data);
Hex *NewHex(void);
int IsInt(const char *str);
int ReadLine(FILE *file, char *buf, uint32_t bufLen, bool skipHash, bool skipEmptyLine);
int SplitArguments(char *inStr, uint32_t inLen, char **outParam, uint32_t *paramLen);
int ReadFunction(const char *in, const uint32_t inLen, char *outFuncName, uint32_t outLen, int argv[MAX_ARGUMENT_COUNT],
uint32_t *argCount);
int AddFunction(const char *funcName, int argv[MAX_ARGUMENT_COUNT], const uint32_t argCount);
int CheckTag(char *in, uint32_t len);
int GenFunctionWrapper(FILE *file, FunctionTable *function);
int ScanAllFunction(FILE *inFile, FILE *outFile);
int ScanHeader(FILE *inFile, FILE *outFile, const char *dir);
int GenFunctionPointer(FILE *file);
int GenDatax(FILE *inFile, FILE *outFile);
int GenExpTable(FILE *outFile);
int LoadFunctionName(FILE *outFile);
int LoadHelper(FILE *inFile, FILE *outFile);
int ScanFunctionFile(FILE *fpIn, FILE *fpOut, const char *dir);
int StripDir(const char *in, char *suiteName, const uint32_t suiteNameLen, char *dir, const uint32_t dirNameLen);
FILE *OpenFile(const char *name, const char *option, const char *format);
int GenResult(void);
int SplitHex(Hex *src, Hex *dest, int max);
int SplitHexRand(Hex *src, Hex *dest, int max);
int WriteHeader(FILE *outFile);
#ifdef __cplusplus
}
#endif
#endif // HELPER_H | 2401_83913325/openHiTLS_1 | testcode/framework/include/helper.h | C | unknown | 3,408 |
/*
* 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 TEST_H
#define TEST_H
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdint.h>
#include <signal.h>
#include <setjmp.h>
#include <sys/wait.h>
#include <time.h>
#include "helper.h"
#include "crypto_test_util.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* Platform-specific dynamic library file extension for testing
*
* This macro provides the appropriate shared library extension for each platform
* and is used by test code to construct dynamic library names.
*
* - Darwin (macOS/iOS): .dylib
* - Linux/Unix/BSD: .so
*/
#ifdef __APPLE__
#define BSL_SAL_DL_EXT "dylib"
#else
#define BSL_SAL_DL_EXT "so"
#endif
#define TEST_RESULT_SUCCEED 0
#define TEST_RESULT_FAILED 1
#define TEST_RESULT_SKIPPED 2
typedef struct {
int result;
char test[512];
char filename[256];
} TestInfo;
#define TRUE_OR_EXIT(TEST) \
do { \
if (!(TEST)) { \
goto EXIT; \
} \
} while (0)
#define TRUE_OR_ABRT(TEST) \
do { \
if (!(TEST)) { \
raise(SIGABRT); \
} \
} while (0)
#define PRINT_ABRT(TEST) \
do { \
if (!(TEST)) { \
goto ABORT; \
} \
} while (0)
#define ASSERT_TRUE(TEST) \
do { \
if (!(TEST)) { \
RecordFailure(#TEST, __FILE__); \
goto EXIT; \
} \
} while (0)
#define ASSERT_EQ(VALUE1, VALUE2) \
do { \
int64_t value1__ = (int64_t)(VALUE1); \
int64_t value2__ = (int64_t)(VALUE2); \
if (value1__ != value2__) { \
RecordFailure(#VALUE1 #VALUE2, __FILE__); \
Print("\nvalue is %d (0x%x).\nexpect %d (0x%x).\n", value1__, value1__, value2__, value2__); \
goto EXIT; \
} \
} while (0)
#define ASSERT_LT(VALUE1, VALUE2) \
do { \
int64_t value1__ = (int64_t)(VALUE1); \
int64_t value2__ = (int64_t)(VALUE2); \
if (!(value1__ < value2__)) { \
RecordFailure(#VALUE1 #VALUE2, __FILE__); \
Print("\nvalue is %d (0x%x).\nexpect %d (0x%x).\n", value1__, value1__, value2__, value2__); \
goto EXIT; \
} \
} while (0)
#define ASSERT_EQ_LOG(LOG, VALUE1, VALUE2) \
do { \
int64_t value1__ = (int64_t)(VALUE1); \
int64_t value2__ = (int64_t)(VALUE2); \
if (value1__ != value2__) { \
RecordFailure(LOG, __FILE__); \
Print("\nvalue is %d (0x%x).\nexpect %d (0x%x).\n", value1__, value1__, value2__, value2__); \
goto EXIT; \
} \
} while (0)
#define ASSERT_NE(VALUE1, VALUE2) \
do { \
int64_t value1__ = (int64_t)(VALUE1); \
int64_t value2__ = (int64_t)(VALUE2); \
if (value1__ == value2__) { \
RecordFailure(#VALUE1#VALUE2, __FILE__); \
Print("\nvalue is the same: %d (0x%x).\n", value1__, value2__); \
goto EXIT; \
} \
} while (0)
#define ASSERT_TRUE_AND_LOG(LOG, TEST) \
do { \
if (!(TEST)) { \
RecordFailure(LOG, __FILE__); \
goto EXIT; \
} \
} while (0)
#define ASSERT_COMPARE(LOG, STR1, SIZE1, STR2, SIZE2) \
do { \
ASSERT_TRUE_AND_LOG(LOG, (SIZE1) == (SIZE2)); \
if (memcmp((STR1), (STR2), (SIZE1)) != 0) { \
RecordFailure((LOG), __FILE__); \
PrintDiff((uint8_t *)(STR1), (uint32_t)(SIZE1), (uint8_t *)(STR2), (uint32_t)(SIZE2)); \
goto EXIT; \
} \
} while (0)
#define SKIP_TEST() \
do {\
SkipTest(__FILE__); \
return; \
} while (0)
extern int *GetJmpAddress(void);
#ifndef TEST_NO_SUBPROC
#define SUB_PROC 1
#define SUB_PROC_BEGIN(parentAction) if (fork() > 0) parentAction
#define SUB_PROC_END() *GetJmpAddress() = SUB_PROC; return
#define SUB_PROC_WAIT(times) for (uint16_t i = 0; i < times; i++) wait(NULL)
#else
#define SUB_PROC 0
#define SUB_PROC_BEGIN(parentAction)
#define SUB_PROC_END()
#define SUB_PROC_WAIT(times)
#endif
extern TestInfo g_testResult;
int ConvertInt(const char *intStr, int *outNum);
int ConvertString(char **str);
int ConvertHex(const char *str, Hex *output);
void RecordFailure(const char *test, const char *filename);
void SkipTest(const char *filename);
void PrintResult(bool showDetail, char *vectorName, uint64_t useTime);
void PrintLog(FILE *logFile);
void PrintDiff(const uint8_t *str1, uint32_t size1, const uint8_t *str2, uint32_t size2);
#ifdef __cplusplus
}
#endif
#endif // TEST_H | 2401_83913325/openHiTLS_1 | testcode/framework/include/test.h | C | unknown | 6,869 |
# 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}/include/pki
${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()
# Use find_library to support cross-platform static library extensions (.a on Unix, .lib on Windows)
find_library(BOUNDSCHECK_STATIC_LIB
NAMES libboundscheck.a boundscheck # Try .a explicitly first, then let CMake find static version
PATHS ${openHiTLS_SRC}/platform/Secure_C/lib
NO_DEFAULT_PATH
NO_CMAKE_FIND_ROOT_PATH
)
if(NOT BOUNDSCHECK_STATIC_LIB)
message(FATAL_ERROR "Could not find static boundscheck library at ${openHiTLS_SRC}/platform/Secure_C/lib")
endif()
list(APPEND PROCESS_LIBS hitls_crypto hitls_bsl ${BOUNDSCHECK_STATIC_LIB} pthread dl rec_wrapper)
target_link_libraries(process ${PROCESS_LIBS})
| 2401_83913325/openHiTLS_1 | testcode/framework/process/CMakeLists.txt | CMake | unknown | 2,537 |
/*
* 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();
(void)ExecuteCmd(&cmdData); // Cast to void to suppress unused-value warning
PushResultToChannelSendBuffer(channelInfo, cmdData.result);
return;
}
int main(int argc, char **argv)
{
int ret, sctpFd = -1; // Initialize sctpFd to -1 (invalid fd)
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;
}
| 2401_83913325/openHiTLS_1 | testcode/framework/process/process.c | C | unknown | 7,172 |
/*
* 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.
*/
/*
* stub_utils.h - Cross-Platform Stub Framework
*
* This framework provides a real-by-default stubbing mechanism:
* - Unix/Linux/macOS: Calls real implementations via dlsym(RTLD_NEXT)
* - Windows: Placeholder for future GetProcAddress-based implementation
* - Allows runtime stubbing for test control
*
* Usage:
* #include "stub_utils.h"
*
* STUB_DEFINE_RET2(int, Add, int, int);
*
* // By default: Calls real Add from library (Unix) or returns default (Windows placeholder)
* int result = Add(10, 20);
*
* // Can stub for testing:
* STUB_REPLACE(Add, my_custom_stub);
* result = Add(10, 20); // Uses my_custom_stub
*
* // Restore to real implementation:
* STUB_RESTORE(Add);
*/
#ifndef STUB_UTILS_H
#define STUB_UTILS_H
#if defined(__linux__) || defined(__gnu_linux__)
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#endif
#include <string.h>
#include <stddef.h>
/* ============================================================================
* Platform Detection and Includes
* ============================================================================ */
#if defined(__unix__) || defined(__unix) || defined(__APPLE__) || defined(__MACH__)
/* Unix-like platforms: Linux, macOS, BSD, etc. */
#define STUB_PLATFORM_UNIX
#include <dlfcn.h>
#ifndef RTLD_NEXT
#error "RTLD_NEXT not supported on this Unix platform. Please ensure _GNU_SOURCE is defined on Linux."
#endif
#elif defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__)
/* Windows platforms */
#define STUB_PLATFORM_WINDOWS
#include <windows.h>
/* Windows implementation is placeholder - real symbol lookup not yet implemented */
#ifndef STUB_WINDOWS_WARN_ONCE
#define STUB_WINDOWS_WARN_ONCE
#pragma message("Warning: Windows real function call support is not yet implemented.")
#endif
#else
#error "Unsupported platform. This framework requires Unix-like OS or Windows."
#endif
/* ============================================================================
* Common Macros
* ============================================================================ */
#define STUB_COMMON_FIELDS \
const char* stub_target_symbol
/* ============================================================================
* Control Macros (Platform-Independent)
* ============================================================================ */
#define STUB_REPLACE(FUNCNAME, STUB_FUNC) \
do { FUNCNAME##_stub.stub_impl = STUB_FUNC; } while(0)
#define STUB_RESTORE(FUNCNAME) \
do { FUNCNAME##_stub.stub_impl = NULL; } while(0)
#define WITH_STUB_SCOPED(FUNCNAME, STUB_FUNC) \
for(int _stub_once = (FUNCNAME##_stub.stub_impl = STUB_FUNC, 1); \
_stub_once; \
_stub_once = 0, FUNCNAME##_stub.stub_impl = NULL)
/* ============================================================================
* Platform-Specific: Real Implementation Lookup
* ============================================================================ */
#ifdef STUB_PLATFORM_UNIX
/* Unix/Linux/macOS: Use dlsym with RTLD_NEXT */
#define STUB_GET_REAL_IMPL(FUNCNAME, FUNC_TYPE) \
static FUNC_TYPE get_real_##FUNCNAME(void) { \
if (FUNCNAME##_stub.real_impl == NULL) { \
FUNCNAME##_stub.real_impl = (FUNC_TYPE)dlsym(RTLD_NEXT, #FUNCNAME); \
} \
return FUNCNAME##_stub.real_impl; \
}
#define STUB_REAL_IMPL_FIELD(FUNC_TYPE) FUNC_TYPE real_impl;
#elif defined(STUB_PLATFORM_WINDOWS)
/* Windows: Placeholder - GetProcAddress-based lookup not yet implemented */
#define STUB_GET_REAL_IMPL(FUNCNAME, FUNC_TYPE) \
static FUNC_TYPE get_real_##FUNCNAME(void) { \
/* TODO: Implement GetProcAddress-based lookup */ \
/* Strategy: Use GetModuleHandle + GetProcAddress to find real impl */ \
/* For now, always return NULL to fall back to default behavior */ \
return NULL; \
}
/* Windows doesn't cache real_impl since lookup is not implemented */
#define STUB_REAL_IMPL_FIELD(FUNC_TYPE) /* No real_impl field on Windows */
#endif
/* ============================================================================
* VOID Function Stubs (0-10 arguments)
* ============================================================================ */
#define STUB_DEFINE_VOID0(FUNCNAME) \
typedef void (*real_##FUNCNAME##_func_t)(void); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
void (*stub_impl)(void); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
void FUNCNAME(void) { \
if (FUNCNAME##_stub.stub_impl) { \
FUNCNAME##_stub.stub_impl(); \
return; \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
real_func(); \
} \
}
#define STUB_DEFINE_VOID1(FUNCNAME, T0) \
typedef void (*real_##FUNCNAME##_func_t)(T0); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
void (*stub_impl)(T0); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
void FUNCNAME(T0 arg0) { \
if (FUNCNAME##_stub.stub_impl) { \
FUNCNAME##_stub.stub_impl(arg0); \
return; \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
real_func(arg0); \
} \
}
#define STUB_DEFINE_VOID2(FUNCNAME, T0, T1) \
typedef void (*real_##FUNCNAME##_func_t)(T0, T1); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
void (*stub_impl)(T0, T1); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
void FUNCNAME(T0 arg0, T1 arg1) { \
if (FUNCNAME##_stub.stub_impl) { \
FUNCNAME##_stub.stub_impl(arg0, arg1); \
return; \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
real_func(arg0, arg1); \
} \
}
#define STUB_DEFINE_VOID3(FUNCNAME, T0, T1, T2) \
typedef void (*real_##FUNCNAME##_func_t)(T0, T1, T2); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
void (*stub_impl)(T0, T1, T2); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
void FUNCNAME(T0 arg0, T1 arg1, T2 arg2) { \
if (FUNCNAME##_stub.stub_impl) { \
FUNCNAME##_stub.stub_impl(arg0, arg1, arg2); \
return; \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
real_func(arg0, arg1, arg2); \
} \
}
#define STUB_DEFINE_VOID4(FUNCNAME, T0, T1, T2, T3) \
typedef void (*real_##FUNCNAME##_func_t)(T0, T1, T2, T3); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
void (*stub_impl)(T0, T1, T2, T3); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
void FUNCNAME(T0 arg0, T1 arg1, T2 arg2, T3 arg3) { \
if (FUNCNAME##_stub.stub_impl) { \
FUNCNAME##_stub.stub_impl(arg0, arg1, arg2, arg3); \
return; \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
real_func(arg0, arg1, arg2, arg3); \
} \
}
#define STUB_DEFINE_VOID5(FUNCNAME, T0, T1, T2, T3, T4) \
typedef void (*real_##FUNCNAME##_func_t)(T0, T1, T2, T3, T4); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
void (*stub_impl)(T0, T1, T2, T3, T4); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
void FUNCNAME(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { \
if (FUNCNAME##_stub.stub_impl) { \
FUNCNAME##_stub.stub_impl(arg0, arg1, arg2, arg3, arg4); \
return; \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
real_func(arg0, arg1, arg2, arg3, arg4); \
} \
}
#define STUB_DEFINE_VOID6(FUNCNAME, T0, T1, T2, T3, T4, T5) \
typedef void (*real_##FUNCNAME##_func_t)(T0, T1, T2, T3, T4, T5); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
void (*stub_impl)(T0, T1, T2, T3, T4, T5); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
void FUNCNAME(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5) { \
if (FUNCNAME##_stub.stub_impl) { \
FUNCNAME##_stub.stub_impl(arg0, arg1, arg2, arg3, arg4, arg5); \
return; \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
real_func(arg0, arg1, arg2, arg3, arg4, arg5); \
} \
}
#define STUB_DEFINE_VOID7(FUNCNAME, T0, T1, T2, T3, T4, T5, T6) \
typedef void (*real_##FUNCNAME##_func_t)(T0, T1, T2, T3, T4, T5, T6); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
void (*stub_impl)(T0, T1, T2, T3, T4, T5, T6); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
void FUNCNAME(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6) { \
if (FUNCNAME##_stub.stub_impl) { \
FUNCNAME##_stub.stub_impl(arg0, arg1, arg2, arg3, arg4, arg5, arg6); \
return; \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
real_func(arg0, arg1, arg2, arg3, arg4, arg5, arg6); \
} \
}
#define STUB_DEFINE_VOID8(FUNCNAME, T0, T1, T2, T3, T4, T5, T6, T7) \
typedef void (*real_##FUNCNAME##_func_t)(T0, T1, T2, T3, T4, T5, T6, T7); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
void (*stub_impl)(T0, T1, T2, T3, T4, T5, T6, T7); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
void FUNCNAME(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7) { \
if (FUNCNAME##_stub.stub_impl) { \
FUNCNAME##_stub.stub_impl(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); \
return; \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
real_func(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); \
} \
}
#define STUB_DEFINE_VOID9(FUNCNAME, T0, T1, T2, T3, T4, T5, T6, T7, T8) \
typedef void (*real_##FUNCNAME##_func_t)(T0, T1, T2, T3, T4, T5, T6, T7, T8); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
void (*stub_impl)(T0, T1, T2, T3, T4, T5, T6, T7, T8); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
void FUNCNAME(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8) { \
if (FUNCNAME##_stub.stub_impl) { \
FUNCNAME##_stub.stub_impl(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); \
return; \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
real_func(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); \
} \
}
#define STUB_DEFINE_VOID10(FUNCNAME, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) \
typedef void (*real_##FUNCNAME##_func_t)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
void (*stub_impl)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
void FUNCNAME(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9) { \
if (FUNCNAME##_stub.stub_impl) { \
FUNCNAME##_stub.stub_impl(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); \
return; \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
real_func(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); \
} \
}
/* ============================================================================
* Return Value Function Stubs (0-10 arguments)
* ============================================================================ */
#define STUB_DEFINE_RET0(RTYPE, FUNCNAME) \
typedef RTYPE (*real_##FUNCNAME##_func_t)(void); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
RTYPE (*stub_impl)(void); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
RTYPE FUNCNAME(void) { \
if (FUNCNAME##_stub.stub_impl) { \
return FUNCNAME##_stub.stub_impl(); \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
return real_func(); \
} \
RTYPE default_ret = {0}; \
return default_ret; \
}
#define STUB_DEFINE_RET1(RTYPE, FUNCNAME, T0) \
typedef RTYPE (*real_##FUNCNAME##_func_t)(T0); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
RTYPE (*stub_impl)(T0); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
RTYPE FUNCNAME(T0 arg0) { \
if (FUNCNAME##_stub.stub_impl) { \
return FUNCNAME##_stub.stub_impl(arg0); \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
return real_func(arg0); \
} \
RTYPE default_ret = {0}; \
return default_ret; \
}
#define STUB_DEFINE_RET2(RTYPE, FUNCNAME, T0, T1) \
typedef RTYPE (*real_##FUNCNAME##_func_t)(T0, T1); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
RTYPE (*stub_impl)(T0, T1); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
RTYPE FUNCNAME(T0 arg0, T1 arg1) { \
if (FUNCNAME##_stub.stub_impl) { \
return FUNCNAME##_stub.stub_impl(arg0, arg1); \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
return real_func(arg0, arg1); \
} \
RTYPE default_ret = {0}; \
return default_ret; \
}
#define STUB_DEFINE_RET3(RTYPE, FUNCNAME, T0, T1, T2) \
typedef RTYPE (*real_##FUNCNAME##_func_t)(T0, T1, T2); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
RTYPE (*stub_impl)(T0, T1, T2); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
RTYPE FUNCNAME(T0 arg0, T1 arg1, T2 arg2) { \
if (FUNCNAME##_stub.stub_impl) { \
return FUNCNAME##_stub.stub_impl(arg0, arg1, arg2); \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
return real_func(arg0, arg1, arg2); \
} \
RTYPE default_ret = {0}; \
return default_ret; \
}
#define STUB_DEFINE_RET4(RTYPE, FUNCNAME, T0, T1, T2, T3) \
typedef RTYPE (*real_##FUNCNAME##_func_t)(T0, T1, T2, T3); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
RTYPE (*stub_impl)(T0, T1, T2, T3); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
RTYPE FUNCNAME(T0 arg0, T1 arg1, T2 arg2, T3 arg3) { \
if (FUNCNAME##_stub.stub_impl) { \
return FUNCNAME##_stub.stub_impl(arg0, arg1, arg2, arg3); \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
return real_func(arg0, arg1, arg2, arg3); \
} \
RTYPE default_ret = {0}; \
return default_ret; \
}
#define STUB_DEFINE_RET5(RTYPE, FUNCNAME, T0, T1, T2, T3, T4) \
typedef RTYPE (*real_##FUNCNAME##_func_t)(T0, T1, T2, T3, T4); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
RTYPE (*stub_impl)(T0, T1, T2, T3, T4); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
RTYPE FUNCNAME(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { \
if (FUNCNAME##_stub.stub_impl) { \
return FUNCNAME##_stub.stub_impl(arg0, arg1, arg2, arg3, arg4); \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
return real_func(arg0, arg1, arg2, arg3, arg4); \
} \
RTYPE default_ret = {0}; \
return default_ret; \
}
#define STUB_DEFINE_RET6(RTYPE, FUNCNAME, T0, T1, T2, T3, T4, T5) \
typedef RTYPE (*real_##FUNCNAME##_func_t)(T0, T1, T2, T3, T4, T5); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
RTYPE (*stub_impl)(T0, T1, T2, T3, T4, T5); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
RTYPE FUNCNAME(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5) { \
if (FUNCNAME##_stub.stub_impl) { \
return FUNCNAME##_stub.stub_impl(arg0, arg1, arg2, arg3, arg4, arg5); \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
return real_func(arg0, arg1, arg2, arg3, arg4, arg5); \
} \
RTYPE default_ret = {0}; \
return default_ret; \
}
#define STUB_DEFINE_RET7(RTYPE, FUNCNAME, T0, T1, T2, T3, T4, T5, T6) \
typedef RTYPE (*real_##FUNCNAME##_func_t)(T0, T1, T2, T3, T4, T5, T6); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
RTYPE (*stub_impl)(T0, T1, T2, T3, T4, T5, T6); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
RTYPE FUNCNAME(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6) { \
if (FUNCNAME##_stub.stub_impl) { \
return FUNCNAME##_stub.stub_impl(arg0, arg1, arg2, arg3, arg4, arg5, arg6); \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
return real_func(arg0, arg1, arg2, arg3, arg4, arg5, arg6); \
} \
RTYPE default_ret = {0}; \
return default_ret; \
}
#define STUB_DEFINE_RET8(RTYPE, FUNCNAME, T0, T1, T2, T3, T4, T5, T6, T7) \
typedef RTYPE (*real_##FUNCNAME##_func_t)(T0, T1, T2, T3, T4, T5, T6, T7); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
RTYPE (*stub_impl)(T0, T1, T2, T3, T4, T5, T6, T7); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
RTYPE FUNCNAME(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7) { \
if (FUNCNAME##_stub.stub_impl) { \
return FUNCNAME##_stub.stub_impl(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
return real_func(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); \
} \
RTYPE default_ret = {0}; \
return default_ret; \
}
#define STUB_DEFINE_RET9(RTYPE, FUNCNAME, T0, T1, T2, T3, T4, T5, T6, T7, T8) \
typedef RTYPE (*real_##FUNCNAME##_func_t)(T0, T1, T2, T3, T4, T5, T6, T7, T8); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
RTYPE (*stub_impl)(T0, T1, T2, T3, T4, T5, T6, T7, T8); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
RTYPE FUNCNAME(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8) { \
if (FUNCNAME##_stub.stub_impl) { \
return FUNCNAME##_stub.stub_impl(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
return real_func(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); \
} \
RTYPE default_ret = {0}; \
return default_ret; \
}
#define STUB_DEFINE_RET10(RTYPE, FUNCNAME, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) \
typedef RTYPE (*real_##FUNCNAME##_func_t)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9); \
typedef struct FUNCNAME##_Stub { \
STUB_COMMON_FIELDS; \
RTYPE (*stub_impl)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9); \
STUB_REAL_IMPL_FIELD(real_##FUNCNAME##_func_t) \
} FUNCNAME##_Stub; \
FUNCNAME##_Stub FUNCNAME##_stub = { \
.stub_target_symbol = #FUNCNAME, \
.stub_impl = NULL, \
}; \
STUB_GET_REAL_IMPL(FUNCNAME, real_##FUNCNAME##_func_t) \
void FUNCNAME##_restore(void) { \
FUNCNAME##_stub.stub_impl = NULL; \
} \
RTYPE FUNCNAME(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9) { \
if (FUNCNAME##_stub.stub_impl) { \
return FUNCNAME##_stub.stub_impl(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); \
} \
real_##FUNCNAME##_func_t real_func = get_real_##FUNCNAME(); \
if (real_func) { \
return real_func(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); \
} \
RTYPE default_ret = {0}; \
return default_ret; \
}
#endif /* STUB_UTILS_H */
| 2401_83913325/openHiTLS_1 | testcode/framework/stub/stub_utils.h | C | unknown | 53,131 |
# 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)
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)
# compile wrapper source directly into test executables use cmake library type INTERFACE
# This ensures REC_Write/REC_Read wrappers can override library symbols on all platforms
add_library(${WRAPPER_LIBNAME} INTERFACE)
target_sources(${WRAPPER_LIBNAME} INTERFACE ${WRAPPER_SRC})
target_link_libraries(${WRAPPER_LIBNAME} INTERFACE TLS_TEST_INTF)
set_target_properties(${HLT_LIBNAME} ${DT_LIBNAME}
PROPERTIES
ARCHIVE_OUTPUT_DIRECTORY "${openHiTLS_SRC}/testcode/output/lib"
)
| 2401_83913325/openHiTLS_1 | testcode/framework/tls/CMakeLists.txt | CMake | unknown | 4,892 |
/*
* 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__ | 2401_83913325/openHiTLS_1 | 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__
| 2401_83913325/openHiTLS_1 | 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);
}
| 2401_83913325/openHiTLS_1 | 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;
}
| 2401_83913325/openHiTLS_1 | 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 | 2401_83913325/openHiTLS_1 | 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;
} | 2401_83913325/openHiTLS_1 | 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
| 2401_83913325/openHiTLS_1 | 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_utils.h"
#include "crypt_default.h"
#ifdef HITLS_TLS_FEATURE_PROVIDER
#include "hitls_crypt.h"
#include "crypt_eal_rand.h"
#endif
/* ============================================================================
* Stub Definitions for HITLS_TLS_FEATURE_PROVIDER
* ============================================================================ */
#ifdef HITLS_TLS_FEATURE_PROVIDER
STUB_DEFINE_RET3(int32_t, CRYPT_EAL_RandbytesEx, CRYPT_EAL_LibCtx *, uint8_t *, uint32_t);
STUB_DEFINE_RET5(HITLS_HMAC_Ctx *, HITLS_CRYPT_HMAC_Init, HITLS_Lib_Ctx *, const char *, HITLS_HashAlgo, const uint8_t *, uint32_t);
STUB_DEFINE_RET9(int32_t, HITLS_CRYPT_HMAC, HITLS_Lib_Ctx *, const char *, HITLS_HashAlgo, const uint8_t *, uint32_t, const uint8_t *, uint32_t, uint8_t *, uint32_t *);
STUB_DEFINE_RET3(HITLS_HASH_Ctx *, HITLS_CRYPT_DigestInit, HITLS_Lib_Ctx *, const char *, HITLS_HashAlgo);
STUB_DEFINE_RET7(int32_t, HITLS_CRYPT_Digest, HITLS_Lib_Ctx *, const char *, HITLS_HashAlgo, const uint8_t *, uint32_t, uint8_t *, uint32_t *);
STUB_DEFINE_RET7(int32_t, HITLS_CRYPT_Encrypt, HITLS_Lib_Ctx *, const char *, const HITLS_CipherParameters *, const uint8_t *, uint32_t, uint8_t *, uint32_t *);
STUB_DEFINE_RET7(int32_t, HITLS_CRYPT_Decrypt, HITLS_Lib_Ctx *, const char *, const HITLS_CipherParameters *, const uint8_t *, uint32_t, uint8_t *, uint32_t *);
STUB_DEFINE_RET4(void *, HITLS_CRYPT_GenerateEcdhKey, void *, const char *, const HITLS_Config *, const HITLS_ECParameters *);
STUB_DEFINE_RET7(int32_t, HITLS_CRYPT_EcdhCalcSharedSecret, HITLS_Lib_Ctx *, const char *, HITLS_CRYPT_Key *, uint8_t *, uint32_t, uint8_t *, uint32_t *);
STUB_DEFINE_RET6(HITLS_CRYPT_Key *, HITLS_CRYPT_GenerateDhKeyByParameters, HITLS_Lib_Ctx *, const char *, uint8_t *, uint16_t, uint8_t *, uint16_t);
STUB_DEFINE_RET4(HITLS_CRYPT_Key *, HITLS_CRYPT_GenerateDhKeyBySecbits, HITLS_Lib_Ctx *, const char *, const HITLS_Config *, int32_t);
#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(CRYPT_EAL_LibCtx *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(HITLS_Ctx *ctx, 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(&ctx->config.tlsConfig, 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(NULL, 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(HITLS_Lib_Ctx *libCtx, const char *attrName,
const HITLS_Config *tlsConfig, int32_t secbits)
{
(void)libCtx;
(void)attrName;
(void)tlsConfig;
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(HITLS_Lib_Ctx *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);
}
void FRAME_RegCryptMethod(void)
{
#ifndef HITLS_TLS_FEATURE_PROVIDER
HITLS_CRYPT_BaseMethod cryptMethod = { 0 };
cryptMethod.randBytes = (CRYPT_RandBytesCallback)STUB_CRYPT_RandBytesCallback;
cryptMethod.hmacSize = (CRYPT_HmacSizeCallback)STUB_CRYPT_HmacSizeCallback;
cryptMethod.hmacInit = (CRYPT_HmacInitCallback)STUB_CRYPT_HmacInitCallback;
cryptMethod.hmacFree = (CRYPT_HmacFreeCallback)STUB_CRYPT_HmacFreeCallback;
cryptMethod.hmacUpdate = (CRYPT_HmacUpdateCallback)STUB_CRYPT_HmacUpdateCallback;
cryptMethod.hmacFinal = (CRYPT_HmacFinalCallback)STUB_CRYPT_HmacFinalCallback;
cryptMethod.hmac = (CRYPT_HmacCallback)STUB_CRYPT_HmacCallback;
cryptMethod.digestSize = (CRYPT_DigestSizeCallback)STUB_CRYPT_DigestSizeCallback;
cryptMethod.digestInit = (CRYPT_DigestInitCallback)STUB_CRYPT_DigestInitCallback;
cryptMethod.digestCopy = (CRYPT_DigestCopyCallback)STUB_CRYPT_DigestCopyCallback;
cryptMethod.digestFree = (CRYPT_DigestFreeCallback)CRYPT_DEFAULT_DigestFree;
cryptMethod.digestUpdate = (CRYPT_DigestUpdateCallback)STUB_CRYPT_DigestUpdateCallback;
cryptMethod.digestFinal = (CRYPT_DigestFinalCallback)STUB_CRYPT_DigestFinalCallback;
cryptMethod.digest = (CRYPT_DigestCallback)STUB_CRYPT_DigestCallback;
cryptMethod.encrypt = (CRYPT_EncryptCallback)STUB_CRYPT_EncryptCallback;
cryptMethod.decrypt = (CRYPT_DecryptCallback)STUB_CRYPT_DecryptCallback;
cryptMethod.cipherFree = (CRYPT_CipherFreeCallback)CRYPT_DEFAULT_CipherFree;
HITLS_CRYPT_RegisterBaseMethod(&cryptMethod);
HITLS_CRYPT_EcdhMethod ecdhMethod = { 0 };
ecdhMethod.generateEcdhKeyPair = (CRYPT_GenerateEcdhKeyPairCallback)STUB_CRYPT_GenerateEcdhKeyPairCallback;
ecdhMethod.freeEcdhKey = (CRYPT_FreeEcdhKeyCallback)CRYPT_DEFAULT_FreeKey;
ecdhMethod.getEcdhPubKey = (CRYPT_GetEcdhEncodedPubKeyCallback)STUB_CRYPT_GetEcdhEncodedPubKeyCallback;
ecdhMethod.calcEcdhSharedSecret = (CRYPT_CalcEcdhSharedSecretCallback)STUB_CRYPT_CalcEcdhSharedSecretCallback;
HITLS_CRYPT_RegisterEcdhMethod(&ecdhMethod);
HITLS_CRYPT_DhMethod dhMethod = { 0 };
dhMethod.generateDhKeyBySecbits = (CRYPT_GenerateDhKeyBySecbitsCallback)STUB_CRYPT_GenerateDhKeyBySecbitsCallback;
dhMethod.generateDhKeyByParams = (CRYPT_GenerateDhKeyByParamsCallback)STUB_CRYPT_GenerateDhKeyByParamsCallback;
dhMethod.freeDhKey = (CRYPT_FreeDhKeyCallback)CRYPT_DEFAULT_FreeKey;
dhMethod.getDhParameters = (CRYPT_DHGetParametersCallback)STUB_CRYPT_DHGetParametersCallback;
dhMethod.getDhPubKey = (CRYPT_GetDhEncodedPubKeyCallback)STUB_CRYPT_GetDhEncodedPubKeyCallback;
dhMethod.calcDhSharedSecret = (CRYPT_CalcDhSharedSecretCallback)STUB_CRYPT_CalcDhSharedSecretCallback;
HITLS_CRYPT_RegisterDhMethod(&dhMethod);
#else
STUB_REPLACE(CRYPT_EAL_RandbytesEx, STUB_CRYPT_RandBytesCallbackLibCtx);
STUB_REPLACE(HITLS_CRYPT_HMAC_Init, STUB_CRYPT_HmacInitCallbackLibCtx);
STUB_REPLACE(HITLS_CRYPT_HMAC, STUB_CRYPT_HmacCallbackLibCtx);
STUB_REPLACE(HITLS_CRYPT_DigestInit, STUB_CRYPT_DigestInitCallbackLibCtx);
STUB_REPLACE(HITLS_CRYPT_Digest, STUB_CRYPT_DigestCallbackLibCtx);
STUB_REPLACE(HITLS_CRYPT_Encrypt, STUB_CRYPT_EncryptCallbackLibCtx);
STUB_REPLACE(HITLS_CRYPT_Decrypt, STUB_CRYPT_DecryptCallbackLibCtx);
STUB_REPLACE(HITLS_CRYPT_GenerateEcdhKey, STUB_CRYPT_GenerateEcdhKeyPairCallbackLibCtx);
STUB_REPLACE(HITLS_CRYPT_EcdhCalcSharedSecret, STUB_CRYPT_CalcEcdhSharedSecretCallbackLibCtx);
STUB_REPLACE(HITLS_CRYPT_GenerateDhKeyByParameters, STUB_CRYPT_GenerateDhKeyByParamsCallbackLibCtx);
STUB_REPLACE(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_RESTORE(CRYPT_EAL_RandbytesEx);
STUB_RESTORE(HITLS_CRYPT_HMAC_Init);
STUB_RESTORE(HITLS_CRYPT_HMAC);
STUB_RESTORE(HITLS_CRYPT_DigestInit);
STUB_RESTORE(HITLS_CRYPT_Digest);
STUB_RESTORE(HITLS_CRYPT_Encrypt);
STUB_RESTORE(HITLS_CRYPT_Decrypt);
STUB_RESTORE(HITLS_CRYPT_GenerateEcdhKey);
STUB_RESTORE(HITLS_CRYPT_EcdhCalcSharedSecret);
STUB_RESTORE(HITLS_CRYPT_GenerateDhKeyByParameters);
STUB_RESTORE(HITLS_CRYPT_GenerateDhKeyBySecbits);
#endif
return;
} | 2401_83913325/openHiTLS_1 | testcode/framework/tls/crypt/src/stub_crypt.c | C | unknown | 29,679 |
/*
* 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_utils.h"
/* Stub definitions - works with dynamic linking (.dylib/.so)
* With shared libraries, dlsym(RTLD_NEXT) can find the real implementation at runtime
* NOTE: STUB mechanism disabled for macOS static linking compatibility
* Using direct state polling approach instead (see FRAME_CreateConnection)
*/
STUB_DEFINE_RET2(int32_t, HS_ChangeState, TLS_Ctx *, uint32_t);
#include "frame_tls.h"
#include "frame_io.h"
#include "frame_link.h"
#include "parse.h"
#include "rec_wrapper.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 ||
link->ssl->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11 ||
#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;
}
// Apply registered wrappers EARLY - before first HITLS_Connect/Accept
// This initializes recCtx and installs wrappers before handshake begins
// Matches HLT framework pattern in hlt_func.c:LocalProcessTlsInit
ApplyWrapperToConnectionEarly(client->ssl);
ApplyWrapperToConnectionEarly(server->ssl);
g_isClient = isClient;
g_nextState = state;
STUB_REPLACE(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_RESTORE(HS_ChangeState);
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;
STUB_REPLACE(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_RESTORE(HS_ChangeState);
return ret;
} | 2401_83913325/openHiTLS_1 | testcode/framework/tls/frame/src/frame_connect.c | C | unknown | 14,903 |
/*
* 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;
} | 2401_83913325/openHiTLS_1 | 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"
#include "rec_wrapper.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;
// Register connection for late wrapper application
// This enables RegisterWrapper to apply wrappers to connections
// that were created before the wrapper was registered
RegisterConnection(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);
}
FRAME_LinkObj *FRAME_CreateLinkWithCerts(HITLS_Config *config, BSL_UIO_TransportType type, const FRAME_CertInfo* certInfo, size_t certInfoLen)
{
#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;
for (size_t i = 0; i < certInfoLen; i++) {
ret = HiTLS_X509_LoadCertAndKey(config,
certInfo[i].caFile,
certInfo[i].chainFile,
certInfo[i].endEquipmentFile,
certInfo[i].signFile,
certInfo[i].privKeyFile,
certInfo[i].signPrivKeyFile);
if (ret != HITLS_SUCCESS) {
return NULL;
}
}
return CreateLink(config, type);
}
void FRAME_FreeLink(FRAME_LinkObj *linkObj)
{
if (linkObj == NULL) {
return;
}
// Unregister connection from global tracking before freeing
if (linkObj->ssl != NULL) {
UnregisterConnection(linkObj->ssl);
RemoveWrapperFromConnection(linkObj->ssl);
}
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;
}
| 2401_83913325/openHiTLS_1 | testcode/framework/tls/frame/src/frame_link.c | C | unknown | 10,264 |
/*
* 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
| 2401_83913325/openHiTLS_1 | 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;
} | 2401_83913325/openHiTLS_1 | 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);
// Apply registered wrapper to a specific TLS connection
// Called internally by HLT framework after creating each connection
void ApplyWrapperToConnection(TLS_Ctx *ctx);
// Early wrapper application - initializes recCtx if needed before first HITLS_Connect
// This solves the timing issue: wrapper applied BEFORE ClientHello is sent
void ApplyWrapperToConnectionEarly(TLS_Ctx *ctx);
// Remove wrapper from a specific TLS connection
// Called when connection is destroyed to clean up resources
void RemoveWrapperFromConnection(TLS_Ctx *ctx);
// Register a connection for late wrapper application
// Called by FRAME_CreateLink to enable RegisterWrapper to apply to existing connections
void RegisterConnection(TLS_Ctx *ctx);
// Unregister a connection from tracking
// Called by FRAME_FreeLink during cleanup
void UnregisterConnection(TLS_Ctx *ctx);
// Check if wrapper is currently enabled
// Returns true if RegisterWrapper has been called and wrapper is active
bool IsWrapperEnabled(void);
// Clear connection tracking list - called during test cleanup to prevent state leakage
// This should be called by HLT_FreeAllProcess() to clear connections between tests
void ClearConnectionList(void);
#ifdef __cplusplus
}
#endif
#endif // REC_WRAPPER_H | 2401_83913325/openHiTLS_1 | testcode/framework/tls/func_wrapper/include/rec_wrapper.h | C | unknown | 2,518 |
/*
* 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 "hs_ctx.h"
#include "bsl_sal.h"
#include "record.h" // Include official RecCtx definition
#include "rec.h" // REC_Init API
#include "rec_wrapper.h"
#include "rec_crypto.h" // For read wrapper support via STUB
#include "stub_utils.h" // For STUB mechanism (new framework)
#include <pthread.h>
#define MAX_BUF 16384
#define MAX_CONNECTIONS 1024
// Define stub for RecGetCryptoFuncs using new framework
// Signature: const RecCryptoFunc *RecGetCryptoFuncs(const RecConnSuitInfo *suiteInfo)
STUB_DEFINE_RET1(const RecCryptoFunc *, RecGetCryptoFuncs, const RecConnSuitInfo *);
// Global wrapper configuration (set by RegisterWrapper)
// Note: g_recWrapper.func == NULL indicates no active wrapper
static RecWrapper g_recWrapper;
static bool g_enableWrapper = false; // Enable flag for STUB-based wrappers
// STUB-based read wrapper support - crypto function caches
RecCryptoFunc g_aeadFuncs;
RecCryptoFunc g_cbcFuncs;
RecCryptoFunc g_plainFuncs;
// Per-connection wrapper context
typedef struct {
RecWrapper config;
REC_WriteFunc originalRecWrite; // Use official REC_WriteFunc type
bool enabled;
} WrapperContext;
// Global mapping table: TLS_Ctx* -> WrapperContext*
typedef struct {
TLS_Ctx *ctx;
WrapperContext *wrapper;
} CtxWrapperMapping;
static CtxWrapperMapping g_ctxMappings[MAX_CONNECTIONS];
static int g_mappingCount = 0;
static pthread_mutex_t g_mappingMutex = PTHREAD_MUTEX_INITIALIZER;
// Global connection tracking list (for late wrapper application)
static TLS_Ctx *g_allConnections[MAX_CONNECTIONS];
static int g_connectionCount = 0;
static pthread_mutex_t g_connectionMutex = PTHREAD_MUTEX_INITIALIZER;
// Helper functions for context mapping
static WrapperContext *GetWrapperContext(TLS_Ctx *ctx)
{
pthread_mutex_lock(&g_mappingMutex);
for (int i = 0; i < g_mappingCount; i++) {
if (g_ctxMappings[i].ctx == ctx) {
WrapperContext *result = g_ctxMappings[i].wrapper;
pthread_mutex_unlock(&g_mappingMutex);
return result;
}
}
pthread_mutex_unlock(&g_mappingMutex);
return NULL;
}
static void SetWrapperContext(TLS_Ctx *ctx, WrapperContext *wrapper)
{
pthread_mutex_lock(&g_mappingMutex);
// Check if already exists
for (int i = 0; i < g_mappingCount; i++) {
if (g_ctxMappings[i].ctx == ctx) {
g_ctxMappings[i].wrapper = wrapper;
pthread_mutex_unlock(&g_mappingMutex);
return;
}
}
// Add new mapping
if (g_mappingCount < MAX_CONNECTIONS) {
g_ctxMappings[g_mappingCount].ctx = ctx;
g_ctxMappings[g_mappingCount].wrapper = wrapper;
g_mappingCount++;
}
pthread_mutex_unlock(&g_mappingMutex);
}
static void RemoveWrapperContext(TLS_Ctx *ctx)
{
pthread_mutex_lock(&g_mappingMutex);
for (int i = 0; i < g_mappingCount; i++) {
if (g_ctxMappings[i].ctx == ctx) {
// Free wrapper context
if (g_ctxMappings[i].wrapper != NULL) {
BSL_SAL_Free(g_ctxMappings[i].wrapper);
}
// Shift remaining mappings
for (int j = i; j < g_mappingCount - 1; j++) {
g_ctxMappings[j] = g_ctxMappings[j + 1];
}
g_mappingCount--;
break;
}
}
pthread_mutex_unlock(&g_mappingMutex);
}
// Function pointer wrapper that intercepts REC_Write calls
static int32_t WrapperRecWrite(TLS_Ctx *ctx, REC_Type recordType, const uint8_t *data, uint32_t num)
{
if (ctx == NULL || ctx->recCtx == NULL) {
return HITLS_NULL_INPUT;
}
// Get wrapper context from global mapping table
WrapperContext *wctx = GetWrapperContext(ctx);
if (wctx == NULL) {
return HITLS_INTERNAL_EXCEPTION;
}
if (!wctx->enabled) {
return HITLS_INTERNAL_EXCEPTION;
}
RecWrapper *wrapper = &wctx->config;
REC_WriteFunc originalFunc = wctx->originalRecWrite;
// Check if wrapper applies to this record type
if (wrapper->isRecRead || wrapper->recordType != recordType) {
return originalFunc(ctx, recordType, data, num);
}
// Check handshake state if this is a handshake record
if (wrapper->recordType == REC_TYPE_HANDSHAKE) {
if (ctx->hsCtx == NULL) {
return originalFunc(ctx, recordType, data, num);
}
if (ctx->hsCtx->state != wrapper->ctrlState) {
return originalFunc(ctx, recordType, data, num);
}
}
// Apply message modification
uint8_t locBuffer[MAX_BUF];
uint32_t manipulateLen = num;
(void)memcpy_s(locBuffer, MAX_BUF, data, num);
wrapper->func(ctx, locBuffer, &manipulateLen, MAX_BUF, wrapper->userData);
// Reallocate buffer if needed
if (recordType == REC_TYPE_HANDSHAKE && 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;
}
// Update handshake context
if (recordType == REC_TYPE_HANDSHAKE) {
(void)memcpy_s(ctx->hsCtx->msgBuf, ctx->hsCtx->bufferLen, locBuffer, manipulateLen);
ctx->hsCtx->msgLen = manipulateLen;
}
// Temporarily restore original recWrite to prevent recursion
// But calling REC_Write() with wrapper still installed would cause infinite recursion
// because REC_Write internally calls ctx->recCtx->recWrite (which is WrapperRecWrite)
ctx->recCtx->recWrite = originalFunc;
// Call REC_Write by symbol to honor STUB_REPLACE from callbacks
int32_t ret = REC_Write(ctx, recordType, locBuffer, manipulateLen);
// Restore wrapper
ctx->recCtx->recWrite = WrapperRecWrite;
if (recordType == REC_TYPE_HANDSHAKE && ret == HITLS_SUCCESS) {
ctx->hsCtx->msgOffset = manipulateLen - num;
}
return ret;
}
// Internal function to apply wrapper to a specific connection
// This is called by the HLT framework after creating each connection
void ApplyWrapperToConnection(TLS_Ctx *ctx)
{
if (ctx == NULL || ctx->recCtx == NULL || g_recWrapper.func == NULL) {
return;
}
RecCtx *recCtx = ctx->recCtx; // Use official RecCtx type
// Check if wrapper already applied
WrapperContext *existingWrapper = GetWrapperContext(ctx);
if (existingWrapper != NULL) {
return;
}
// Allocate wrapper context
WrapperContext *wctx = (WrapperContext *)BSL_SAL_Calloc(1, sizeof(WrapperContext));
if (wctx == NULL) {
return;
}
// Store configuration and original function pointer
wctx->config = g_recWrapper;
wctx->originalRecWrite = recCtx->recWrite;
wctx->enabled = true;
// Add to mapping table
SetWrapperContext(ctx, wctx);
// Install wrapper function pointer
recCtx->recWrite = WrapperRecWrite;
}
// Early wrapper application - initializes recCtx if needed
// This solves the timing issue: wrapper must be applied BEFORE first HITLS_Connect
void ApplyWrapperToConnectionEarly(TLS_Ctx *ctx)
{
if (ctx == NULL || g_recWrapper.func == NULL) {
return;
}
// If recCtx not yet initialized, initialize it now
if (ctx->recCtx == NULL) {
int32_t ret = REC_Init(ctx);
if (ret != HITLS_SUCCESS) {
return;
}
}
// Now recCtx is guaranteed to be initialized, apply wrapper
ApplyWrapperToConnection(ctx);
}
// Internal function to remove wrapper from a connection
void RemoveWrapperFromConnection(TLS_Ctx *ctx)
{
if (ctx == NULL || ctx->recCtx == NULL) {
return;
}
RecCtx *recCtx = ctx->recCtx; // Use official RecCtx type
WrapperContext *wctx = GetWrapperContext(ctx);
if (wctx == NULL) {
return;
}
// Restore original function pointer
recCtx->recWrite = wctx->originalRecWrite;
// Remove from mapping table (also frees wctx)
RemoveWrapperContext(ctx);
}
// Check if wrapper is enabled
bool IsWrapperEnabled(void)
{
return g_recWrapper.func != NULL;
}
// Connection tracking functions
void RegisterConnection(TLS_Ctx *ctx)
{
pthread_mutex_lock(&g_connectionMutex);
// Prevent duplicate registration
for (int i = 0; i < g_connectionCount; i++) {
if (g_allConnections[i] == ctx) {
pthread_mutex_unlock(&g_connectionMutex);
return;
}
}
// Add to global tracking list
if (g_connectionCount < MAX_CONNECTIONS) {
g_allConnections[g_connectionCount] = ctx;
g_connectionCount++;
}
pthread_mutex_unlock(&g_connectionMutex);
}
void UnregisterConnection(TLS_Ctx *ctx)
{
pthread_mutex_lock(&g_connectionMutex);
// Remove from list (compact array)
for (int i = 0; i < g_connectionCount; i++) {
if (g_allConnections[i] == ctx) {
for (int j = i; j < g_connectionCount - 1; j++) {
g_allConnections[j] = g_allConnections[j + 1];
}
g_connectionCount--;
break;
}
}
pthread_mutex_unlock(&g_connectionMutex);
}
// ============================================================================
// STUB-based Read Wrapper Support
// ============================================================================
// Initialize crypto function tables for STUB mechanism
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);
}
// Get original crypto functions based on suite info
static RecCryptoFunc *RecGetOriginCryptFuncs(const 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;
}
// Wrapper for decrypt function - intercepts incoming messages during decryption
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);
// FIXED: Removed IS_SUPPORT_DATAGRAM check to support TLS (not just DTLS)
if (ret == HITLS_SUCCESS && g_enableWrapper && 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;
}
// Wrapper for decrypt post-process - additional message modification point
static int32_t WrapperDecryptPostProcess(TLS_Ctx *ctx, RecConnSuitInfo *suitInfo, REC_TextInput *cryptMsg,
uint8_t *data, uint32_t *dataLen)
{
int32_t ret = RecGetOriginCryptFuncs((const RecConnSuitInfo *)suitInfo)->decryptPostProcess(ctx, suitInfo, cryptMsg, data, dataLen);
// No DTLS restriction here - supports both TLS and DTLS
if (ret == HITLS_SUCCESS && g_enableWrapper && 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;
}
// Wrapper for plaintext buffer length calculation
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;
}
// STUB replacement for RecGetCryptoFuncs - returns modified function table
static const RecCryptoFunc *Stub_RecCrypto(const RecConnSuitInfo *suiteInfo)
{
static RecCryptoFunc recCryptoFunc = { 0 };
recCryptoFunc = *RecGetOriginCryptFuncs(suiteInfo);
recCryptoFunc.calPlantextBufLen = WrapperCalPlantextBufLenFunc;
recCryptoFunc.decrypt = WrapperDecryptFunc;
recCryptoFunc.decryptPostProcess = WrapperDecryptPostProcess;
return &recCryptoFunc;
}
// ============================================================================
// Framework API
// ============================================================================
void RegisterWrapper(RecWrapper wrapper)
{
// If there's already an active wrapper, clear it first
if (g_recWrapper.func != NULL) {
ClearWrapper();
}
// Store wrapper configuration globally
g_recWrapper = wrapper;
// Choose mechanism based on wrapper type
if (wrapper.isRecRead) {
// READ wrappers: Use STUB mechanism to intercept decrypt functions
FRAME_InitRecCrypto();
STUB_REPLACE(RecGetCryptoFuncs, Stub_RecCrypto); // New framework API
g_enableWrapper = true;
} else {
// WRITE wrappers: Use function pointer replacement
// Apply to all existing connections (enables late registration)
pthread_mutex_lock(&g_connectionMutex);
for (int i = 0; i < g_connectionCount; i++) {
ApplyWrapperToConnectionEarly(g_allConnections[i]);
}
pthread_mutex_unlock(&g_connectionMutex);
}
}
void ClearWrapper(void)
{
// Reset STUB mechanism (if active for read wrappers)
if (g_enableWrapper) {
STUB_RESTORE(RecGetCryptoFuncs);
g_enableWrapper = false;
}
// Clear all per-connection wrapper contexts from mapping table
pthread_mutex_lock(&g_mappingMutex);
for (int i = 0; i < g_mappingCount; i++) {
if (g_ctxMappings[i].wrapper != NULL) {
// Restore original function pointer if recCtx still exists
if (g_ctxMappings[i].ctx != NULL && g_ctxMappings[i].ctx->recCtx != NULL) {
g_ctxMappings[i].ctx->recCtx->recWrite = g_ctxMappings[i].wrapper->originalRecWrite;
}
// Free wrapper context
BSL_SAL_Free(g_ctxMappings[i].wrapper);
g_ctxMappings[i].wrapper = NULL;
}
}
g_mappingCount = 0;
pthread_mutex_unlock(&g_mappingMutex);
// Clear global wrapper configuration (sets func to NULL)
(void)memset(&g_recWrapper, 0, sizeof(RecWrapper));
}
void ClearConnectionList(void)
{
// Clear the connection tracking list to prevent state leakage between tests
pthread_mutex_lock(&g_connectionMutex);
g_connectionCount = 0;
(void)memset(g_allConnections, 0, sizeof(g_allConnections));
pthread_mutex_unlock(&g_connectionMutex);
}
| 2401_83913325/openHiTLS_1 | testcode/framework/tls/func_wrapper/src/rec_wrapper.c | C | unknown | 15,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 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 | 2401_83913325/openHiTLS_1 | 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);
FRAME_LinkObj *FRAME_CreateLinkWithCerts(HITLS_Config *config, BSL_UIO_TransportType type,
const FRAME_CertInfo* certInfo, size_t certInfoLen);
/**
* @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
| 2401_83913325/openHiTLS_1 | testcode/framework/tls/include/frame_tls.h | C | unknown | 6,871 |
/*
* 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_SetDtlsCookieExchangeSupport(HLT_Ctx_Config *ctxConfig, bool isSupport);
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);
pthread_t HLT_TlsListen(void *ssl);
pthread_t HLT_TlsAccept(void* ssl);
int HLT_TlsListenBlock(void* ssl);
int HLT_TlsAcceptBlock(void* ssl);
int HLT_GetTlsAcceptResultFromId(pthread_t 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 | 2401_83913325/openHiTLS_1 | testcode/framework/tls/include/hlt.h | C | unknown | 10,279 |
/*
* 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 <pthread.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.
bool isSupportDtlsCookieExchange;
} 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;
pthread_t 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
| 2401_83913325/openHiTLS_1 | testcode/framework/tls/include/hlt_type.h | C | unknown | 12,435 |
/*
* 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
| 2401_83913325/openHiTLS_1 | 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
| 2401_83913325/openHiTLS_1 | 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 | 2401_83913325/openHiTLS_1 | 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 | 2401_83913325/openHiTLS_1 | 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
| 2401_83913325/openHiTLS_1 | 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;
}
| 2401_83913325/openHiTLS_1 | 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;
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;
} | 2401_83913325/openHiTLS_1 | testcode/framework/tls/msg/src/frame_pack_msg.c | C | unknown | 55,196 |
/*
* 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));
} | 2401_83913325/openHiTLS_1 | 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;
} | 2401_83913325/openHiTLS_1 | 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);
}
| 2401_83913325/openHiTLS_1 | 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 | 2401_83913325/openHiTLS_1 | 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 | 2401_83913325/openHiTLS_1 | 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);
ctxConfig->isSupportDtlsCookieExchange = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx CookieExchange is %d", ctxConfig->isSupportDtlsCookieExchange);
// 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;
}
| 2401_83913325/openHiTLS_1 | testcode/framework/tls/process/src/handle_cmd.c | C | unknown | 18,995 |
/*
* 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;
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return;
}
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;
}
/* Allocate CmdData on heap to avoid stack overflow (2MB is too large for stack) */
CmdData *cmdData = (CmdData *)calloc(1, sizeof(CmdData));
if (cmdData == NULL) {
LOG_ERROR("Failed to allocate CmdData");
free(dataBuf);
return;
}
ret = ParseCmdFromStr(dataBuf->data, cmdData);
index = (int)strtol(cmdData->id, &endPtr, 0) % MAX_RCV_BUFFER_NUM;
ret = PushResultToChannelIdBuffer(channelInfo, dataBuf->data, index);
free(cmdData);
if (ret != SUCCESS) {
LOG_ERROR("PushResultToChannelRcvBuffer Error");
free(dataBuf);
return;
}
LOG_DEBUG("Local Process Rcv is %s", dataBuf->data);
} else {
LOG_ERROR("FD_ISSET Error");
}
}
free(dataBuf);
}
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;
}
| 2401_83913325/openHiTLS_1 | testcode/framework/tls/process/src/process.c | C | unknown | 13,268 |
/*
* 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
| 2401_83913325/openHiTLS_1 | 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
| 2401_83913325/openHiTLS_1 | 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;
}
| 2401_83913325/openHiTLS_1 | 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;
} | 2401_83913325/openHiTLS_1 | 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 | 2401_83913325/openHiTLS_1 | 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
| 2401_83913325/openHiTLS_1 | 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
| 2401_83913325/openHiTLS_1 | 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 <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;
}
| 2401_83913325/openHiTLS_1 | testcode/framework/tls/rpc/src/common_func.c | C | unknown | 12,083 |
/*
* 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"
#include "rec_wrapper.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},
{"HITLS_SM4_GCM_SM3", HITLS_SM4_GCM_SM3},
{"HITLS_SM4_CCM_SM3", HITLS_SM4_CCM_SM3},
/* 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_CONFIG_VERSION
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
// 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");
}
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, 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
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
LOG_DEBUG("HiTLS Set Dtls Cookie Support is %d", inCtxCfg->isSupportDtlsCookieExchange);
ret = HITLS_CFG_SetDtlsCookieExchangeSupport(outCfg, (uint32_t)inCtxCfg->isSupportDtlsCookieExchange);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetDtlsCookieExchangeSupport 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"));
}
// Apply wrapper if enabled before handshake
// This handles the case where RegisterWrapper() was called before connection creation
if (IsWrapperEnabled()) {
ApplyWrapperToConnectionEarly((TLS_Ctx *)ssl);
}
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)
{
bool isReused = false;
(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);
} | 2401_83913325/openHiTLS_1 | testcode/framework/tls/rpc/src/hitls_func.c | C | unknown | 43,006 |
/*
* 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"
#include "rec_wrapper.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
pthread_t HLT_TlsListen(void *ssl)
{
(void)ssl;
Process *process = GetProcess();
switch (process->tlsType) {
case HITLS : {
return 0; // Hitls does not support the listen function.
}
default:
return 0;
}
}
// 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
pthread_t HLT_TlsAccept(void *ssl)
{
(void)ssl;
int ret;
Process *process = GetProcess();
pthread_t t_id;
switch (process->tlsType) {
case HITLS :
ret = pthread_create(&t_id, NULL, (void*)HitlsAccept, (void*)ssl);
break;
default:
return 0;
}
if (ret != 0) {
return 0;
}
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(pthread_t 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.
// acceptId stores RPC command ID (int) cast to pthread_t, cast it back
ret = HLT_RpcGetTlsAcceptResult((int)(uintptr_t)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();
// For local connections, register connection for wrapper tracking
if (process->remoteFlag == 0) {
RegisterConnection((TLS_Ctx *)ssl);
// If wrapper already enabled, apply it now
if (IsWrapperEnabled()) {
ApplyWrapperToConnectionEarly((TLS_Ctx *)ssl);
}
}
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;
pthread_t 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(1u, sizeof(HLT_Ctx_Config));
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 = HITLS_SESS_CACHE_SERVER;
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 wrapper state BEFORE freeing SSL objects to prevent use-after-free
ClearWrapper();
// 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();
// Clear connection tracking list to prevent state leakage between tests
ClearConnectionList();
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.
// Register connection for wrapper tracking
RegisterConnection((TLS_Ctx *)ssl);
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)
{
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) {
pthread_t acceptId = HLT_TlsAccept(tlsRes->ssl);
if (acceptId == 0) {
LOG_ERROR("HLT_TlsAccept ERROR");
return NULL;
}
tlsRes->acceptId = acceptId;
} else {
int rpcAcceptId = HLT_RpcTlsAccept(process, tlsRes->sslId);
if (rpcAcceptId == ERROR) {
LOG_ERROR("HLT_TlsAccept ERROR");
return NULL;
}
// Store RPC command ID in acceptId (safe to cast int to pthread_t for storage)
tlsRes->acceptId = (pthread_t)(uintptr_t)rpcAcceptId;
}
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_SetDtlsCookieExchangeSupport(HLT_Ctx_Config *ctxConfig, bool isSupport)
{
ctxConfig->isSupportDtlsCookieExchange = isSupport;
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");
}
| 2401_83913325/openHiTLS_1 | testcode/framework/tls/rpc/src/hlt_func.c | C | unknown | 42,041 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#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};
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
uint32_t offset = 0;
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcTlsNewCtx");
goto cleanup;
}
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf->data, sizeof(dataBuf->data),
"%llu|%s|%d|%d|",
g_cmdIndex, __FUNCTION__, tlsVersion, isClient);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
offset += ret;
if (providerCnt == 0 || providerNames == NULL || providerLibFmts == NULL) {
ret = sprintf_s(dataBuf->data + offset, sizeof(dataBuf->data) - offset, "|");
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
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]);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
offset += ret;
}
if (providerCnt >= 1) {
ret = sprintf_s(dataBuf->data + offset, sizeof(dataBuf->data) - offset, "%s,%d|", providerNames[providerCnt - 1],
providerLibFmts[providerCnt - 1]);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
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, "|");
}
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
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, "|");
}
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
offset += ret;
dataBuf->dataLen = strlen(dataBuf->data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (!(ret == SUCCESS)) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = atoi(expectCmdData.paras[0]);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
int HLT_RpcTlsNewCtx(HLT_Process *peerProcess, TLS_VERSION tlsVersion, bool isClient)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcTlsNewCtx");
goto cleanup;
}
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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (!(ret == SUCCESS)) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = atoi(expectCmdData.paras[0]);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
int HLT_RpcTlsSetCtx(HLT_Process *peerProcess, int ctxId, HLT_Ctx_Config *config)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcTlsSetCtx");
goto cleanup;
}
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|%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->isSupportDtlsCookieExchange, config->attrName);
dataBuf->dataLen = strlen(dataBuf->data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Wait to receive the result.
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (!(ret == SUCCESS)) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = atoi(expectCmdData.paras[0]);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
int HLT_RpcTlsNewSsl(HLT_Process *peerProcess, int ctxId)
{
int ret;
uint64_t cmdIndex;
CmdData expectCmdData = {0};
Process *srcProcess = NULL;
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcTlsNewSsl");
goto cleanup;
}
// 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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Wait to receive the result.
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (!(ret == SUCCESS)) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = atoi(expectCmdData.paras[0]);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
int HLT_RpcTlsSetSsl(HLT_Process *peerProcess, int sslId, HLT_Ssl_Config *config)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcTlsSetSsl");
goto cleanup;
}
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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Wait to receive the result.
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (!(ret == SUCCESS)) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = atoi(expectCmdData.paras[0]);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
int HLT_RpcTlsListen(HLT_Process *peerProcess, int sslId)
{
int ret;
uint64_t acceptId;
Process *srcProcess = NULL;
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
srcProcess = GetProcess();
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcTlsListen");
goto cleanup;
}
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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
result = acceptId;
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
int HLT_RpcTlsAccept(HLT_Process *peerProcess, int sslId)
{
int ret;
uint64_t acceptId;
Process *srcProcess = NULL;
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
srcProcess = GetProcess();
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcTlsAccept");
goto cleanup;
}
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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
result = acceptId;
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
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};
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcTlsConnect");
goto cleanup;
}
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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Waiting for the result returned by the peer
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (!(ret == SUCCESS)) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = atoi(expectCmdData.paras[0]);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
int HLT_RpcTlsConnectUnBlock(HLT_Process *peerProcess, int sslId)
{
uint64_t cmdIndex;
Process *srcProcess = NULL;
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcTlsConnect");
goto cleanup;
}
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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
result = cmdIndex;
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
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};
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcTlsRead");
goto cleanup;
}
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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Waiting for the result returned by the peer
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (!(ret == SUCCESS)) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
// 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.
}
result = ret;
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
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;
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcTlsRead");
goto cleanup;
}
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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
result = cmdIndex;
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
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};
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcTlsWrite");
goto cleanup;
}
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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Waiting for the result returned by the peer
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (!(ret == SUCCESS)) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = atoi(expectCmdData.paras[0]);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
int HLT_RpcTlsWriteUnBlock(HLT_Process *peerProcess, int sslId, uint8_t *data, uint32_t bufSize)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcTlsWrite");
goto cleanup;
}
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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Do not wait for the result returned by the peer.
result = cmdIndex;
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
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;
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
CmdData expectCmdData = {0};
srcProcess = GetProcess();
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcTlsRenegotiate");
goto cleanup;
}
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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (!(ret == SUCCESS)) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = (int)strtol(expectCmdData.paras[0], &endPtr, 0);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
int HLT_RpcTlsVerifyClientPostHandshake(HLT_Process *peerProcess, int sslId)
{
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess = NULL;
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
CmdData expectCmdData = {0};
srcProcess = GetProcess();
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call RpcTlsVerifyClientPostHandshake");
goto cleanup;
}
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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (!(ret == SUCCESS)) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = (int)strtol(expectCmdData.paras[0], &endPtr, 0);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
int HLT_RpcDataChannelConnect(HLT_Process *peerProcess, DataChannelParam *channelParam)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcDataChannelConnect");
goto cleanup;
}
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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Waiting for the result returned by the peer
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (!(ret == SUCCESS)) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = atoi(expectCmdData.paras[0]);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
int HLT_RpcDataChannelBind(HLT_Process *peerProcess, DataChannelParam *channelParam)
{
int ret;
uint64_t bindId;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcDataChannelBind");
goto cleanup;
}
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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Waiting for the result returned by the peer
ret = WaitResult(&expectCmdData, bindId, __FUNCTION__);
if (!(ret == SUCCESS)) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
channelParam->port = atoi(expectCmdData.paras[1]);
result = atoi(expectCmdData.paras[0]);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
int HLT_RpcDataChannelAccept(HLT_Process *peerProcess, DataChannelParam *channelParam)
{
int ret;
uint64_t acceptId;
Process *srcProcess = NULL;
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcDataChannelAccept");
goto cleanup;
}
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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
result = acceptId;
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
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};
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcTlsRegCallback");
goto cleanup;
}
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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (!(ret == SUCCESS)) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = atoi(expectCmdData.paras[0]);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
int HLT_RpcProcessExit(HLT_Process *peerProcess)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess;
CmdData expectCmdData = {0};
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
srcProcess = GetProcess();
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcProcessExit");
goto cleanup;
}
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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (!(ret == SUCCESS)) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = SUCCESS;
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
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};
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (!(ret == SUCCESS)) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = (int)strtol(expectCmdData.paras[0], &endPtr, 0);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
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};
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (!(ret == SUCCESS)) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = (int)strtol(expectCmdData.paras[0], &endPtr, 0);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
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};
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
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);
if (!(ret > 0)) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (!(ret == SUCCESS)) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (!(ret == SUCCESS)) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = (int)strtol(expectCmdData.paras[0], &endPtr, 0);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
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};
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
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);
if (ret <= 0) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (ret != SUCCESS) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (!(ret == SUCCESS)) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = (int)strtol(expectCmdData.paras[0], &endPtr, 0);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
int HLT_RpcTlsClose(HLT_Process *peerProcess, int sslId)
{
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess = NULL;
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
CmdData expectCmdData = {0};
srcProcess = GetProcess();
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcTlsClose");
goto cleanup;
}
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);
if (ret <= 0) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (ret != SUCCESS) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (!(ret == SUCCESS)) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = (int)strtol(expectCmdData.paras[0], &endPtr, 0);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
int HLT_RpcFreeResFormSsl(HLT_Process *peerProcess, int sslId)
{
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess = NULL;
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
CmdData expectCmdData = {0};
srcProcess = GetProcess();
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcFreeResFormSsl");
goto cleanup;
}
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);
if (ret <= 0) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (ret != SUCCESS) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (ret != SUCCESS) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = (int)strtol(expectCmdData.paras[0], &endPtr, 0);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
int HLT_RpcSctpClose(HLT_Process *peerProcess, int fd)
{
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess = NULL;
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
CmdData expectCmdData = {0};
srcProcess = GetProcess();
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcSctpClose");
goto cleanup;
}
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);
if (ret <= 0) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (ret != SUCCESS) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (ret != SUCCESS) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = (int)strtol((const char *)expectCmdData.paras[0], &endPtr, 0);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
int HLT_RpcCloseFd(HLT_Process *peerProcess, int fd, int linkType)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
srcProcess = GetProcess();
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcCloseFd");
goto cleanup;
}
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);
if (ret <= 0) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (ret != SUCCESS) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// The close fd does not need to wait for the result.
result = ret;
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
int HLT_RpcTlsSetMtu(HLT_Process *peerProcess, int sslId, uint16_t mtu)
{
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess = NULL;
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
CmdData expectCmdData = {0};
srcProcess = GetProcess();
if (!(peerProcess->remoteFlag == 1)) {
LOG_ERROR("Only Remote Process Support Call HLT_RpcTlsSetMtu");
goto cleanup;
}
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);
if (ret <= 0) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (ret != SUCCESS) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (ret != SUCCESS) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = (int)strtol(expectCmdData.paras[0], &endPtr, 0);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
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};
/* Allocate buffer on heap to avoid stack overflow (20KB is too large for stack) */
ControlChannelBuf *dataBuf = (ControlChannelBuf *)malloc(sizeof(ControlChannelBuf));
if (dataBuf == NULL) {
LOG_ERROR("Failed to allocate ControlChannelBuf");
return ERROR;
}
int result = ERROR;
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);
if (ret <= 0) {
LOG_ERROR("sprintf_s Error");
goto cleanup;
}
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, dataBuf);
if (ret != SUCCESS) {
LOG_ERROR("ControlChannelWrite Error");
goto cleanup;
}
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
if (ret != SUCCESS) {
LOG_ERROR("WaitResult Error");
goto cleanup;
}
result = (int)strtol(expectCmdData.paras[0], &endPtr, 0);
cleanup:
if (dataBuf != NULL) {
free(dataBuf);
}
return result;
}
| 2401_83913325/openHiTLS_1 | testcode/framework/tls/rpc/src/hlt_rpc_func.c | C | unknown | 53,954 |
/*
* 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);
ret = ERROR;
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;
} | 2401_83913325/openHiTLS_1 | testcode/framework/tls/rpc/src/rpc_func.c | C | unknown | 23,859 |
/*
* 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 | 2401_83913325/openHiTLS_1 | 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
| 2401_83913325/openHiTLS_1 | 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 | 2401_83913325/openHiTLS_1 | 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
| 2401_83913325/openHiTLS_1 | 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
| 2401_83913325/openHiTLS_1 | 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;
} | 2401_83913325/openHiTLS_1 | 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;
} | 2401_83913325/openHiTLS_1 | 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
| 2401_83913325/openHiTLS_1 | 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 | 2401_83913325/openHiTLS_1 | 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"
;;
"tls-debug")
COMMON_PARAM="$COMMON_PARAM $i"
;;
"debug"|"asan")
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_default test=obj
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=obj_custom,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_SM3" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM" add-options="-DHITLS_CRYPTO_DRBG_GM"
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_SM3" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM" add-options="-DHITLS_CRYPTO_DRBG_GM"
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_SM3" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM" add-options="-DHITLS_CRYPTO_DRBG_GM"
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_SM3" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM" add-options="-DHITLS_CRYPTO_DRBG_GM"
# 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_SM3" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM" add-options="-DHITLS_CRYPTO_DRBG_GM"
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_SM3" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM" add-options="-DHITLS_CRYPTO_DRBG_GM"
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_SM3" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM" add-options="-DHITLS_CRYPTO_DRBG_GM"
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_SM3" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM" add-options="-DHITLS_CRYPTO_DRBG_GM"
}
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,pkey_cmp,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,pkey_cmp,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" add-options="-DHITLS_CRYPTO_MLKEM_CMP" add-options="-DHITLS_CRYPTO_MLDSA_CMP"
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=sal_thread,eal,codecskey,rsa,drbg_hash,cipher,modes,sha256,hmac
bash mini_build_test.sh no-tls enable=sal_thread,eal,key_epki,key_encode,rsa,drbg_hash,cipher,modes,sha256,hmac
bash mini_build_test.sh no-tls enable=sal_thread,eal,key_encode,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=sal_thread,eal,key_decode,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=sal_thread,eal,x509,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=sal_thread,eal,x509_crt,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=sal_thread,eal,x509_crt_gen,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=sal_thread,eal,x509_crt_parse,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=sal_thread,eal,x509_csr,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=sal_thread,eal,x509_csr_gen,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=sal_thread,eal,x509_csr_parse,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=sal_thread,eal,x509_crl,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=sal_thread,eal,x509_crl_gen,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=sal_thread,eal,x509_crl_parse,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=sal_thread,eal,x509_vfy,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=sal_thread,eal,pkcs12,rsa,sha256,drbg_hash,md,cipher,modes,hmac
bash mini_build_test.sh no-tls enable=sal_thread,eal,pkcs12_gen,rsa,sha256,drbg_hash,md,cipher,modes,hmac
bash mini_build_test.sh no-tls enable=sal_thread,eal,pkcs12_parse,rsa,drbg_hash,md,cipher,modes,hmac
bash mini_build_test.sh no-tls enable=sal_thread,eal,info_crt,x509_crt_gen,rsa,drbg_hash,md,cipher,modes,hmac
bash mini_build_test.sh no-tls enable=sal_thread,eal,info_csr,x509_csr_gen,rsa,drbg_hash,md,cipher,modes,hmac
bash mini_build_test.sh no-tls enable=sal_thread,eal,info_crl,x509_crl_gen,rsa,drbg_hash,md,cipher,modes,hmac
bash mini_build_test.sh no-tls enable=sal_thread,eal,info_crt,x509_crt_parse,rsa,drbg_hash,md,cipher,modes,hmac
bash mini_build_test.sh no-tls enable=sal_thread,eal,info_csr,x509_csr_parse,rsa,drbg_hash,md,cipher,modes,hmac
bash mini_build_test.sh no-tls enable=sal_thread,eal,info_crl,x509_crl_parse,rsa,drbg_hash,md,cipher,modes,hmac
#### key gen ####sal_thread,
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,sal_thread,eal,key_encode,sal_file,pem,rsa,sha256,drbg_hash test=key_encode
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,key_encode,pem,ed25519,drbg_hash test=key_encode
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,key_encode,sal_file,sm2,sha256,drbg_hash test=key_encode
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,key_encode,pem,ecdsa,curve_nistp256,sha256,drbg_hash test=key_encode
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,key_encode,pem,mldsa,sha256,drbg_hash test=key_encode
#### key parse ####
echo "Test: key_decode without provider"
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,key_decode,sal_file,pem,rsa,sha256,drbg_hash test=key_decode
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,key_decode,sal_file,pem,ed25519,drbg_hash test=key_decode
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,key_decode,sal_file,sm2,sha256,drbg_hash test=key_decode
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,key_decode,sal_file,pem,ecdsa,curve_nistp256,sha256,drbg_hash test=key_decode
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,key_decode,sal_file,pem,mldsa,sha256,drbg_hash test=key_decode
echo "Test: key_decode with provider"
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,key_decode,provider,sal_dl,sal_file,pem,rsa,sha256,drbg_hash test=key_decode
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,key_decode,provider,sal_dl,sal_file,pem,ed25519,drbg_hash test=key_decode
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,key_decode,provider,sal_dl,sal_file,sm2,sha256,drbg_hash test=key_decode
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,key_decode,provider,sal_dl,sal_file,pem,ecdsa,curve_nistp256,sha256,drbg_hash test=key_decode
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,key_decode,provider,sal_dl,sal_file,pem,mldsa,sha256,drbg_hash test=key_decode
echo "Test: key_decode_chain (with provider)"
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,key_decode_chain,sal_dl,sal_file,pem,rsa,sha256,drbg_hash test=key_decode
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,key_decode_chain,sal_dl,sal_file,pem,ed25519,drbg_hash test=key_decode
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,key_decode_chain,sal_dl,sal_file,sm2,sha256,drbg_hash test=key_decode
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,key_decode_chain,sal_dl,sal_file,pem,ecdsa,curve_nistp256,sha256,drbg_hash test=key_decode
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,key_decode_chain,sal_dl,sal_file,pem,mldsa,sha256,drbg_hash test=key_decode
#### crl gen ####
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_crl_gen,rsa,sal_file,pem,sha256,drbg_hash test=x509_crl_gen
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_crl_gen,pem,ed25519,drbg_hash test=x509_crl_gen
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_crl_gen,sm2,sha256,drbg_hash test=x509_crl_gen
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_crl_gen,sal_file,ecdsa,curve_nistp256,sha256,drbg_hash test=x509_crl_gen
#### crl parse ####
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_crl_parse,pem,sal_file,rsa,sha256,drbg_hash test=x509_crl_parse
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_crl_parse,sal_file,ed25519,sha256,drbg_hash test=x509_crl_parse
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_crl_parse,pem,sal_file,sm2,sha256,drbg_hash test=x509_crl_parse
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_crl_parse,sal_file,ecdsa,curve_nistp256,sha256,drbg_hash test=x509_crl_parse
#### csr gen ####
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_csr_gen,x509_csr_attr,x509_csr_get,pem,rsa,sha256,drbg_hash test=x509_csr_gen
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_csr_gen,x509_csr_attr,x509_csr_get,sal_file,ed25519,drbg_hash test=x509_csr_gen add-options="-DHITLS_CRYPTO_ED25519_CHECK"
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_csr_gen,x509_csr_attr,x509_csr_get,sm2,sha256,drbg_hash test=x509_csr_gen
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_csr_gen,x509_csr_attr,x509_csr_get,sal_file,pem,ecdsa,curve_nistp256,sha256,drbg_hash test=x509_csr_gen
#### csr parse ####
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_csr_parse,x509_csr_attr,x509_csr_get,sal_file,rsa,sha256,drbg_hash test=x509_csr_parse
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_csr_parse,x509_csr_attr,x509_csr_get,sal_file,pem,ed25519,drbg_hash test=x509_csr_parse
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_csr_parse,x509_csr_attr,x509_csr_get,sal_file,pem,sm2,sha256,drbg_hash test=x509_csr_parse
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_csr_parse,x509_csr_attr,x509_csr_get,sal_file,ecdsa,curve_nistp256,sha256,drbg_hash test=x509_csr_parse
#### cert gen ####
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=eal,x509_crt_gen,pem,rsa,sha256,drbg_hash,sal_str,sal_thread test=x509_crt_gen
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=eal,x509_crt_gen,sal_file,pem,ed25519,drbg_hash,sal_str,sal_thread test=x509_crt_gen
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=eal,x509_crt_gen,sal_file,sm2,sha256,drbg_hash,sal_str,sal_thread test=x509_crt_gen
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=eal,x509_crt_gen,ecdsa,curve_nistp256,sha256,drbg_hash,sal_str,sal_thread test=x509_crt_gen
#### cert parse ####
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_crt_parse,sal_file,sal_str,pem,rsa,sha256,drbg_hash test=x509_crt_parse
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_crt_parse,sal_file,sal_str,ed25519,drbg_hash test=x509_crt_parse
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_crt_parse,sal_file,sal_str,sm2,sha256,drbg_hash test=x509_crt_parse
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_crt_parse,sal_file,sal_str,pem,ecdsa,curve_nistp256,curve_nistp384,sha256,drbg_hash test=x509_crt_parse
#### cert chain ####
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,x509_vfy,sal_file,sal_str,pem,rsa,ecdsa,curve_nistp256,curve_nistp384,ed25519,sm2,sha2,drbg_hash test=x509_vfy
#### pkcs12 gen ####
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,,sal_file,sal_str,pkcs12_gen,key_decode,sal_file,pem,rsa,ecdsa,curve_nistp256,ed25519,sm2,drbg_hash,cipher,modes,md,hmac test=pkcs12_gen
bash mini_build_test.sh $COMMON_PARAM linux no-tls enable=sal_thread,eal,pkcs12_parse,sal_file,sal_str,pem,rsa,ecdsa,curve_nistp256,curve_nistp384,curve_nistp521,ed25519,sm2,cipher,modes,md,drbg_hash,hmac test=pkcs12_parse
}
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,sal_dl test=provider add-options="-DHITLS_CONFIG_FILE='<test_config.h>'" include-path="${include_path}"
provider_test_check
# hmac
# build without sha256, and not check config
bash mini_build_test.sh $COMMON_PARAM $NO_LIB linux enable=eal,provider,sal_dl,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,sal_dl,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,sal_dl,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,sal_dl,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,sal_dl,rsa,sm3,drbg_hash,entropy,ealinit 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
| 2401_83913325/openHiTLS_1 | testcode/script/all_mini_test.sh | Shell | unknown | 34,781 |
#!/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=""
build_crypto_module_provider=false
# Detect platform and set shared library extension
# Reference: https://en.wikipedia.org/wiki/Dynamic_linker
case "$(uname)" in
Linux)
# Linux uses ELF format with .so extension
SHARED_LIB_EXT=".so"
;;
Darwin)
# macOS uses Mach-O format with .dylib extension
SHARED_LIB_EXT=".dylib"
;;
FreeBSD|OpenBSD|NetBSD)
# BSD systems use ELF format with .so extension
SHARED_LIB_EXT=".so"
;;
*)
echo "Warning: Unknown platform '$(uname)', assuming .so extension"
SHARED_LIB_EXT=".so"
;;
esac
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 Build Directory
# ============================================================
# Function: clean
# Purpose: Remove and recreate build directory for fresh build
# ============================================================
clean()
{
rm -rf ${HITLS_ROOT_DIR}/build
mkdir ${HITLS_ROOT_DIR}/build
}
# ============================================================
# Ensure Secure_C Submodule is Ready
# ============================================================
# Function: ensure_securec_ready
# Purpose: Check and initialize Secure_C git submodule if needed
# Note: Actual build happens via CMake (platform/SecureC.cmake)
# This function only ensures the source code is available
# ============================================================
ensure_securec_ready()
{
local securec_src_dir="${HITLS_ROOT_DIR}/platform/Secure_C/src"
local securec_lib_file="${HITLS_ROOT_DIR}/platform/Secure_C/lib/libboundscheck.a"
echo "======================================================================"
echo "Checking Secure_C dependency..."
echo "======================================================================"
# Initialize submodule if source not present
if [ ! -d "${securec_src_dir}" ]; then
echo "[INFO] Secure_C submodule not initialized, initializing..."
cd "${HITLS_ROOT_DIR}"
if ! git submodule update --init platform/Secure_C; then
echo "[ERROR] Failed to initialize Secure_C submodule"
echo "[ERROR] Please check your git configuration and network connection"
exit 1
fi
echo "[SUCCESS] Secure_C submodule initialized"
else
echo "[INFO] Secure_C submodule already initialized"
fi
# Report build status
if [ -f "${securec_lib_file}" ]; then
echo "[INFO] Securec library already built: ${securec_lib_file}"
else
echo "[INFO] Securec will be built by CMake during hitls build"
fi
echo ""
}
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} -DHITLS_TLS_FEATURE_SM_TLS13" # enable rfc8998 tests
add_options="${add_options} ${test_options}"
build_options=""
if [[ $executes = "ON" ]]; then
build_options="${build_options} --executes hitls"
add_options="${add_options} -DHITLS_CRYPTO_CMVP"
fi
# On Linux, we need -ldl for dlopen() and related functions
# On macOS, libdl functionality is part of libSystem, so -ldl is not needed (and causes duplicate warnings)
# On macOS, also need -fno-inline to prevent inlining (required for STUB interception to work)
link_flags=""
if [[ "$(uname)" != "Darwin" ]]; then
link_flags="--add_link_flags=\"-ldl\""
else
add_options="${add_options} -fno-inline"
fi
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
python3 ../configure.py ${build_options} --lib_type ${LIB_TYPE} --enable all --asm_type x8664 --add_options="$add_options" --del_options="$del_options" ${link_flags} ${enable_sctp} ${dis_options}
elif [[ $get_arch = "armv8_be" ]]; then
echo "Compile: env=armv8, asm + c, big endian, 64bits"
python3 ../configure.py ${build_options} --lib_type ${LIB_TYPE} --enable all --endian big --asm_type armv8 --add_options="$add_options" --del_options="$del_options" ${link_flags} ${enable_sctp} ${dis_options}
elif [[ $get_arch = "armv8_le" ]]; then
echo "Compile: env=armv8, asm + c, little endian, 64bits"
python3 ../configure.py ${build_options} --lib_type ${LIB_TYPE} --enable all --asm_type armv8 --add_options="$add_options" --del_options="$del_options" ${link_flags} ${enable_sctp} ${dis_options}
elif [[ $get_arch = "riscv64" ]]; then
echo "Compile: env=riscv64, asm + c, little endian, 64bits"
python3 ../configure.py --lib_type ${LIB_TYPE} --asm_type riscv64 --add_options="$add_options" --del_options="$del_options" ${link_flags} ${enable_sctp}
else
echo "Compile: env=$get_arch, c, little endian, 64bits"
python3 ../configure.py ${build_options} --lib_type ${LIB_TYPE} --enable all --add_options="$add_options" --del_options="$del_options" ${link_flags} ${enable_sctp} ${dis_options}
fi
# macOS-specific flags for STUB test mechanism compatibility
# On macOS, use flat namespace + interposable to allow test STUB wrappers to intercept library internal calls
# -flat_namespace: Changes symbol resolution order (matches Linux behavior)
# -Wl,-interposable: Forces all function calls through PLT, even intra-module calls (prevents direct jumps)
# This combination ensures STUB mechanism can intercept same-compilation-unit calls
# ONLY needed for test builds - Production builds use default two-level namespace
if [[ "$(uname)" = "Darwin" ]]; then
cmake .. -DCMAKE_SHARED_LINKER_FLAGS="-flat_namespace -undefined dynamic_lookup -Wl,-interposable" \
-DCMAKE_EXE_LINKER_FLAGS="-flat_namespace -undefined dynamic_lookup"
else
cmake ..
fi
make -j
}
build_hitls_provider()
{
# Compile openHiTLS
cd ${HITLS_ROOT_DIR}/build
# Remove configuration files to allow reconfiguration for provider build
rm -f feature_config.json compile_config.json macro.txt modules.cmake
if [[ $libname = "libhitls_sm${SHARED_LIB_EXT}" ]] && [[ $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=config/json/${subdir}/${get_arch}/${compile_file} \
--lib_type=shared \
--bundle_libs
cmake .. -DCMAKE_SKIP_RPATH=TRUE -DCMAKE_INSTALL_PREFIX=../output/${subdir}/${get_arch}
make -j
make install
# Verify the library was built with correct name
cd ../output/${subdir}/${get_arch}/lib
if [ ! -f "$libname" ]; then
echo "Error: $libname not found in $(pwd)"
echo "Available files:"
ls -la
exit 1
fi
echo "Successfully built $libname in $(pwd)"
}
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 codecsdata key_decode_chain"
;;
"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"
;;
"riscv64")
get_arch="riscv64"
;;
"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")
if [[ "$(uname)" = "Darwin" ]]; then
echo "Warning: ISO provider build is not supported on macOS, due to sw-entropy skipping..."
else
add_options="${add_options} -DHITLS_CRYPTO_CMVP_ISO19790"
libname="libhitls_iso${SHARED_LIB_EXT}"
build_crypto_module_provider=true
fi
;;
"fips")
if [[ "$(uname)" = "Darwin" ]]; then
echo "Warning: FIPS provider build is not supported on macOS, due to sw-entropy skipping..."
else
add_options="${add_options} -DHITLS_CRYPTO_CMVP_FIPS"
libname="libhitls_fips${SHARED_LIB_EXT}"
build_crypto_module_provider=true
fi
;;
"sm")
if [[ "$(uname)" = "Darwin" ]]; then
echo "Warning: SM provider build is not supported on macOS, due to sw-entropy skipping..."
else
add_options="${add_options} -DHITLS_CRYPTO_CMVP_SM"
libname="libhitls_sm${SHARED_LIB_EXT}"
build_crypto_module_provider=true
fi
;;
"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
ensure_securec_ready
# Always build main library
build_hitls_code
# Build CMVP provider if requested (iso/fips/sm)
if [[ $build_crypto_module_provider == true ]]; then
build_hitls_provider
fi
| 2401_83913325/openHiTLS_1 | testcode/script/build_hitls.sh | Shell | unknown | 14,539 |
#!/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()
{
# Force recalculate HITLS_ROOT_DIR to avoid CI environment variable pollution
# Unset any pre-existing value to ensure clean path resolution
unset 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__"
# Add PKI macro if PKI library exists (needed for test framework linking)
if ls ${HITLS_ROOT_DIR}/build/libhitls_pki.* 1> /dev/null 2>&1; then
CUSTOM_CFLAGS="$CUSTOM_CFLAGS -DHITLS_PKI"
fi
# Add UDP/TCP/SCTP only if main library has them (check macro.txt)
# This ensures test framework matches the main library's UIO capabilities
if grep -q "HITLS_BSL_UIO_UDP" ${HITLS_ROOT_DIR}/build/macro.txt 2>/dev/null; then
CUSTOM_CFLAGS="$CUSTOM_CFLAGS -DHITLS_BSL_UIO_UDP"
fi
if grep -q "HITLS_BSL_UIO_TCP" ${HITLS_ROOT_DIR}/build/macro.txt 2>/dev/null; then
CUSTOM_CFLAGS="$CUSTOM_CFLAGS -DHITLS_BSL_UIO_TCP"
fi
if grep -q "HITLS_BSL_UIO_SCTP" ${HITLS_ROOT_DIR}/build/macro.txt 2>/dev/null; then
CUSTOM_CFLAGS="$CUSTOM_CFLAGS -DHITLS_BSL_UIO_SCTP"
fi
fi
# Add macOS-specific flags for AppleClang (must come AFTER macro.txt)
if [[ "$(uname)" == "Darwin" ]]; then
CUSTOM_CFLAGS="$CUSTOM_CFLAGS -Wno-unused-command-line-argument -Wno-error=unused-command-line-argument"
CUSTOM_CFLAGS="$CUSTOM_CFLAGS -Wno-sometimes-uninitialized -Wno-error=sometimes-uninitialized"
CUSTOM_CFLAGS="$CUSTOM_CFLAGS -Wno-gnu-folding-constant -Wno-error=gnu-folding-constant"
CUSTOM_CFLAGS="$CUSTOM_CFLAGS -Wno-non-literal-null-conversion -Wno-error=non-literal-null-conversion"
CUSTOM_CFLAGS="$CUSTOM_CFLAGS -Wno-sizeof-array-div -Wno-error=sizeof-array-div"
CUSTOM_CFLAGS="$CUSTOM_CFLAGS -Wno-format -Wno-error=format"
CUSTOM_CFLAGS="$CUSTOM_CFLAGS -Wno-enum-conversion -Wno-error=enum-conversion"
CUSTOM_CFLAGS="$CUSTOM_CFLAGS -Wno-int-conversion -Wno-error=int-conversion"
CUSTOM_CFLAGS="$CUSTOM_CFLAGS -Wno-unused-function -Wno-error=unused-function"
fi
if [[ ! -e "${HITLS_ROOT_DIR}/testcode/output/log" ]]; then
mkdir -p ${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
# macOS-specific flags for STUB test mechanism compatibility
# On macOS, use flat namespace to allow test STUB wrappers to intercept library internal calls
# This matches Linux symbol resolution behavior and is ONLY needed for test builds
# Production builds (via top-level CMakeLists.txt) use the default two-level namespace
if [[ "$(uname)" = "Darwin" ]]; then
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} \
-DCMAKE_SHARED_LINKER_FLAGS="-flat_namespace -undefined dynamic_lookup" \
-DCMAKE_EXE_LINKER_FLAGS="-flat_namespace -undefined dynamic_lookup" ..
else
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} ..
fi
make -j
}
# Function: Compile provider .so file
build_provider_so()
{
# Only build if provider support is enabled
if [ -f ${HITLS_ROOT_DIR}/build/macro.txt ]; then
if ! grep -q "HITLS_CRYPTO_PROVIDER" ${HITLS_ROOT_DIR}/build/macro.txt 2>/dev/null; then
echo "[INFO] Provider support not enabled, skipping provider library build"
return 0
fi
else
echo "[WARNING] macro.txt not found, skipping provider library build"
return 0
fi
echo "======================================================================"
echo "Building provider test libraries..."
echo "======================================================================"
local provider_dir="${HITLS_ROOT_DIR}/testcode/testdata/provider"
if [ ! -d "$provider_dir" ]; then
echo "[ERROR] Provider directory not found: $provider_dir"
return 1
fi
cd "$provider_dir"
if [ $? -ne 0 ]; then
echo "[ERROR] Failed to change directory to provider path: $provider_dir"
return 1
fi
rm -rf build
mkdir build
cd build
echo "[INFO] Running cmake for provider libraries..."
if ! cmake -DENABLE_GCOV=${ENABLE_GCOV} ..; then
echo "[ERROR] CMake configuration failed for provider libraries"
return 1
fi
echo "[INFO] Building provider libraries..."
if ! make -j; then
echo "[ERROR] Provider library build failed"
return 1
fi
echo "[SUCCESS] Provider libraries built successfully"
echo "[INFO] Provider library location:"
if [ -d "${HITLS_ROOT_DIR}/testcode/output/provider_test_data" ]; then
ls -lh "${HITLS_ROOT_DIR}/testcode/output/provider_test_data/path1/" 2>/dev/null | head -5 || true
echo "..."
ls -lh "${HITLS_ROOT_DIR}/testcode/output/provider_test_data/path2/" 2>/dev/null | head -5 || true
local path1_count=$(ls "${HITLS_ROOT_DIR}/testcode/output/provider_test_data/path1/" 2>/dev/null | wc -l)
local path2_count=$(ls "${HITLS_ROOT_DIR}/testcode/output/provider_test_data/path2/" 2>/dev/null | wc -l)
echo "[INFO] Built $path1_count provider libraries in path1/ and $path2_count in path2/"
else
echo "[ERROR] Provider output directory not found!"
return 1
fi
return 0
}
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 -p ${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
| 2401_83913325/openHiTLS_1 | testcode/script/build_sdv.sh | Shell | unknown | 15,362 |
#!/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
# Cross-platform CPU count detection
if [[ "$(uname)" == "Darwin" ]]; then
threadsNum=$(sysctl -n hw.ncpu)
else
threadsNum=$(grep -c ^processor /proc/cpuinfo)
fi
testsuite_array=()
testcase_array=()
# Build library path with all necessary library paths (cross-platform)
# Start with build directory (no leading colon)
LIB_PATHS="$(realpath ${HITLS_ROOT_DIR}/build)"
LIB_PATHS="${LIB_PATHS}:$(realpath ${HITLS_ROOT_DIR}/platform/Secure_C/lib)"
# Add CMVP provider library paths (all architectures: C, armv8_le, x86_64, etc.)
for cmvp_lib_dir in ${HITLS_ROOT_DIR}/output/CMVP/*/lib; do
if [ -d "$cmvp_lib_dir" ]; then
LIB_PATHS="${LIB_PATHS}:$(realpath $cmvp_lib_dir)"
echo "[INFO] Adding CMVP library path: $(realpath $cmvp_lib_dir)"
fi
done
# Also check build/output location (alternative install path)
if [ -d "${HITLS_ROOT_DIR}/build/output/CMVP" ]; then
for cmvp_lib_dir in ${HITLS_ROOT_DIR}/build/output/CMVP/*/lib; do
if [ -d "$cmvp_lib_dir" ]; then
LIB_PATHS="${LIB_PATHS}:$(realpath $cmvp_lib_dir)"
echo "[INFO] Adding CMVP library path (build): $(realpath $cmvp_lib_dir)"
fi
done
fi
# Set library path based on platform
if [[ "$(uname)" == "Darwin" ]]; then
# macOS uses DYLD_LIBRARY_PATH
if [ -n "${DYLD_LIBRARY_PATH}" ]; then
LIB_PATHS="${LIB_PATHS}:${DYLD_LIBRARY_PATH}"
fi
export DYLD_LIBRARY_PATH="${LIB_PATHS}"
export LD_LIBRARY_PATH="${LIB_PATHS}" # Also set for compatibility
echo "[INFO] Final DYLD_LIBRARY_PATH: ${DYLD_LIBRARY_PATH}"
else
# Linux uses LD_LIBRARY_PATH
if [ -n "${LD_LIBRARY_PATH}" ]; then
LIB_PATHS="${LIB_PATHS}:${LD_LIBRARY_PATH}"
fi
export LD_LIBRARY_PATH="${LIB_PATHS}"
echo "[INFO] Final LD_LIBRARY_PATH: ${LD_LIBRARY_PATH}"
fi
# 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
# Set custom LD_LIBRARY_PATH for provider load test suite
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
# Run other test suites normally
./${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))
# Cross-platform date formatting
if [[ "$(uname)" == "Darwin" ]]; then
days=$((elapsed/86400)); hours=$(( (elapsed%86400)/3600 )); minutes=$(( (elapsed%3600)/60 )); seconds=$((elapsed%60))
echo "Elapsed time: $days days $(printf "%02d" $hours) hr $(printf "%02d" $minutes) min $(printf "%02d" $seconds) sec" >> time.txt
else
eval "echo Elapsed time: $(date -ud "@$elapsed" +'$((%s/3600/24)) days %H hr %M min %S sec') >> time.txt"
fi
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()
{
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 [ $? -ne 0 ]; then
echo "Demo ${e} failed"
exit 1
fi
fi
done
# run server and client in order.
./server &
server_pid=$!
sleep 1
./client
client_rc=$?
if [ $client_rc -ne 0 ]; then
echo "Demo client failed"
exit 1
fi
# wait server to exit and get exit code
wait $server_pid
server_rc=$?
if [ $server_rc -ne 0 ]; then
echo "Demo server failed"
exit 1
fi
# run tlcp server and client in order.
./tlcp_server &
tlcp_server_pid=$!
sleep 1
./tlcp_client
tlcp_client_rc=$?
echo "tlcp_client_rc: $tlcp_client_rc"
if [ $tlcp_client_rc -ne 0 ]; then
echo "Demo tlcp client failed"
exit 1
fi
wait $tlcp_server_pid
tlcp_server_rc=$?
echo "tlcp_server_rc: $tlcp_server_rc"
if [ $tlcp_server_rc -ne 0 ]; then
echo "Demo tlcp server 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
| 2401_83913325/openHiTLS_1 | testcode/script/execute_sdv.sh | Shell | unknown | 11,650 |
#!/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"
ASAN_OPTIONS=""
TLS_FLAG=""
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 " %-25s %s\n" "tls-debug" "TEST: HiTLS tls module debug log."
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"
ASAN_OPTIONS="asan"
;;
"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"
;;
"tls-debug")
TLS_FLAG=$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 $ASAN_OPTIONS $params $TLS_FLAG
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
| 2401_83913325/openHiTLS_1 | testcode/script/mini_build_test.sh | Shell | unknown | 12,712 |
#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 | 2401_83913325/openHiTLS_1 | 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}")
add_compile_definitions(OPENHITLSDIR="${CMAKE_INSTALL_PREFIX}/")
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
)
add_library(TEST_INTF INTERFACE)
if(ENABLE_PRINT)
target_compile_options(TEST_INTF INTERFACE -DPRINT_TO_TERMINAL)
endif()
if(ENABLE_FAIL_REPEAT)
target_compile_options(TEST_INTF 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
)
# Link libraries - cross-platform shared library configuration
# Use library names without extensions; CMake handles platform-specific suffixes
# macOS: .dylib, Linux: .so
set(TEST_INTF_LIBS "")
if(ENABLE_TLS AND ${BUILD_TLS} GREATER -1)
list(APPEND TEST_INTF_LIBS tls_hlt tls_frame hitls_tls rec_wrapper)
endif()
if(ENABLE_PKI AND ${BUILD_PKI} GREATER -1)
list(APPEND TEST_INTF_LIBS hitls_pki)
endif()
if(ENABLE_AUTH AND ${BUILD_AUTH} GREATER -1)
list(APPEND TEST_INTF_LIBS hitls_auth)
endif()
if(ENABLE_CRYPTO AND ${BUILD_CRYPTO} GREATER -1)
list(APPEND TEST_INTF_LIBS hitls_crypto)
endif()
# Use find_library to support cross-platform static library extensions (.a on Unix, .lib on Windows)
find_library(BOUNDSCHECK_STATIC_LIB
NAMES libboundscheck.a boundscheck # Try .a explicitly first, then let CMake find static version
PATHS ${CMAKE_SOURCE_DIR}/../platform/Secure_C/lib
NO_DEFAULT_PATH
NO_CMAKE_FIND_ROOT_PATH
)
if(NOT BOUNDSCHECK_STATIC_LIB)
message(FATAL_ERROR "Could not find static boundscheck library at ${CMAKE_SOURCE_DIR}/../platform/Secure_C/lib")
endif()
list(APPEND TEST_INTF_LIBS hitls_bsl ${BOUNDSCHECK_STATIC_LIB} pthread dl)
target_link_libraries(TEST_INTF INTERFACE ${TEST_INTF_LIBS})
# Shared variant inherits all configurations from TEST_INTF
add_library(TEST_INTF_SHARED INTERFACE)
target_link_libraries(TEST_INTF_SHARED INTERFACE TEST_INTF)
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/sm9/include
${openHiTLS_SRC}/crypto/ecc/src/sm9/inc
${openHiTLS_SRC}/crypto/paillier/include
${openHiTLS_SRC}/crypto/paillier/src
${openHiTLS_SRC}/crypto/elgamal/include
${openHiTLS_SRC}/crypto/elgamal/src
${openHiTLS_SRC}/crypto/codecsdata/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}/auth/otp/include
${openHiTLS_SRC}/auth/pake/spake2plus/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}
)
# TEST_INTF_SHARED inherits include directories from TEST_INTF
# Test case precompiled library - currently using shared library configuration
# Future: Create separate TESTCASE_PRE if static library support is needed
add_library(TESTCASE_PRE ${TEST_SOURCE})
target_link_libraries(TESTCASE_PRE PRIVATE TEST_INTF_SHARED)
# Build apps library BEFORE test executables (must be defined before linking)
if("${APPS}" STREQUAL "ON")
SET(APPS_LIB "hitls_apps")
aux_source_directory(${openHiTLS_SRC}/apps/src APPS_SRC)
# Exclude hitls.c which contains main() - conflicts with test executables
list(REMOVE_ITEM APPS_SRC "${openHiTLS_SRC}/apps/src/hitls.c")
# Build as SHARED library (dylib/so) for stub framework compatibility
# Stub framework uses dlsym(RTLD_NEXT) which requires dynamic symbol visibility
add_library(${APPS_LIB} SHARED ${APPS_SRC})
if(WIN32)
# Windows: .dll (not yet supported, placeholder for future implementation)
set(HITLS_LIB_EXT "dll")
message(WARNING "Windows build for apps library is not yet supported")
elseif(APPLE)
# macOS: .dylib
set(HITLS_LIB_EXT "dylib")
else()
# Linux/Unix: .so
set(HITLS_LIB_EXT "so")
endif()
target_link_libraries(${APPS_LIB} PRIVATE
${openHiTLS_SRC}/build/libhitls_crypto.${HITLS_LIB_EXT}
${openHiTLS_SRC}/build/libhitls_tls.${HITLS_LIB_EXT}
${openHiTLS_SRC}/build/libhitls_pki.${HITLS_LIB_EXT}
${openHiTLS_SRC}/build/libhitls_bsl.${HITLS_LIB_EXT}
)
# Platform-specific system libraries
if(WIN32)
# Windows system libraries (not yet supported)
message(WARNING "Windows build for apps library is not yet supported")
elseif(APPLE OR UNIX)
# macOS and Linux: pthread and dl
target_link_libraries(${APPS_LIB} PRIVATE pthread dl)
endif()
# Platform-specific compile options
if(MSVC)
# MSVC (Windows): Debug info + position-independent code equivalent
# target_compile_options(${APPS_LIB} PRIVATE /Od /Zi /DEBUG)
message(WARNING " Platform-specific options: Windows build for apps library is not yet supported")
elseif(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang|AppleClang")
# GCC/Clang (Linux/macOS): Debug info + position-independent code
target_compile_options(${APPS_LIB} PRIVATE -O0 -g3 -gdwarf-2 -fPIC)
endif()
target_include_directories(${APPS_LIB} PRIVATE
${openHiTLS_SRC}/apps/include
${openHiTLS_SRC}/apps/src
${TEST_INTF_INCLUDE_DIRS}
)
# Output directory for shared library
set_target_properties(${APPS_LIB}
PROPERTIES
LIBRARY_OUTPUT_DIRECTORY "${openHiTLS_SRC}/testcode/output/lib"
RUNTIME_OUTPUT_DIRECTORY "${openHiTLS_SRC}/testcode/output/lib" # For Windows DLL
)
endif()
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()
# Create test cases with shared library linking for STUB framework compatibility
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)
# Apply GNU ld-specific link options only on Linux
if(NOT APPLE)
target_link_options(${sdv_exe} PRIVATE "LINKER:-z,noexecstack")
endif()
add_dependencies(${sdv_exe} ${sdv_exe}_phony)
set_target_properties(${sdv_exe} PROPERTIES
RUNTIME_OUTPUT_DIRECTORY "${openHiTLS_SRC}/testcode/output"
)
# Use shared libraries for STUB framework (dlsym RTLD_NEXT) compatibility
target_link_libraries(${sdv_exe} PRIVATE TEST_INTF_SHARED TESTCASE_PRE)
# Link apps test suites against hitls_apps shared library
# Matches all 23 apps tests: 18 with "app" in name + dgst, enc, opt, print, rand
if("${APPS}" STREQUAL "ON" AND ${sdv_exe} MATCHES "test_suite_ut_(app|dgst|enc|opt|print|rand)")
target_link_libraries(${sdv_exe} PRIVATE hitls_apps)
endif()
endforeach()
| 2401_83913325/openHiTLS_1 | testcode/sdv/CMakeLists.txt | CMake | unknown | 13,871 |
/*
* 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 */
| 2401_83913325/openHiTLS_1 | 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_utils.h"
#define MAX_CRLFILE_SIZE (256 * 1024)
#define DEFAULT_CERT_SIZE 1024U
/* END_HEADER */
/* ============================================================================
* Stub Definitions
* ============================================================================ */
STUB_DEFINE_RET3(int32_t, HITLS_APP_OptBegin, int32_t, char **, const HITLS_CmdOption *);
STUB_DEFINE_RET4(int32_t, BSL_UIO_Ctrl, BSL_UIO *, int32_t, int32_t, void *);
STUB_DEFINE_RET0(char *, HITLS_APP_OptGetValueStr);
STUB_DEFINE_RET4(int32_t, HITLS_APP_OptWriteUio, BSL_UIO *, uint8_t *, uint32_t, int32_t);
STUB_DEFINE_RET4(int32_t, HITLS_X509_CertCtrl, HITLS_X509_Cert *, int32_t, void *, uint32_t);
#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_REPLACE(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_RESTORE(HITLS_APP_OptBegin);
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_REPLACE(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_RESTORE(BSL_UIO_Ctrl);
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_REPLACE(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_RESTORE(HITLS_APP_OptGetValueStr);
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_REPLACE(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_RESTORE(HITLS_APP_OptWriteUio);
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_REPLACE(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_RESTORE(HITLS_X509_CertCtrl);
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;
} | 2401_83913325/openHiTLS_1 | testcode/sdv/testcase/apps/test_suite_ut_app_crl.c | C | unknown | 11,166 |
/*
* 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_utils.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 */
/**
* @test UT_HITLS_APP_GENPKEY_TC004
* @spec -
* @title 测试ML-DSA密钥生成
*/
/* BEGIN_CASE */
void UT_HITLS_APP_GENPKEY_TC004()
{
char *argv[][20] = {
{"genpkey", "-algorithm", "ML-DSA", "-pkeyopt", "mldsa_param:ML-DSA-44"},
{"genpkey", "-algorithm", "ML-DSA", "-pkeyopt", "mldsa_param:ML-DSA-65"},
{"genpkey", "-algorithm", "ML-DSA", "-pkeyopt", "mldsa_param:ML-DSA-87"},
{"genpkey", "-algorithm", "ML-DSA", "-pkeyopt", "mldsa_param:ML-DSA-44", "-out", GENPKEY_TEST_FILE_PATH},
{"genpkey", "-algorithm", "ML-DSA", "-pkeyopt", "mldsa_param:ML-DSA-65", "-out", GENPKEY_TEST_FILE_PATH},
{"genpkey", "-algorithm", "ML-DSA", "-pkeyopt", "mldsa_param:ML-DSA-87", "-out", GENPKEY_TEST_FILE_PATH},
{"genpkey", "-algorithm", "ML-DSA", "-pkeyopt", "mldsa_param:ML-DSA-44", "-aes256-cbc", "-pass", "pass:123456"},
{"genpkey", "-algorithm", "ML-DSA", "-pkeyopt", "mldsa_param:ML-DSA-65", "-aes256-cbc", "-pass", "pass:123456", "-out", GENPKEY_TEST_FILE_PATH},
{"genpkey", "-algorithm", "ML-DSA", "-pkeyopt", "mldsa_param:ML-DSA-87", "-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},
{7, argv[3], HITLS_APP_SUCCESS},
{7, argv[4], HITLS_APP_SUCCESS},
{7, argv[5], HITLS_APP_SUCCESS},
{8, argv[6], HITLS_APP_SUCCESS},
{10, argv[7], HITLS_APP_SUCCESS},
{10, argv[8], 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_TC005
* @spec -
* @title 测试outform参数配置
*/
/* BEGIN_CASE */
void UT_HITLS_APP_GENPKEY_TC005(char *outformOpt)
{
char *argv[][20] = {
{"genpkey", "-algorithm", "RSA", "-pkeyopt", "rsa_keygen_bits:2048", "-out", GENPKEY_TEST_FILE_PATH, "-outform", outformOpt},
};
OptTestData testData[] = {
{9, 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();
remove(GENPKEY_TEST_FILE_PATH);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_GENPKEY_TC006
* @spec -
* @title 测试ML-DSA配合outform参数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_GENPKEY_TC006(char *outformOpt)
{
char *argv[][20] = {
{"genpkey", "-algorithm", "ML-DSA", "-pkeyopt", "mldsa_param:ML-DSA-65", "-out", GENPKEY_TEST_FILE_PATH, "-outform", outformOpt},
};
OptTestData testData[] = {
{9, 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();
remove(GENPKEY_TEST_FILE_PATH);
return;
}
/* END_CASE */ | 2401_83913325/openHiTLS_1 | testcode/sdv/testcase/apps/test_suite_ut_app_genpkey.c | C | unknown | 10,835 |
/*
* 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_utils.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 */
/* ============================================================================
* Stub Definitions
* ============================================================================ */
STUB_DEFINE_RET4(int32_t, HITLS_APP_Passwd, char *, int32_t, int32_t, void *);
#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_REPLACE(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_RESTORE(HITLS_APP_Passwd);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_genrsa_TC002(void)
{
STUB_REPLACE(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_RESTORE(HITLS_APP_Passwd);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_genrsa_TC003(void)
{
STUB_REPLACE(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_RESTORE(HITLS_APP_Passwd);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_genrsa_TC004(void)
{
STUB_REPLACE(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_RESTORE(HITLS_APP_Passwd);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_genrsa_TC005(void)
{
STUB_REPLACE(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_RESTORE(HITLS_APP_Passwd);
return;
}
/* END_CASE */ | 2401_83913325/openHiTLS_1 | testcode/sdv/testcase/apps/test_suite_ut_app_genrsa.c | C | unknown | 8,689 |
/*
* 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 <limits.h>
#include "securec.h"
#include "stub_utils.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"
#include "app_sm.h"
#include "bsl_ui.h"
/* END_HEADER */
/* ============================================================================
* Stub Definitions
* ============================================================================ */
STUB_DEFINE_RET5(int32_t, BSL_UI_ReadPwdUtil, BSL_UI_ReadPwdParam *, char *, uint32_t *, const BSL_UI_CheckDataCallBack, void *);
STUB_DEFINE_RET1(int32_t, HITLS_APP_SM_IntegrityCheck, AppProvider *);
STUB_DEFINE_RET0(int32_t, HITLS_APP_SM_RootUserCheck);
#define KDF_MAX_ARGC 22
#define MAX_BUFSIZE (1024 * 8)
#define WORK_PATH "./kdf_workpath"
#define PASSWORD "a1234567"
#ifdef HITLS_CRYPTO_CMVP_SM_PURE_C
#define HITLS_SM_PROVIDER_PATH "../../output/CMVP/C/lib"
#endif
#ifdef HITLS_CRYPTO_CMVP_SM_ARMV8_LE
#define HITLS_SM_PROVIDER_PATH "../../output/CMVP/armv8_le/lib"
#endif
#ifdef HITLS_CRYPTO_CMVP_SM_X86_64
#define HITLS_SM_PROVIDER_PATH "../../output/CMVP/x86_64/lib"
#endif
#define HITLS_SM_LIB_NAME "libhitls_sm." BSL_SAL_DL_EXT
#define HITLS_SM_PROVIDER_ATTR "provider=sm"
#define SM_PARAM \
"-sm", "-workpath", WORK_PATH, \
"-provider", HITLS_SM_LIB_NAME, \
"-provider-path", HITLS_SM_PROVIDER_PATH, \
"-provider-attr", HITLS_SM_PROVIDER_ATTR
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
static int32_t AppInit(void)
{
int32_t ret = AppPrintErrorUioInit(stderr);
if (ret != HITLS_APP_SUCCESS) {
return ret;
}
if (APP_Create_LibCtx() == NULL) {
(void)AppPrintError("Create g_libCtx failed\n");
return HITLS_APP_INVALID_ARG;
}
return HITLS_APP_SUCCESS;
}
static void AppUninit(void)
{
AppPrintErrorUioUnInit();
HITLS_APP_FreeLibCtx();
}
#ifdef HITLS_APP_SM_MODE
static 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[] = PASSWORD;
(void)strcpy_s(buff, *buffLen, result);
*buffLen = (uint32_t)strlen(buff) + 1;
return BSL_SUCCESS;
}
static int32_t STUB_HITLS_APP_SM_IntegrityCheck(AppProvider *provider)
{
(void)provider;
return HITLS_APP_SUCCESS;
}
static int32_t STUB_HITLS_APP_SM_RootUserCheck(void)
{
return HITLS_APP_SUCCESS;
}
#endif
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(AppInit(), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_KdfMain(argc, argv), expectRet);
EXIT:
AppUninit();
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(AppInit(), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_KdfMain(argc, argv), HITLS_APP_SUCCESS);
ASSERT_EQ(CompareOutByData(outFile, expectData), HITLS_APP_SUCCESS);
EXIT:
AppUninit();
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(AppInit(), 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:
AppUninit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_kdf_TC003
* @title Test the sm mode of the kdf command.
* @brief Enter parameters and return HITLS_APP_SUCCESS.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_kdf_TC003(char *outFile, Hex *expectData)
{
#ifndef HITLS_APP_SM_MODE
(void)outFile;
(void)expectData;
SKIP_TEST();
#else
system("rm -rf " WORK_PATH);
system("mkdir -p " WORK_PATH);
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);;
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);;
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);;
char *argv[] = {"kdf", SM_PARAM, "-mac", "hmac-sm3", "-pass", "passwordPASSWORDpassword",
"-salt", "saltSALTsaltSALTsaltSALTsaltSALTsalt", "-keylen", "40", "-out", outFile,
"-iter", "1024", "pbkdf2", NULL};
ASSERT_EQ(AppInit(), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_KdfMain(sizeof(argv) / sizeof(argv[0]) - 1, argv), HITLS_APP_SUCCESS);
ASSERT_EQ(CompareOutByData(outFile, expectData), HITLS_APP_SUCCESS);
EXIT:
AppUninit();
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
system("rm -rf " WORK_PATH);
remove(outFile);
#endif
}
/* END_CASE */
| 2401_83913325/openHiTLS_1 | testcode/sdv/testcase/apps/test_suite_ut_app_kdf.c | C | unknown | 7,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.
*/
/* 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 "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 */
| 2401_83913325/openHiTLS_1 | testcode/sdv/testcase/apps/test_suite_ut_app_key.c | C | unknown | 13,337 |
/*
* 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 <dirent.h>
#include <unistd.h>
#include <fcntl.h>
#include "app_enc.h"
#include "app_keymgmt.h"
#include "app_dgst.h"
#include "app_errno.h"
#include "app_help.h"
#include "app_print.h"
#include "app_opt.h"
#include "app_mac.h"
#include "bsl_ui.h"
#include "bsl_uio.h"
#include "securec.h"
#include "crypt_eal_cipher.h"
#include "crypt_eal_rand.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_cmvp.h"
#include "eal_cipher_local.h"
#include "stub_utils.h"
#include "bsl_errno.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 */
/* Platform-specific dynamic library extension for testing */
#ifdef __APPLE__
#define BSL_SAL_DL_EXT "dylib"
#else
#define BSL_SAL_DL_EXT "so"
#endif
/* ============================================================================
* Stub Definitions
* ============================================================================ */
STUB_DEFINE_RET5(int32_t, BSL_UI_ReadPwdUtil, BSL_UI_ReadPwdParam *, char *, uint32_t *, const BSL_UI_CheckDataCallBack, void *);
STUB_DEFINE_RET1(int32_t, HITLS_APP_SM_IntegrityCheck, AppProvider *);
STUB_DEFINE_RET0(int32_t, HITLS_APP_SM_RootUserCheck);
#ifdef HITLS_APP_SM_MODE
#define WORK_PATH "./keymgmt_workpath"
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
#define SUFFIX ".p12"
#define SYNC_DATA_FILE "./keymgmt_workpath/sync_data.bin"
#ifdef HITLS_CRYPTO_CMVP_SM_PURE_C
#define HITLS_SM_PROVIDER_PATH "../../output/CMVP/C/lib"
#endif
#ifdef HITLS_CRYPTO_CMVP_SM_ARMV8_LE
#define HITLS_SM_PROVIDER_PATH "../../output/CMVP/armv8_le/lib"
#endif
#ifdef HITLS_CRYPTO_CMVP_SM_X86_64
#define HITLS_SM_PROVIDER_PATH "../../output/CMVP/x86_64/lib"
#endif
#define HITLS_SM_LIB_NAME "libhitls_sm." BSL_SAL_DL_EXT
#define HITLS_SM_PROVIDER_ATTR "provider=sm"
#define SM_PARAM \
"-sm", "-workpath", WORK_PATH, \
"-provider", HITLS_SM_LIB_NAME, \
"-provider-path", HITLS_SM_PROVIDER_PATH, \
"-provider-attr", HITLS_SM_PROVIDER_ATTR
static AppProvider g_appProvider = {HITLS_SM_LIB_NAME, HITLS_SM_PROVIDER_PATH, HITLS_SM_PROVIDER_ATTR};
static int32_t AppTestInit(void)
{
system("rm -rf " WORK_PATH);
system("mkdir -p " WORK_PATH);
int32_t ret = AppPrintErrorUioInit(stderr);
if (ret != HITLS_APP_SUCCESS) {
return ret;
}
if (APP_GetCurrent_LibCtx() == NULL) {
if (APP_Create_LibCtx() == NULL) {
AppPrintError("Create g_libCtx failed\n");
return HITLS_APP_INVALID_ARG;
}
}
return HITLS_APP_SUCCESS;
}
static void AppTestUninit(void)
{
HITLS_APP_FreeLibCtx();
AppPrintErrorUioUnInit();
system("rm -rf " WORK_PATH);
}
static 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[] = "a1234567";
(void)strcpy_s(buff, *buffLen, result);
*buffLen = (uint32_t)strlen(buff) + 1;
return BSL_SUCCESS;
}
static int32_t STUB_HITLS_APP_SM_IntegrityCheck(AppProvider *provider)
{
(void)provider;
return HITLS_APP_SUCCESS;
}
static int32_t STUB_HITLS_APP_SM_RootUserCheck(void)
{
return HITLS_APP_SUCCESS;
}
static int has_suffix(const char *filename, const char *suffix)
{
size_t len_filename = strlen(filename);
size_t len_suffix = strlen(suffix);
if (len_filename >= len_suffix) {
return strcmp(filename + len_filename - len_suffix, suffix) == 0;
}
return 0;
}
static char *GetUuidFromP12(const char *directory)
{
struct dirent *entry;
DIR *dp = opendir(directory);
if (dp == NULL) {
return NULL;
}
bool found = false;
while ((entry = readdir(dp))) {
if (entry->d_type == DT_REG && has_suffix(entry->d_name, SUFFIX)) {
found = true;
break;
}
}
if (!found) {
closedir(dp);
return NULL;
}
uint32_t len = strlen(entry->d_name) - strlen(SUFFIX) + 1;
char *uuid = BSL_SAL_Malloc(len);
if (uuid == NULL) {
closedir(dp);
return NULL;
}
(void)memcpy_s(uuid, len, entry->d_name, len - 1);
uuid[len - 1] = '\0';
closedir(dp);
return uuid;
}
// Get the list of all UUIDs in the directory
static int32_t GetAllUuidsFromDirectory(const char *directory, char **uuidList, int maxCount)
{
struct dirent *entry;
DIR *dp = opendir(directory);
if (dp == NULL) {
return 0;
}
int count = 0;
while ((entry = readdir(dp)) && count < maxCount) {
if (entry->d_type == DT_REG && has_suffix(entry->d_name, SUFFIX)) {
uint32_t len = strlen(entry->d_name) - strlen(SUFFIX) + 1;
uuidList[count] = BSL_SAL_Malloc(len);
if (uuidList[count] == NULL) {
for (int i = 0; i < count; i++) {
BSL_SAL_FREE(uuidList[i]);
}
closedir(dp);
return -1;
}
(void)memcpy_s(uuidList[count], len, entry->d_name, len - 1);
uuidList[count][len - 1] = '\0';
count++;
}
}
closedir(dp);
return count;
}
static int32_t TEST_APP_SM_Init(AppProvider *provider, HITLS_APP_SM_Param *smParam)
{
int32_t ret = CRYPT_EAL_ProviderRandInitCtx(APP_GetCurrent_LibCtx(), CRYPT_RAND_SM4_CTR_DF, HITLS_SM_PROVIDER_ATTR,
NULL, 0, NULL);
if (ret != HITLS_APP_SUCCESS) {
return ret;
}
ret = HITLS_APP_SM_Init(provider, smParam->workPath, (char **)&smParam->password, &smParam->status);
CRYPT_EAL_RandDeinitEx(APP_GetCurrent_LibCtx());
if (ret != HITLS_APP_SUCCESS) {
return ret;
}
smParam->passwordLen = strlen((char *)smParam->password);
return HITLS_APP_SUCCESS;
}
typedef struct {
int fd;
} TLCP_Context;
static int32_t TLCP_Send_Init(void *ctx)
{
TLCP_Context *tlcpCtx = (TLCP_Context *)ctx;
(void)memset_s(tlcpCtx, sizeof(TLCP_Context), 0, sizeof(TLCP_Context));
int fd = open(SYNC_DATA_FILE, O_WRONLY | O_CREAT, 0644);
if (fd == -1) {
AppPrintError("open %s failed, ret: 0x%08x\n", SYNC_DATA_FILE, fd);
return HITLS_APP_UIO_FAIL;
}
tlcpCtx->fd = fd;
return HITLS_APP_SUCCESS;
}
static int32_t TLCP_Receive_Init(void *ctx)
{
TLCP_Context *tlcpCtx = (TLCP_Context *)ctx;
(void)memset_s(tlcpCtx, sizeof(TLCP_Context), 0, sizeof(TLCP_Context));
int fd = open(SYNC_DATA_FILE, O_RDONLY);
if (fd == -1) {
AppPrintError("open %s failed, ret: 0x%08x\n", SYNC_DATA_FILE, fd);
return HITLS_APP_UIO_FAIL;
}
tlcpCtx->fd = fd;
return HITLS_APP_SUCCESS;
}
// transport stubs (to be replaced by TLCP integration)
static int32_t TLCP_Send(void *ctx, const void *data, uint32_t len)
{
TLCP_Context *tlcpCtx = (TLCP_Context *)ctx;
int ret = write(tlcpCtx->fd, data, len);
if (ret < 0 || (uint32_t)ret != len) {
AppPrintError("write %s failed, ret: %d\n", SYNC_DATA_FILE, ret);
return HITLS_APP_UIO_FAIL;
}
return HITLS_APP_SUCCESS;
}
static int32_t TLCP_Receive(void *ctx, void *data, uint32_t len)
{
TLCP_Context *tlcpCtx = (TLCP_Context *)ctx;
int ret = read(tlcpCtx->fd, data, len);
if (ret < 0 || (uint32_t)ret != len) {
AppPrintError("read %s failed, ret: %d\n", SYNC_DATA_FILE, ret);
return HITLS_APP_UIO_FAIL;
}
return HITLS_APP_SUCCESS;
}
static void TLCP_Deinit(void *ctx)
{
if (ctx == NULL) {
return;
}
TLCP_Context *tlcpCtx = (TLCP_Context *)ctx;
close(tlcpCtx->fd);
(void)memset_s(tlcpCtx, sizeof(TLCP_Context), 0, sizeof(TLCP_Context));
}
static int32_t CreateFile(const char *file)
{
FILE *fp = fopen(file, "w");
if (fp == NULL) {
return HITLS_APP_UIO_FAIL;
}
fprintf(fp, "01234567890123456789");
fclose(fp);
return HITLS_APP_SUCCESS;
}
static int32_t CompareFile(const char *file1, const char *file2)
{
FILE *fp1 = fopen(file1, "rb");
FILE *fp2 = fopen(file2, "rb");
if (fp1 == NULL || fp2 == NULL) {
if (fp1 != NULL) fclose(fp1);
if (fp2 != NULL) fclose(fp2);
return HITLS_APP_UIO_FAIL;
}
int result = HITLS_APP_SUCCESS;
char buf1[1024];
char buf2[1024];
size_t bytesRead1, bytesRead2;
do {
bytesRead1 = fread(buf1, 1, sizeof(buf1), fp1);
bytesRead2 = fread(buf2, 1, sizeof(buf2), fp2);
if (bytesRead1 != bytesRead2 || memcmp(buf1, buf2, bytesRead1) != 0) {
result = HITLS_APP_UIO_FAIL;
break;
}
} while (bytesRead1 > 0 && bytesRead2 > 0);
fclose(fp1);
fclose(fp2);
return result;
}
static int32_t EncryptAndDecrypt(char *uuid, char *cipher)
{
char *inFile = WORK_PATH "/test.txt";
char *outFile = WORK_PATH "/test.txt.cipher";
char *outFile2 = WORK_PATH "/test.txt.out";
char *argv[][20] = {
{"enc", "-enc", "-cipher", cipher, "-uuid", uuid, "-in", inFile, "-out", outFile, SM_PARAM},
{"enc", "-dec", "-cipher", cipher, "-uuid", uuid, "-in", outFile, "-out", outFile2, SM_PARAM},
};
int ret = CreateFile(inFile);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = HITLS_EncMain(sizeof(argv[0]) / sizeof(argv[0][0]) - 1, argv[0]);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = HITLS_EncMain(sizeof(argv[1]) / sizeof(argv[1][0]) - 1, argv[1]);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = CompareFile(inFile, outFile2);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
system("rm -f " WORK_PATH "/test.txt");
system("rm -f " WORK_PATH "/test.txt.cipher");
system("rm -f " WORK_PATH "/test.txt.out");
EXIT:
return ret;
}
static int32_t CalculateMac(char *uuid, char *algId)
{
char *inFile = WORK_PATH "/test.txt";
char *outFile = WORK_PATH "/test.txt.mac";
char *argv[][19] = {
{"mac", "-name", algId, "-uuid", uuid, SM_PARAM, "-in", inFile, "-out", outFile},
};
int ret = CreateFile(inFile);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = HITLS_MacMain(sizeof(argv[0]) / sizeof(argv[0][0]) - 1, argv[0]);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
system("rm -f " WORK_PATH "/test.txt");
system("rm -f " WORK_PATH "/test.txt.mac");
EXIT:
return ret;
}
static void DeleteKey(char *uuid)
{
if (uuid == NULL) {
return;
}
char *argv[] = {"keymgmt", "-delete", SM_PARAM, "-uuid", uuid, NULL};
int ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
EXIT:
return;
}
#endif
/**
* @test UT_HITLS_APP_KEYMGMT_TC001
* @spec -
* @title Test keymgmt subcommand: create and find sm4 key
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC001(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
char *uuid = NULL;
char *argv[] = {"keymgmt", "-create", "-algid", "sm4", SM_PARAM, NULL};
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
int ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
uuid = GetUuidFromP12(WORK_PATH);
ASSERT_TRUE(uuid != NULL);
ret = EncryptAndDecrypt(uuid, "sm4_cbc");
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = EncryptAndDecrypt(uuid, "sm4_ecb");
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = EncryptAndDecrypt(uuid, "sm4_ctr");
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = EncryptAndDecrypt(uuid, "sm4_cfb");
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = EncryptAndDecrypt(uuid, "sm4_ofb");
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = EncryptAndDecrypt(uuid, "sm4_gcm");
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
EXIT:
BSL_SAL_FREE(uuid);
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KEYMGMT_TC002
* @spec -
* @title Test keymgmt subcommand: create and find sm4_xts key
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC002(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
char *uuid = NULL;
char *argv[] = {"keymgmt", "-create", "-algid", "sm4_xts", SM_PARAM, NULL};
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
int ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
uuid = GetUuidFromP12(WORK_PATH);
ASSERT_TRUE(uuid != NULL);
ret = EncryptAndDecrypt(uuid, "sm4_xts");
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
EXIT:
BSL_SAL_FREE(uuid);
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
#ifdef HITLS_APP_SM_MODE
static int32_t AsymSignAndVerify(CRYPT_EAL_PkeyCtx *pkeyCtx)
{
uint8_t data[4] = {0, 1, 2, 3};
uint32_t dataLen = sizeof(data);
uint8_t sign[1024] = {0};
uint32_t signLen = sizeof(sign);
int32_t ret = CRYPT_EAL_ProviderRandInitCtx(APP_GetCurrent_LibCtx(), CRYPT_RAND_SM4_CTR_DF, HITLS_SM_PROVIDER_ATTR,
NULL, 0, NULL);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = CRYPT_EAL_PkeySign(pkeyCtx, CRYPT_MD_SM3, data, dataLen, sign, &signLen);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = CRYPT_EAL_PkeyVerify(pkeyCtx, CRYPT_MD_SM3, data, dataLen, sign, signLen);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
EXIT:
CRYPT_EAL_RandDeinitEx(APP_GetCurrent_LibCtx());
return ret;
}
#endif
/**
* @test UT_HITLS_APP_KEYMGMT_TC003
* @spec -
* @title Test keymgmt subcommand: create and find sm2 key
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC003(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
HITLS_APP_SM_Param smParam = {NULL, 0, WORK_PATH, NULL, 0, HITLS_APP_SM_STATUS_CLOSE};
HITLS_APP_KeyInfo keyInfo = {0};
char *argv[] = {"keymgmt", "-create", "-algid", "sm2", SM_PARAM, NULL};
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
int ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
smParam.uuid = GetUuidFromP12(WORK_PATH);
ASSERT_TRUE(smParam.uuid != NULL);
ret = TEST_APP_SM_Init(&g_appProvider, &smParam);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = HITLS_APP_FindKey(&g_appProvider, &smParam, CRYPT_PKEY_SM2, &keyInfo);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = AsymSignAndVerify(keyInfo.pkeyCtx);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(keyInfo.pkeyCtx);
BSL_SAL_FREE(smParam.uuid);
BSL_SAL_FREE(smParam.password);
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KEYMGMT_TC004
* @spec -
* @title Test keymgmt subcommand: unsupported algorithm id on create; expect failure
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC004(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
char *argv[] = {"keymgmt", "-create", "-algid", "aes128_cbc", SM_PARAM, NULL};
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
int ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_OPT_VALUE_INVALID);
EXIT:
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KEYMGMT_TC005
* @spec -
* @title Test keymgmt subcommand: invalid parameter scenarios; expect failure
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC005(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
// Case 1: Missing operation parameter (-create or -delete)
char *argv1[] = {"keymgmt", "-algid", "sm2", SM_PARAM, NULL};
int ret = HITLS_KeyMgmtMain(sizeof(argv1) / sizeof(argv1[0]) - 1, argv1);
ASSERT_EQ(ret, HITLS_APP_OPT_VALUE_INVALID);
// Case 2: Missing -sm parameter
char *argv2[] = {"keymgmt", "-create", "-algid", "sm2", "-workpath", WORK_PATH, NULL};
ret = HITLS_KeyMgmtMain(sizeof(argv2) / sizeof(argv2[0]) - 1, argv2);
ASSERT_EQ(ret, HITLS_APP_OPT_VALUE_INVALID);
// Case 3: Missing -workpath parameter
char *argv3[] = {"keymgmt", "-create", "-algid", "sm2", "-sm", NULL};
ret = HITLS_KeyMgmtMain(sizeof(argv3) / sizeof(argv3[0]) - 1, argv3);
ASSERT_EQ(ret, HITLS_APP_OPT_VALUE_INVALID);
// Case 4: Missing -algid parameter (during key creation)
char *argv4[] = {"keymgmt", "-create", SM_PARAM, NULL};
ret = HITLS_KeyMgmtMain(sizeof(argv4) / sizeof(argv4[0]) - 1, argv4);
ASSERT_EQ(ret, HITLS_APP_OPT_VALUE_INVALID);
// Case 5: Missing -uuid parameter (during key deletion)
char *argv5[] = {"keymgmt", "-delete", SM_PARAM, NULL};
ret = HITLS_KeyMgmtMain(sizeof(argv5) / sizeof(argv5[0]) - 1, argv5);
ASSERT_EQ(ret, HITLS_APP_OPT_VALUE_INVALID);
// Case 6: Specify both -create and -delete (conflicting operations)
char *argv6[] = {"keymgmt", "-create", "-delete", "-algid", "sm2", SM_PARAM, NULL};
ret = HITLS_KeyMgmtMain(sizeof(argv6) / sizeof(argv6[0]) - 1, argv6);
ASSERT_EQ(ret, HITLS_APP_OPT_VALUE_INVALID);
// Case 7: Empty argument list
char *argv7[] = {"keymgmt", NULL};
ret = HITLS_KeyMgmtMain(sizeof(argv7) / sizeof(argv7[0]) - 1, argv7);
ASSERT_EQ(ret, HITLS_APP_OPT_VALUE_INVALID);
EXIT:
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KEYMGMT_TC006
* @spec -
* @title Test keymgmt subcommand: invalid derivation parameters; expect failure
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC006(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
// Case 1: Invalid derivation parameters
char *argv1[] = {"keymgmt", "-create", "-algid", "sm2", SM_PARAM, "-iter", "1023", NULL};
int ret = HITLS_KeyMgmtMain(sizeof(argv1) / sizeof(argv1[0]) - 1, argv1);
ASSERT_EQ(ret, HITLS_APP_OPT_VALUE_INVALID);
char *argv2[] = {"keymgmt", "-create", "-algid", "sm2", SM_PARAM, "-iter", "-1024", NULL};
ret = HITLS_KeyMgmtMain(sizeof(argv2) / sizeof(argv2[0]) - 1, argv2);
ASSERT_EQ(ret, HITLS_APP_OPT_UNKOWN);
// Case 2: Invalid salt length
char *argv3[] = {"keymgmt", "-create", "-algid", "sm2", SM_PARAM, "-saltlen", "7", NULL};
ret = HITLS_KeyMgmtMain(sizeof(argv3) / sizeof(argv3[0]) - 1, argv3);
ASSERT_EQ(ret, HITLS_APP_OPT_VALUE_INVALID);
char *argv4[] = {"keymgmt", "-create", "-algid", "sm2", SM_PARAM, "-saltlen", "-8", NULL};
ret = HITLS_KeyMgmtMain(sizeof(argv4) / sizeof(argv4[0]) - 1, argv4);
ASSERT_EQ(ret, HITLS_APP_OPT_UNKOWN);
EXIT:
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KEYMGMT_TC007
* @spec -
* @title Test keymgmt subcommand: delete key with single UUID; expect success
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC007(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
char *uuid = NULL;
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
// First create a key
char *argv_create[] = {"keymgmt", "-create", "-algid", "sm2", SM_PARAM, NULL};
int ret = HITLS_KeyMgmtMain(sizeof(argv_create) / sizeof(argv_create[0]) - 1, argv_create);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
// Get the created key UUID
uuid = GetUuidFromP12(WORK_PATH);
ASSERT_TRUE(uuid != NULL);
// Verify the key file exists
char keyPath[256];
snprintf(keyPath, sizeof(keyPath), "%s/%s.p12", WORK_PATH, uuid);
FILE *fp = fopen(keyPath, "r");
ASSERT_TRUE(fp != NULL);
fclose(fp);
// Test deleting a key - pass a single UUID
char *argv_delete[] = {"keymgmt", "-delete", SM_PARAM, "-uuid", uuid, NULL};
ret = HITLS_KeyMgmtMain(sizeof(argv_delete) / sizeof(argv_delete[0]) - 1, argv_delete);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
// Verify the key file has been deleted
fp = fopen(keyPath, "r");
ASSERT_TRUE(fp == NULL);
EXIT:
BSL_SAL_FREE(uuid);
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KEYMGMT_TC008
* @spec -
* @title Test keymgmt subcommand: delete key with single UUID; key not found; expect failure
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC008(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
// Test deleting a non-existent key - pass a randomly generated UUID
char fakeUuid[] = "1234567890abcdef1234567890abcdef";
char *argv_delete[] = {"keymgmt", "-delete", SM_PARAM, "-uuid", fakeUuid, NULL};
int ret = HITLS_KeyMgmtMain(sizeof(argv_delete) / sizeof(argv_delete[0]) - 1, argv_delete);
// Should return failure because the key does not exist
ASSERT_NE(ret, HITLS_APP_SUCCESS);
// Verify there is indeed no corresponding key file in the work directory
char keyPath[256];
snprintf(keyPath, sizeof(keyPath), "%s/%s.p12", WORK_PATH, fakeUuid);
FILE *fp = fopen(keyPath, "r");
ASSERT_TRUE(fp == NULL);
EXIT:
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KEYMGMT_TC009
* @spec -
* @title Test keymgmt subcommand: delete keys with multiple UUIDs; expect success
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC009(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
char *uuid1 = NULL;
char *uuidArray[10] = {NULL};
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
// Create the first key
char *argv_create1[] = {"keymgmt", "-create", "-algid", "sm2", SM_PARAM, NULL};
int ret = HITLS_KeyMgmtMain(sizeof(argv_create1) / sizeof(argv_create1[0]) - 1, argv_create1);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
// Create the second key
char *argv_create2[] = {"keymgmt", "-create", "-algid", "sm4", SM_PARAM, NULL};
ret = HITLS_KeyMgmtMain(sizeof(argv_create2) / sizeof(argv_create2[0]) - 1, argv_create2);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
// Get the list of created key UUIDs
uuid1 = GetUuidFromP12(WORK_PATH);
ASSERT_TRUE(uuid1 != NULL);
// Get all UUIDs in the directory
int uuidCount = GetAllUuidsFromDirectory(WORK_PATH, uuidArray, 10);
ASSERT_EQ(uuidCount, 2); // There should be two keys
// Find a UUID different from uuid1
char *uuid2 = NULL;
for (int i = 0; i < uuidCount; i++) {
if (strcmp(uuidArray[i], uuid1) != 0) {
uuid2 = uuidArray[i];
break;
}
}
ASSERT_TRUE(uuid2 != NULL);
// Verify both key files exist
char keyPath1[256], keyPath2[256];
snprintf(keyPath1, sizeof(keyPath1), "%s/%s.p12", WORK_PATH, uuid1);
snprintf(keyPath2, sizeof(keyPath2), "%s/%s.p12", WORK_PATH, uuid2);
FILE *fp1 = fopen(keyPath1, "r");
ASSERT_TRUE(fp1 != NULL);
fclose(fp1);
FILE *fp2 = fopen(keyPath2, "r");
ASSERT_TRUE(fp2 != NULL);
fclose(fp2);
// Test deleting multiple keys - pass multiple UUIDs (comma-separated)
char uuidList[256];
snprintf(uuidList, sizeof(uuidList), "%s,%s", uuid1, uuid2);
char *argv_delete[] = {"keymgmt", "-delete", SM_PARAM, "-uuid", uuidList, NULL};
ret = HITLS_KeyMgmtMain(sizeof(argv_delete) / sizeof(argv_delete[0]) - 1, argv_delete);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
// Verify both key files have been deleted
fp1 = fopen(keyPath1, "r");
fp2 = fopen(keyPath2, "r");
ASSERT_TRUE(fp1 == NULL);
ASSERT_TRUE(fp2 == NULL);
EXIT:
BSL_SAL_FREE(uuid1);
// Free memory allocated in uuidArray
for (int i = 0; i < 10; i++) {
if (uuidArray[i] != NULL) {
BSL_SAL_FREE(uuidArray[i]);
}
}
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KEYMGMT_TC010
* @spec -
* @title Test keymgmt subcommand: delete with multiple UUIDs; some missing; expect failure; earlier existing keys deleted in order
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC010(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
// Create the first key
char *argv_create1[] = {"keymgmt", "-create", "-algid", "sm2", SM_PARAM, NULL};
int ret = HITLS_KeyMgmtMain(sizeof(argv_create1) / sizeof(argv_create1[0]) - 1, argv_create1);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
// Get the created key UUID
char *uuid1 = GetUuidFromP12(WORK_PATH);
ASSERT_TRUE(uuid1 != NULL);
// Verify the key file exists
char keyPath1[256];
snprintf(keyPath1, sizeof(keyPath1), "%s/%s.p12", WORK_PATH, uuid1);
FILE *fp1 = fopen(keyPath1, "r");
ASSERT_TRUE(fp1 != NULL);
fclose(fp1);
// Construct a list containing existing and non-existing UUIDs
char fakeUuid[] = "1234567890abcdef1234567890abcdef";
char uuidList[256];
// Note: Put the existing UUID first and the non-existing one after, to verify ordered deletion logic
snprintf(uuidList, sizeof(uuidList), "%s,%s", uuid1, fakeUuid);
char *argv_delete[] = {"keymgmt", "-delete", SM_PARAM, "-uuid", uuidList, NULL};
ret = HITLS_KeyMgmtMain(sizeof(argv_delete) / sizeof(argv_delete[0]) - 1, argv_delete);
// Should return failure because some UUIDs do not have corresponding keys
ASSERT_NE(ret, HITLS_APP_SUCCESS);
// Verify the existing key file has been deleted (processed first due to order)
fp1 = fopen(keyPath1, "r");
ASSERT_TRUE(fp1 == NULL);
// Verify the non-existent key file indeed does not exist
char keyPath2[256];
snprintf(keyPath2, sizeof(keyPath2), "%s/%s.p12", WORK_PATH, fakeUuid);
FILE *fp2 = fopen(keyPath2, "r");
ASSERT_TRUE(fp2 == NULL);
EXIT:
BSL_SAL_FREE(uuid1);
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KEYMGMT_TC011
* @spec -
* @title Test keymgmt subcommand: find key API with UUID; find sm4-ofb key success (keyLen 16); sm4_xts returns failure
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC011(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
HITLS_APP_KeyInfo keyInfo = {0};
HITLS_APP_SM_Param smParam = {NULL, 0, WORK_PATH, NULL, 0, HITLS_APP_SM_STATUS_CLOSE};
// Create an sm4 key instead of an sm2 key
char *argv[] = {"keymgmt", "-create", "-algid", "sm4", SM_PARAM, NULL};
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
int ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
smParam.uuid = GetUuidFromP12(WORK_PATH);
ASSERT_TRUE(smParam.uuid != NULL);
ret = TEST_APP_SM_Init(&g_appProvider, &smParam);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
// Find sm4-ofb key
ret = HITLS_APP_FindKey(&g_appProvider, &smParam, CRYPT_CIPHER_SM4_OFB, &keyInfo);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
// Verify key info
ASSERT_TRUE(keyInfo.key != NULL);
ASSERT_EQ(keyInfo.keyLen, 16); // sm4 key length should be 16 bytes
// Find sm4_xts key; expect failure
ret = HITLS_APP_FindKey(&g_appProvider, &smParam, CRYPT_CIPHER_SM4_XTS, &keyInfo);
ASSERT_EQ(ret, HITLS_APP_INVALID_ARG);
EXIT:
BSL_SAL_FREE(smParam.uuid);
BSL_SAL_FREE(smParam.password);
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KEYMGMT_TC012
* @spec -
* @title Test keymgmt subcommand: find key API with UUID; find sm4_xts key success (keyLen 32); sm4-ofb returns failure
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC012(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
HITLS_APP_KeyInfo keyInfo = {0};
HITLS_APP_SM_Param smParam = {NULL, 0, WORK_PATH, NULL, 0, HITLS_APP_SM_STATUS_CLOSE};
// Create an sm4_xts key instead of an sm2 key
char *argv[] = {"keymgmt", "-create", "-algid", "sm4_xts", SM_PARAM, NULL};
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
int ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
smParam.uuid = GetUuidFromP12(WORK_PATH);
ASSERT_TRUE(smParam.uuid != NULL);
ret = TEST_APP_SM_Init(&g_appProvider, &smParam);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
// Find sm4_xts key
ret = HITLS_APP_FindKey(&g_appProvider, &smParam, CRYPT_CIPHER_SM4_XTS, &keyInfo);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
// Verify key info
ASSERT_TRUE(keyInfo.key != NULL);
ASSERT_EQ(keyInfo.keyLen, 32); // sm4_xts key length should be 32 bytes
// Find sm4-ofb key; expect failure
ret = HITLS_APP_FindKey(&g_appProvider, &smParam, CRYPT_CIPHER_SM4_OFB, &keyInfo);
ASSERT_EQ(ret, HITLS_APP_INVALID_ARG);
EXIT:
BSL_SAL_FREE(smParam.uuid);
BSL_SAL_FREE(smParam.password);
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KEYMGMT_TC013
* @spec -
* @title Test keymgmt subcommand: create MAC key; compute MAC via CLI; expect success
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC013(char *macAlgId)
{
#ifndef HITLS_APP_SM_MODE
(void)macAlgId;
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
char *uuid = NULL;
char *argv[] = {"keymgmt", "-create", "-algid", macAlgId, SM_PARAM, NULL};
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
int ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
uuid = GetUuidFromP12(WORK_PATH);
ASSERT_TRUE(uuid != NULL);
ret = CalculateMac(uuid, macAlgId);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
EXIT:
BSL_SAL_FREE(uuid);
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KEYMGMT_TC014
* @spec -
* @title Test keymgmt subcommand: find key API with UUID; find MAC key success; keyLen equals algorithm keyLen
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC014(int algId, char *macAlgId, int keyLen)
{
#ifndef HITLS_APP_SM_MODE
(void)algId;
(void)macAlgId;
(void)keyLen;
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
HITLS_APP_KeyInfo keyInfo = {0};
HITLS_APP_SM_Param smParam = {NULL, 0, WORK_PATH, NULL, 0, HITLS_APP_SM_STATUS_CLOSE};
// Create a MAC key
char *argv[] = {"keymgmt", "-create", "-algid", macAlgId, SM_PARAM, NULL};
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
int ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
smParam.uuid = GetUuidFromP12(WORK_PATH);
ASSERT_TRUE(smParam.uuid != NULL);
ret = TEST_APP_SM_Init(&g_appProvider, &smParam);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
// Find MAC key
ret = HITLS_APP_FindKey(&g_appProvider, &smParam, algId, &keyInfo);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
// Verify key info
ASSERT_TRUE(keyInfo.key != NULL);
ASSERT_EQ(keyInfo.keyLen, keyLen);
ASSERT_EQ(keyInfo.attr.algId, algId);
EXIT:
BSL_SAL_FREE(smParam.uuid);
BSL_SAL_FREE(smParam.password);
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KEYMGMT_TC015
* @spec -
* @title Test keymgmt subcommand: find key API with UUID; find sm2 key success; pkeyCtx not NULL
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC015(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
HITLS_APP_KeyInfo keyInfo = {0};
HITLS_APP_SM_Param smParam = {NULL, 0, WORK_PATH, NULL, 0, HITLS_APP_SM_STATUS_CLOSE};
// Create an sm2 key
char *argv[] = {"keymgmt", "-create", "-algid", "sm2", SM_PARAM, NULL};
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
int ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
smParam.uuid = GetUuidFromP12(WORK_PATH);
ASSERT_TRUE(smParam.uuid != NULL);
ret = TEST_APP_SM_Init(&g_appProvider, &smParam);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
// Find sm2 key
ret = HITLS_APP_FindKey(&g_appProvider, &smParam, CRYPT_PKEY_SM2, &keyInfo);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
// Verify key info
ASSERT_TRUE(keyInfo.pkeyCtx != NULL); // pkeyCtx is not NULL
ASSERT_EQ(keyInfo.attr.algId, CRYPT_PKEY_SM2);
// Test SM2 key signing and verification
ret = AsymSignAndVerify(keyInfo.pkeyCtx);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
char *argv2[] = {"keymgmt", "-getpub", "-uuid", smParam.uuid, SM_PARAM, NULL};
ret = HITLS_KeyMgmtMain(sizeof(argv2) / sizeof(argv2[0]) - 1, argv2);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(keyInfo.pkeyCtx);
BSL_SAL_FREE(smParam.uuid);
BSL_SAL_FREE(smParam.password);
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KEYMGMT_TC016
* @spec -
* @title Test keymgmt subcommand: find key API with UUID; find sm2 key with wrong password; PKCS12 decryption fails
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC016(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
HITLS_APP_SM_Param smParam = {NULL, 0, WORK_PATH, NULL, 0, HITLS_APP_SM_STATUS_CLOSE};
// Create an sm2 key
char *argv[] = {"keymgmt", "-create", "-algid", "sm2", SM_PARAM, NULL};
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
int ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
smParam.uuid = GetUuidFromP12(WORK_PATH);
ASSERT_TRUE(smParam.uuid != NULL);
HITLS_APP_KeyInfo keyInfo = {0};
ret = TEST_APP_SM_Init(&g_appProvider, &smParam);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
// Attempt to decrypt PKCS12 with a wrong password: flip the first byte of the correct password
smParam.password[0] = ~smParam.password[0];
// Finding sm2 key should fail (PKCS12 decryption failure)
ret = HITLS_APP_FindKey(&g_appProvider, &smParam, CRYPT_PKEY_SM2, &keyInfo);
ASSERT_EQ(ret, HITLS_APP_X509_FAIL);
EXIT:
BSL_SAL_FREE(smParam.uuid);
BSL_SAL_FREE(smParam.password);
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC017(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
uint8_t data[4] = {0, 1, 2, 3};
uint32_t dataLen = sizeof(data);
uint8_t sign[1024] = {0};
uint32_t signLen = sizeof(sign);
HITLS_APP_SM_Param smParam = {NULL, 0, WORK_PATH, NULL, 0, HITLS_APP_SM_STATUS_CLOSE};
HITLS_APP_KeyInfo keyInfo = {0};
char *argv[] = {"keymgmt", "-create", "-algid", "sm2", SM_PARAM, NULL};
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
int ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
smParam.uuid = GetUuidFromP12(WORK_PATH);
ASSERT_TRUE(smParam.uuid != NULL);
ret = TEST_APP_SM_Init(&g_appProvider, &smParam);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = HITLS_APP_FindKey(&g_appProvider, &smParam, CRYPT_PKEY_SM2, &keyInfo);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = CRYPT_EAL_ProviderRandInitCtx(APP_GetCurrent_LibCtx(), CRYPT_RAND_SM4_CTR_DF, "provider=sm", NULL, 0, NULL);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = CRYPT_EAL_PkeySign(keyInfo.pkeyCtx, CRYPT_MD_SM3, data, dataLen, sign, &signLen);
CRYPT_EAL_RandDeinitEx(APP_GetCurrent_LibCtx());
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
CRYPT_EAL_PkeyFreeCtx(keyInfo.pkeyCtx);
(void)memset_s(&keyInfo, sizeof(keyInfo), 0, sizeof(keyInfo));
TLCP_Context tlcpCtx = {0};
ret = TLCP_Send_Init(&tlcpCtx);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = HITLS_APP_SendKey(&g_appProvider, &smParam, TLCP_Send, &tlcpCtx);
TLCP_Deinit(&tlcpCtx);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
DeleteKey(smParam.uuid);
ret = TLCP_Receive_Init(&tlcpCtx);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = CRYPT_EAL_ProviderRandInitCtx(APP_GetCurrent_LibCtx(), CRYPT_RAND_SM4_CTR_DF, "provider=sm", NULL, 0, NULL);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = HITLS_APP_ReceiveKey(&g_appProvider, &smParam, -1, -1, TLCP_Receive, &tlcpCtx);
CRYPT_EAL_RandDeinitEx(APP_GetCurrent_LibCtx());
TLCP_Deinit(&tlcpCtx);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = HITLS_APP_FindKey(&g_appProvider, &smParam, CRYPT_PKEY_SM2, &keyInfo);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = CRYPT_EAL_PkeyVerify(keyInfo.pkeyCtx, CRYPT_MD_SM3, data, dataLen, sign, signLen);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
EXIT:
CRYPT_EAL_PkeyFreeCtx(keyInfo.pkeyCtx);
BSL_SAL_FREE(smParam.uuid);
BSL_SAL_FREE(smParam.password);
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KEYMGMT_TC018
* @spec -
* @title Test keymgmt subcommand: erase all keys interface; expect success
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC018(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
char *argv[] = {"keymgmt", "-create", "-algid", "sm4", SM_PARAM, NULL};
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
int ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
char *argv2[] = {"keymgmt", "-erasekey", SM_PARAM, NULL};
ret = HITLS_KeyMgmtMain(sizeof(argv2) / sizeof(argv2[0]) - 1, argv2);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
EXIT:
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KEYMGMT_TC019
* @spec -
* @title Test keymgmt subcommand: get status interface; expect success
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC019(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
char *argv[] = {"keymgmt", "-getstatus", SM_PARAM, NULL};
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
int ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
EXIT:
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KEYMGMT_TC020
* @spec -
* @title Test keymgmt subcommand: get version interface; expect success
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC020(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
char *argv[] = {"keymgmt", "-getversion", SM_PARAM, NULL};
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
int ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
EXIT:
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KEYMGMT_TC021
* @spec -
* @title Test keymgmt subcommand: self-test interface; expect success
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC021(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
char *argv[] = {"keymgmt", "-selftest", SM_PARAM, NULL};
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
int ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
EXIT:
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
#ifdef HITLS_APP_SM_MODE
static int32_t SM2SignAndVerify(char *uuid)
{
char *inFile = WORK_PATH "/test.txt";
char *outFile = WORK_PATH "/test.signature";
char pubkey[256] = {0};
(void)sprintf_s(pubkey, sizeof(pubkey), "%s/%s-pub.pem", WORK_PATH, uuid);
char *argv[] = {"dgst", "-md", "sm3", "-sign", uuid, SM_PARAM, "-out", outFile, inFile, NULL};
char *argv2[] = {"dgst", "-md", "sm3", "-verify", pubkey, SM_PARAM, "-signature", outFile, inFile, NULL};
int ret = CreateFile(inFile);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = HITLS_DgstMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = HITLS_DgstMain(sizeof(argv2) / sizeof(argv2[0]) - 1, argv2);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
system("rm -f " WORK_PATH "/test.txt");
system("rm -f " WORK_PATH "/test.signature");
EXIT:
return ret;
}
#endif
/**
* @test UT_HITLS_APP_KEYMGMT_SM2_SIGN_VERIFY_TEST
* @spec -
* @title Test sm mode sm2 sign and verify interface; expect success
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_SM2_SIGN_VERIFY_TEST(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_REPLACE(BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_REPLACE(HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
STUB_REPLACE(HITLS_APP_SM_RootUserCheck, STUB_HITLS_APP_SM_RootUserCheck);
char *uuid = NULL;
char *argv[] = {"keymgmt", "-create", "-algid", "sm2", SM_PARAM, NULL};
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
int ret = HITLS_KeyMgmtMain(sizeof(argv) / sizeof(argv[0]) - 1, argv);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
uuid = GetUuidFromP12(WORK_PATH);
ASSERT_TRUE(uuid != NULL);
char *argv2[] = {"keymgmt", "-getpub", "-uuid", uuid, SM_PARAM, NULL};
ret = HITLS_KeyMgmtMain(sizeof(argv2) / sizeof(argv2[0]) - 1, argv2);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = SM2SignAndVerify(uuid);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
EXIT:
BSL_SAL_FREE(uuid);
AppTestUninit();
STUB_RESTORE(BSL_UI_ReadPwdUtil);
STUB_RESTORE(HITLS_APP_SM_IntegrityCheck);
STUB_RESTORE(HITLS_APP_SM_RootUserCheck);
#endif
}
/* END_CASE */
| 2401_83913325/openHiTLS_1 | testcode/sdv/testcase/apps/test_suite_ut_app_keymgmt.c | C | unknown | 48,775 |
/*
* 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_utils.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 */ | 2401_83913325/openHiTLS_1 | testcode/sdv/testcase/apps/test_suite_ut_app_list.c | C | unknown | 2,834 |
/*
* 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 <limits.h>
#include "securec.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 */
| 2401_83913325/openHiTLS_1 | testcode/sdv/testcase/apps/test_suite_ut_app_mac.c | C | unknown | 4,159 |