code
stringlengths 1
1.05M
| repo_name
stringlengths 6
83
| path
stringlengths 3
242
| language
stringclasses 222
values | license
stringclasses 20
values | size
int64 1
1.05M
|
|---|---|---|---|---|---|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#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
|
2301_79861745/bench_create
|
testcode/framework/tls/crypt/include/stub_crypt.h
|
C
|
unknown
| 788
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include <stdint.h>
#include <stddef.h>
#include "hitls_build.h"
#include "securec.h"
#include "bsl_sal.h"
#include "hitls_crypt_reg.h"
#include "hitls_error.h"
#include "hs_common.h"
#include "config_type.h"
#include "stub_replace.h"
#include "crypt_default.h"
#ifdef HITLS_TLS_FEATURE_PROVIDER
#include "hitls_crypt.h"
#include "crypt_eal_rand.h"
#endif
#define MD5_DIGEST_LENGTH 16
#define SHA1_DIGEST_LENGTH 20
#define SHA256_DIGEST_LENGTH 32
#define SHA384_DIGEST_LENGTH 48
#define SHA512_DIGEST_LENGTH 64
#define SM3_DIGEST_LENGTH 32
#define AEAD_TAG_LENGTH 16
typedef struct {
HITLS_HashAlgo algo;
uint8_t *key;
uint32_t keyLen;
} FRAME_HmacCtx;
typedef struct {
HITLS_HashAlgo algo;
} FRAME_HashCtx;
typedef struct {
uint8_t *pubKey;
uint32_t pubKeyLen;
uint8_t *privateKey;
uint32_t privateKeyLen;
} FRAME_EcdhKey;
typedef struct {
uint8_t *p;
uint8_t *g;
uint16_t plen;
uint16_t glen;
uint8_t *pubKey;
uint32_t pubKeyLen;
uint8_t *privateKey;
uint32_t privateKeyLen;
} FRAME_DhKey;
/**
* @ingroup hitls_crypt_reg
* @brief Obtain the random number
*
* @param buf [OUT] random number
* @param len [IN] random number length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_RandBytesCallback(uint8_t *buf, uint32_t len)
{
if (memset_s(buf, len, 1, len) != EOK) {
return HITLS_MEMCPY_FAIL;
}
return HITLS_SUCCESS;
}
int32_t STUB_CRYPT_RandBytesCallbackLibCtx(void *libCtx, uint8_t *buf, uint32_t len)
{
(void)libCtx;
if (memset_s(buf, len, 1, len) != EOK) {
return HITLS_MEMCPY_FAIL;
}
return HITLS_SUCCESS;
}
/**
* @ingroup hitls_crypt_reg
* @brief Generate a key pair based on the elliptic curve parameters
*
* @param curveParams [IN] Elliptic curve parameters
*
* @return Key handle
*/
HITLS_CRYPT_Key *STUB_CRYPT_GenerateEcdhKeyPairCallback(const HITLS_ECParameters *curveParams)
{
uint32_t keyLen = 0u;
if (curveParams == NULL) {
return NULL;
}
FRAME_EcdhKey *ecdhKey = (FRAME_EcdhKey *)BSL_SAL_Calloc(1u, sizeof(FRAME_EcdhKey));
if (ecdhKey == NULL) {
return NULL;
}
const TLS_GroupInfo *groupInfo = NULL;
switch (curveParams->type) {
case HITLS_EC_CURVE_TYPE_NAMED_CURVE:
groupInfo = ConfigGetGroupInfo(NULL, curveParams->param.namedcurve);
if (groupInfo == NULL) {
BSL_SAL_FREE(ecdhKey);
return NULL;
}
keyLen = groupInfo->pubkeyLen;
break;
default:
break;
}
uint8_t *pubKey = (uint8_t *)BSL_SAL_Malloc(keyLen);
if (pubKey == NULL) {
BSL_SAL_FREE(ecdhKey);
return NULL;
}
memset_s(pubKey, keyLen, 1u, keyLen);
uint8_t *privateKey = (uint8_t *)BSL_SAL_Malloc(keyLen);
if (privateKey == NULL) {
BSL_SAL_FREE(pubKey);
BSL_SAL_FREE(ecdhKey);
return NULL;
}
memset_s(privateKey, keyLen, 2u, keyLen);
ecdhKey->pubKey = pubKey;
ecdhKey->pubKeyLen = keyLen;
ecdhKey->privateKey = privateKey;
ecdhKey->privateKeyLen = keyLen;
return ecdhKey;
}
HITLS_CRYPT_Key *STUB_CRYPT_GenerateEcdhKeyPairCallbackLibCtx(void *libCtx,
const char *attrName, const HITLS_Config *config, const HITLS_ECParameters *curveParams)
{
(void)libCtx;
(void)attrName;
(void)config;
return STUB_CRYPT_GenerateEcdhKeyPairCallback(curveParams);
}
/**
* @ingroup hitls_crypt_reg
* @brief Release the key
*
* @param key [IN] Key handle
*/
void STUB_CRYPT_FreeEcdhKeyCallback(HITLS_CRYPT_Key *key)
{
FRAME_EcdhKey *ecdhKey = (FRAME_EcdhKey *)key;
if (ecdhKey != NULL) {
BSL_SAL_FREE(ecdhKey->pubKey);
BSL_SAL_FREE(ecdhKey->privateKey);
BSL_SAL_FREE(ecdhKey);
}
return;
}
/**
* @ingroup hitls_crypt_reg
* @brief Extract the public key data
*
* @param key [IN] Key handle
* @param pubKeyBuf [OUT] Public key data
* @param bufLen [IN] buffer length
* @param pubKeyLen [OUT] Public key data length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_GetEcdhEncodedPubKeyCallback(HITLS_CRYPT_Key *key, uint8_t *pubKeyBuf, uint32_t bufLen,
uint32_t *pubKeyLen)
{
FRAME_EcdhKey *ecdhKey = (FRAME_EcdhKey *)key;
if ((ecdhKey == NULL) ||
(pubKeyBuf == NULL) ||
(pubKeyLen == NULL) ||
(bufLen < ecdhKey->pubKeyLen)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (memcpy_s(pubKeyBuf, bufLen, ecdhKey->pubKey, ecdhKey->pubKeyLen) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*pubKeyLen = ecdhKey->pubKeyLen;
return HITLS_SUCCESS;
}
/**
* @ingroup hitls_crypt_reg
* @brief Calculate the shared key based on the local key and peer public key
*
* @param key [IN] Key handle
* @param pubKeyBuf [IN] Public key data
* @param pubKeyLen [IN] Public key data length
* @param sharedSecret [OUT] Shared key
* @param sharedSecretLen [IN/OUT] IN: Maximum length of the key padding OUT: Key length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_CalcEcdhSharedSecretCallback(HITLS_CRYPT_Key *key, uint8_t *peerPubkey, uint32_t pubKeyLen,
uint8_t *sharedSecret, uint32_t *sharedSecretLen)
{
FRAME_EcdhKey *ecdhKey = (FRAME_EcdhKey *)key;
if ((ecdhKey == NULL) ||
(peerPubkey == NULL) ||
(sharedSecret == NULL) ||
(sharedSecretLen == NULL) ||
(ecdhKey->privateKeyLen > pubKeyLen) ||
(*sharedSecretLen < pubKeyLen)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (memset_s(sharedSecret, *sharedSecretLen, 3u, pubKeyLen) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*sharedSecretLen = pubKeyLen;
return HITLS_SUCCESS;
}
int32_t STUB_CRYPT_CalcEcdhSharedSecretCallbackLibCtx(void *libCtx, const char *attrName,
HITLS_CRYPT_Key *key, uint8_t *peerPubkey,
uint32_t pubKeyLen, uint8_t *sharedSecret, uint32_t *sharedSecretLen)
{
(void)libCtx;
(void)attrName;
return STUB_CRYPT_CalcEcdhSharedSecretCallback(key, peerPubkey, pubKeyLen, sharedSecret, sharedSecretLen);
}
void STUB_CRYPT_FreeDhKeyCallback(HITLS_CRYPT_Key *key)
{
FRAME_DhKey *dhKey = (FRAME_DhKey *)key;
if (dhKey != NULL) {
BSL_SAL_FREE(dhKey->p);
BSL_SAL_FREE(dhKey->g);
BSL_SAL_FREE(dhKey->privateKey);
BSL_SAL_FREE(dhKey->pubKey);
BSL_SAL_FREE(dhKey);
}
return;
}
HITLS_CRYPT_Key *STUB_CRYPT_GenerateDhKeyBySecbitsCallback(int32_t secbits)
{
uint16_t plen;
if (secbits >= 192) {
plen = 1024;
} else if (secbits >= 152) {
plen = 512;
} else if (secbits >= 128) {
plen = 384;
} else if (secbits >= 112) {
plen = 256;
} else {
plen = 128;
}
FRAME_DhKey *dhKey = (FRAME_DhKey *)BSL_SAL_Calloc(1u, sizeof(FRAME_DhKey));
if (dhKey == NULL) {
return NULL;
}
dhKey->p = BSL_SAL_Calloc(1u, plen);
if (dhKey->p == NULL) {
BSL_SAL_FREE(dhKey);
return NULL;
}
memset_s(dhKey->p, plen, 1u, plen);
dhKey->plen = plen;
dhKey->g = BSL_SAL_Calloc(1u, plen);
if (dhKey->g == NULL) {
STUB_CRYPT_FreeDhKeyCallback(dhKey);
return NULL;
}
memset_s(dhKey->g, plen, 2u, plen);
dhKey->glen = plen;
dhKey->pubKey = BSL_SAL_Calloc(1u, plen);
if (dhKey->pubKey == NULL) {
STUB_CRYPT_FreeDhKeyCallback(dhKey);
return NULL;
}
memset_s(dhKey->pubKey, plen, 3u, plen);
dhKey->pubKeyLen = plen;
dhKey->privateKey = BSL_SAL_Calloc(1u, plen);
if (dhKey->privateKey == NULL) {
STUB_CRYPT_FreeDhKeyCallback(dhKey);
return NULL;
}
memset_s(dhKey->privateKey, plen, 4u, plen);
dhKey->privateKeyLen = plen;
return dhKey;
}
HITLS_CRYPT_Key *STUB_CRYPT_GenerateDhKeyBySecbitsCallbackLibCtx(void *libCtx, const char *attrName, int32_t secbits)
{
(void)libCtx;
(void)attrName;
return STUB_CRYPT_GenerateDhKeyBySecbitsCallback(secbits);
}
HITLS_CRYPT_Key *STUB_CRYPT_GenerateDhKeyByParamsCallback(uint8_t *p, uint16_t plen, uint8_t *g, uint16_t glen)
{
if ((p == NULL) || (plen == 0) || (g == NULL) || (glen == 0)) {
return NULL;
}
FRAME_DhKey *dhKey = (FRAME_DhKey *)BSL_SAL_Calloc(1u, sizeof(FRAME_DhKey));
if (dhKey == NULL) {
return NULL;
}
dhKey->p = BSL_SAL_Dump(p, plen);
if (dhKey->p == NULL) {
BSL_SAL_FREE(dhKey);
return NULL;
}
dhKey->plen = plen;
dhKey->g = BSL_SAL_Dump(g, glen);
if (dhKey->g == NULL) {
STUB_CRYPT_FreeDhKeyCallback(dhKey);
return NULL;
}
dhKey->glen = glen;
dhKey->pubKey = BSL_SAL_Calloc(1u, plen);
if (dhKey->pubKey == NULL) {
STUB_CRYPT_FreeDhKeyCallback(dhKey);
return NULL;
}
if (memset_s(dhKey->pubKey, plen, 3u, plen) != EOK) {
STUB_CRYPT_FreeDhKeyCallback(dhKey);
return NULL;
}
dhKey->pubKeyLen = plen;
dhKey->privateKey = BSL_SAL_Calloc(1u, plen);
if (dhKey->privateKey == NULL) {
STUB_CRYPT_FreeDhKeyCallback(dhKey);
return NULL;
}
if (memset_s(dhKey->privateKey, plen, 4u, plen) != EOK) {
STUB_CRYPT_FreeDhKeyCallback(dhKey);
return NULL;
}
dhKey->privateKeyLen = plen;
return dhKey;
}
HITLS_CRYPT_Key *STUB_CRYPT_GenerateDhKeyByParamsCallbackLibCtx(void *libCtx, const char *attrName,
uint8_t *p, uint16_t plen, uint8_t *g, uint16_t glen)
{
(void)libCtx;
(void)attrName;
return STUB_CRYPT_GenerateDhKeyByParamsCallback(p, plen, g, glen);
}
int32_t STUB_CRYPT_DHGetParametersCallback(HITLS_CRYPT_Key *key, uint8_t *p, uint16_t *plen, uint8_t *g, uint16_t *glen)
{
if ((key == NULL) || (plen == NULL) || (glen == NULL)) {
return HITLS_INTERNAL_EXCEPTION;
}
FRAME_DhKey *dhKey = (FRAME_DhKey *)key;
if (p != NULL) {
if (memcpy_s(p, *plen, dhKey->p, dhKey->plen) != EOK) {
return HITLS_MEMCPY_FAIL;
}
}
if (g != NULL) {
if (memcpy_s(g, *glen, dhKey->g, dhKey->glen) != EOK) {
return HITLS_MEMCPY_FAIL;
}
}
*plen = dhKey->plen;
*glen = dhKey->glen;
return HITLS_SUCCESS;
}
int32_t STUB_CRYPT_GetDhEncodedPubKeyCallback(HITLS_CRYPT_Key *key, uint8_t *pubKeyBuf, uint32_t bufLen,
uint32_t *pubKeyLen)
{
if ((key == NULL) || (pubKeyBuf == NULL) || (pubKeyLen == NULL)) {
return HITLS_INTERNAL_EXCEPTION;
}
FRAME_DhKey *dhKey = (FRAME_DhKey *)key;
if (memcpy_s(pubKeyBuf, bufLen, dhKey->pubKey, dhKey->pubKeyLen) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*pubKeyLen = dhKey->pubKeyLen;
return HITLS_SUCCESS;
}
int32_t STUB_CRYPT_CalcDhSharedSecretCallback(HITLS_CRYPT_Key *key, uint8_t *peerPubkey, uint32_t pubKeyLen,
uint8_t *sharedSecret, uint32_t *sharedSecretLen)
{
FRAME_DhKey *dhKey = (FRAME_DhKey *)key;
if ((dhKey == NULL) ||
(peerPubkey == NULL) ||
(sharedSecret == NULL) ||
(sharedSecretLen == NULL) ||
(dhKey->plen < pubKeyLen)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (memset_s(sharedSecret, *sharedSecretLen, 1u, dhKey->plen) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*sharedSecretLen = dhKey->plen;
return HITLS_SUCCESS;
}
/**
* @ingroup hitls_crypt_reg
* @brief Obtain the HMAC length
*
* @param hashAlgo [IN] Hash algorithm
*
* @return HMAC length
*/
uint32_t STUB_CRYPT_HmacSizeCallback(HITLS_HashAlgo hashAlgo)
{
switch (hashAlgo) {
case HITLS_HASH_MD5:
return MD5_DIGEST_LENGTH;
case HITLS_HASH_SHA1:
return SHA1_DIGEST_LENGTH;
case HITLS_HASH_SHA_256:
return SHA256_DIGEST_LENGTH;
case HITLS_HASH_SHA_384:
return SHA384_DIGEST_LENGTH;
case HITLS_HASH_SHA_512:
return SHA512_DIGEST_LENGTH;
default:
break;
}
return 0u;
}
/**
* @ingroup hitls_crypt_reg
* @brief Initialize the HMAC context
*
* @param hashAlgo [IN] Hash algorithm
* @param key [IN] Key
* @param len [IN] Key length
*
* @return HMAC context
*/
HITLS_HMAC_Ctx *STUB_CRYPT_HmacInitCallback(HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t len)
{
FRAME_HmacCtx *ctx = BSL_SAL_Calloc(1u, sizeof(FRAME_HmacCtx));
if (ctx == NULL) {
return NULL;
}
ctx->algo = hashAlgo;
ctx->key = BSL_SAL_Dump(key, len);
if (ctx->key == NULL) {
BSL_SAL_FREE(ctx);
return NULL;
}
ctx->keyLen = len;
return ctx;
}
HITLS_HMAC_Ctx *STUB_CRYPT_HmacInitCallbackLibCtx(void *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t len)
{
(void)libCtx;
(void)attrName;
return STUB_CRYPT_HmacInitCallback(hashAlgo, key, len);
}
/**
* @ingroup hitls_crypt_reg
* @brief Release the HMAC context
*
* @param ctx [IN] HMAC context
*/
void STUB_CRYPT_HmacFreeCallback(HITLS_HMAC_Ctx *ctx)
{
FRAME_HmacCtx *hmacCtx = (FRAME_HmacCtx *)ctx;
if (hmacCtx != NULL) {
BSL_SAL_FREE(hmacCtx->key);
BSL_SAL_FREE(hmacCtx);
}
return;
}
/**
* @ingroup hitls_crypt_reg
* @brief Add the input data
*
* @param ctx [IN] HMAC context
* @param data [IN] Input data
* @param len [IN] Data length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_HmacUpdateCallback(HITLS_HMAC_Ctx *ctx, const uint8_t *data, uint32_t len)
{
if ((ctx == NULL) || (data == NULL) || len == 0) {
return HITLS_INTERNAL_EXCEPTION;
}
return HITLS_SUCCESS;
}
/**
* @ingroup hitls_crypt_reg
* @brief Output the HMAC result
*
* @param ctx [IN] HMAC context
* @param out [OUT] Output data
* @param len [IN/OUT] IN: Maximum buffer length OUT: Output data length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_HmacFinalCallback(HITLS_HMAC_Ctx *ctx, uint8_t *out, uint32_t *len)
{
FRAME_HmacCtx *hmacCtx = (FRAME_HmacCtx *)ctx;
if ((hmacCtx == NULL) || (out == NULL) || (len == NULL)) {
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t hmacSize = STUB_CRYPT_HmacSizeCallback(hmacCtx->algo);
if ((hmacSize == 0u) || (hmacSize > *len)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (memset_s(out, *len, 4u, hmacSize) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*len = hmacSize;
return HITLS_SUCCESS;
}
/**
* @ingroup hitls_crypt_reg
* @brief HMAC function
*
* @param hashAlgo [IN] Hash algorithm
* @param key [IN] Key
* @param keyLen [IN] Key length
* @param in [IN] Input data
* @param inLen [IN] Input data length
* @param out [OUT] Output data
* @param outLen [IN/OUT] IN: Maximum buffer length OUT: Output data length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_HmacCallback(HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t keyLen,
const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
if ((key == NULL) || (keyLen == 0) || (in == NULL) || (inLen == 0) ||
(out == NULL) || (outLen == NULL)) {
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t hmacSize = STUB_CRYPT_HmacSizeCallback(hashAlgo);
if ((hmacSize == 0u) || (hmacSize > *outLen)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (memset_s(out, *outLen, 4u, hmacSize) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*outLen = hmacSize;
return HITLS_SUCCESS;
}
int32_t STUB_CRYPT_HmacCallbackLibCtx(void *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t keyLen,
const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
(void)libCtx;
(void)attrName;
return STUB_CRYPT_HmacCallback(hashAlgo, key, keyLen, in, inLen, out, outLen);
}
/**
* @ingroup hitls_crypt_reg
* @brief Obtain the hash length
*
* @param hashAlgo [IN] Hash algorithm
*
* @return Hash length
*/
uint32_t STUB_CRYPT_DigestSizeCallback(HITLS_HashAlgo hashAlgo)
{
return STUB_CRYPT_HmacSizeCallback(hashAlgo);
}
/**
* @ingroup hitls_crypt_reg
* @brief Initialize the hash context
*
* @param hashAlgo [IN] Hash algorithm
*
* @return hash context
*/
HITLS_HASH_Ctx *STUB_CRYPT_DigestInitCallback(HITLS_HashAlgo hashAlgo)
{
FRAME_HashCtx *ctx = BSL_SAL_Calloc(1u, sizeof(FRAME_HashCtx));
if (ctx == NULL) {
return NULL;
}
ctx->algo = hashAlgo;
return ctx;
}
HITLS_HASH_Ctx *STUB_CRYPT_DigestInitCallbackLibCtx(void *libCtx, const char *attrName, HITLS_HashAlgo hashAlgo)
{
(void)libCtx;
(void)attrName;
return STUB_CRYPT_DigestInitCallback(hashAlgo);
}
/**
* @ingroup hitls_crypt_reg
* @brief Copy hash Context
*
* @param ctx [IN] hash Context
*
* @return hash Context
*/
HITLS_HASH_Ctx *STUB_CRYPT_DigestCopyCallback(HITLS_HASH_Ctx *ctx)
{
FRAME_HashCtx *srcCtx = (FRAME_HashCtx *)ctx;
if (srcCtx == NULL) {
return NULL;
}
FRAME_HashCtx *newCtx = BSL_SAL_Calloc(1u, sizeof(FRAME_HashCtx));
if (newCtx == NULL) {
return NULL;
}
newCtx->algo = srcCtx->algo;
return newCtx;
}
/**
* @ingroup hitls_crypt_reg
* @brief Release the hash context
*
* @param ctx [IN] hash Context
*/
void STUB_CRYPT_DigestFreeCallback(HITLS_HASH_Ctx *ctx)
{
BSL_SAL_FREE(ctx);
return;
}
/**
* @ingroup hitls_crypt_reg
* @brief Add the input data
*
* @param ctx [IN] hash Context
* @param data [IN] Input data
* @param len [IN] Input data length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_DigestUpdateCallback(HITLS_HASH_Ctx *ctx, const uint8_t *data, uint32_t len)
{
if ((ctx == NULL) || (data == NULL) || (len == 0u)) {
return HITLS_INTERNAL_EXCEPTION;
}
return HITLS_SUCCESS;
}
/**
* @ingroup hitls_crypt_reg
* @brief Output the hash result
*
* @param ctx [IN] hash Context
* @param out [IN] Output data
* @param len [IN/OUT] IN: Maximum buffer length OUT: Output data length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_DigestFinalCallback(HITLS_HASH_Ctx *ctx, uint8_t *out, uint32_t *len)
{
FRAME_HashCtx *hashCtx = (FRAME_HashCtx *)ctx;
if ((hashCtx == NULL) || (out == NULL) || (len == NULL)) {
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t digestSize = STUB_CRYPT_DigestSizeCallback(hashCtx->algo);
if ((digestSize == 0) || (digestSize > *len)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (memset_s(out, *len, 5u, digestSize) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*len = digestSize;
return HITLS_SUCCESS;
}
/**
* @ingroup hitls_crypt_reg
* @brief hash function
*
* @param hashAlgo [IN] Hash algorithm
* @param in [IN] Input data
* @param inLen [IN] Input data length
* @param out [OUT] Output data
* @param outLen [IN/OUT] IN: Maximum buffer length OUT: Output data length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_DigestCallback(HITLS_HashAlgo hashAlgo, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
if ((in == NULL) ||
(out == NULL) ||
(outLen == NULL) ||
(inLen == 0)) {
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t digestSize = STUB_CRYPT_DigestSizeCallback(hashAlgo);
if ((digestSize == 0) || (digestSize > *outLen)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (memset_s(out, *outLen, 5u, digestSize) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*outLen = digestSize;
return HITLS_SUCCESS;
}
int32_t STUB_CRYPT_DigestCallbackLibCtx(void *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
(void)libCtx;
(void)attrName;
return STUB_CRYPT_DigestCallback(hashAlgo, in, inLen, out, outLen);
}
/**
* @ingroup hitls_crypt_reg
* @brief Encryption
*
* @param cipher [IN] Key parameters
* @param in [IN] Plaintext data
* @param inLen [IN] Plaintext data length
* @param out [OUT] Ciphertext data
* @param outLen [IN/OUT] IN: maximum buffer length OUT: ciphertext data length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_EncryptCallback(const HITLS_CipherParameters *cipher, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
if (cipher->type == HITLS_AEAD_CIPHER) {
if (*outLen < inLen + AEAD_TAG_LENGTH) {
return HITLS_INTERNAL_EXCEPTION;
}
(void)memset_s(out, *outLen, 0, *outLen);
if (inLen != 0 && memcpy_s(out, *outLen, in, inLen) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*outLen = inLen + AEAD_TAG_LENGTH;
} else {
*outLen = 0;
return HITLS_INTERNAL_EXCEPTION;
}
return HITLS_SUCCESS;
}
int32_t STUB_CRYPT_EncryptCallbackLibCtx(void *libCtx, const char *attrName,
const HITLS_CipherParameters *cipher, const uint8_t *in,
uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
(void)libCtx;
(void)attrName;
return STUB_CRYPT_EncryptCallback(cipher, in, inLen, out, outLen);
}
/**
* @ingroup hitls_crypt_reg
* @brief Decrypt
*
* @param cipher [IN] Key parameters
* @param in [IN] Ciphertext data
* @param inLen [IN] Ciphertext data length
* @param out [OUT] Plaintext data
* @param outLen [IN/OUT] IN: Maximum buffer length OUT: Plaintext data length
*
* @return 0 indicates success. Other values indicate failure
*/
int32_t STUB_CRYPT_DecryptCallback(const HITLS_CipherParameters *cipher, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
if (cipher->type == HITLS_AEAD_CIPHER) {
if (inLen < AEAD_TAG_LENGTH) {
return HITLS_INTERNAL_EXCEPTION;
}
(void)memset_s(out, *outLen, 0, *outLen);
if (memcpy_s(out, *outLen, in, inLen - AEAD_TAG_LENGTH) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*outLen = inLen - AEAD_TAG_LENGTH;
} else {
*outLen = 0;
return HITLS_INTERNAL_EXCEPTION;
}
return HITLS_SUCCESS;
}
int32_t STUB_CRYPT_DecryptCallbackLibCtx(void *libCtx, const char *attrName,
const HITLS_CipherParameters *cipher, const uint8_t *in,
uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
(void)libCtx;
(void)attrName;
return STUB_CRYPT_DecryptCallback(cipher, in, inLen, out, outLen);
}
FuncStubInfo g_tmpRpInfo[16] = {0};
void FRAME_RegCryptMethod(void)
{
#ifndef HITLS_TLS_FEATURE_PROVIDER
HITLS_CRYPT_BaseMethod cryptMethod = { 0 };
cryptMethod.randBytes = STUB_CRYPT_RandBytesCallback;
cryptMethod.hmacSize = STUB_CRYPT_HmacSizeCallback;
cryptMethod.hmacInit = STUB_CRYPT_HmacInitCallback;
cryptMethod.hmacFree = STUB_CRYPT_HmacFreeCallback;
cryptMethod.hmacUpdate = STUB_CRYPT_HmacUpdateCallback;
cryptMethod.hmacFinal = STUB_CRYPT_HmacFinalCallback;
cryptMethod.hmac = STUB_CRYPT_HmacCallback;
cryptMethod.digestSize = STUB_CRYPT_DigestSizeCallback;
cryptMethod.digestInit = STUB_CRYPT_DigestInitCallback;
cryptMethod.digestCopy = STUB_CRYPT_DigestCopyCallback;
cryptMethod.digestFree = CRYPT_DEFAULT_DigestFree;
cryptMethod.digestUpdate = STUB_CRYPT_DigestUpdateCallback;
cryptMethod.digestFinal = STUB_CRYPT_DigestFinalCallback;
cryptMethod.digest = STUB_CRYPT_DigestCallback;
cryptMethod.encrypt = STUB_CRYPT_EncryptCallback;
cryptMethod.decrypt = STUB_CRYPT_DecryptCallback;
cryptMethod.cipherFree = CRYPT_DEFAULT_CipherFree;
HITLS_CRYPT_RegisterBaseMethod(&cryptMethod);
HITLS_CRYPT_EcdhMethod ecdhMethod = { 0 };
ecdhMethod.generateEcdhKeyPair = STUB_CRYPT_GenerateEcdhKeyPairCallback;
ecdhMethod.freeEcdhKey = CRYPT_DEFAULT_FreeKey;
ecdhMethod.getEcdhPubKey = STUB_CRYPT_GetEcdhEncodedPubKeyCallback;
ecdhMethod.calcEcdhSharedSecret = STUB_CRYPT_CalcEcdhSharedSecretCallback;
HITLS_CRYPT_RegisterEcdhMethod(&ecdhMethod);
HITLS_CRYPT_DhMethod dhMethod = { 0 };
dhMethod.generateDhKeyBySecbits = STUB_CRYPT_GenerateDhKeyBySecbitsCallback;
dhMethod.generateDhKeyByParams = STUB_CRYPT_GenerateDhKeyByParamsCallback;
dhMethod.freeDhKey = CRYPT_DEFAULT_FreeKey;
dhMethod.getDhParameters = STUB_CRYPT_DHGetParametersCallback;
dhMethod.getDhPubKey = STUB_CRYPT_GetDhEncodedPubKeyCallback;
dhMethod.calcDhSharedSecret = STUB_CRYPT_CalcDhSharedSecretCallback;
HITLS_CRYPT_RegisterDhMethod(&dhMethod);
#else
STUB_Init();
STUB_Replace(&g_tmpRpInfo[0], CRYPT_EAL_RandbytesEx, STUB_CRYPT_RandBytesCallbackLibCtx);
STUB_Replace(&g_tmpRpInfo[1], HITLS_CRYPT_HMAC_Init, STUB_CRYPT_HmacInitCallbackLibCtx);
STUB_Replace(&g_tmpRpInfo[2], HITLS_CRYPT_HMAC, STUB_CRYPT_HmacCallbackLibCtx);
STUB_Replace(&g_tmpRpInfo[3], HITLS_CRYPT_DigestInit, STUB_CRYPT_DigestInitCallbackLibCtx);
STUB_Replace(&g_tmpRpInfo[4], HITLS_CRYPT_Digest, STUB_CRYPT_DigestCallbackLibCtx);
STUB_Replace(&g_tmpRpInfo[5], HITLS_CRYPT_Encrypt, STUB_CRYPT_EncryptCallbackLibCtx);
STUB_Replace(&g_tmpRpInfo[6], HITLS_CRYPT_Decrypt, STUB_CRYPT_DecryptCallbackLibCtx);
STUB_Replace(&g_tmpRpInfo[7], HITLS_CRYPT_GenerateEcdhKey, STUB_CRYPT_GenerateEcdhKeyPairCallbackLibCtx);
STUB_Replace(&g_tmpRpInfo[8], HITLS_CRYPT_EcdhCalcSharedSecret, STUB_CRYPT_CalcEcdhSharedSecretCallbackLibCtx);
STUB_Replace(&g_tmpRpInfo[9], HITLS_CRYPT_GenerateDhKeyByParameters, STUB_CRYPT_GenerateDhKeyByParamsCallbackLibCtx);
STUB_Replace(&g_tmpRpInfo[10], HITLS_CRYPT_GenerateDhKeyBySecbits, STUB_CRYPT_GenerateDhKeyBySecbitsCallbackLibCtx);
#endif
return;
}
void FRAME_DeRegCryptMethod(void)
{
#ifndef HITLS_TLS_FEATURE_PROVIDER
HITLS_CRYPT_BaseMethod cryptMethod = { 0 };
HITLS_CRYPT_RegisterBaseMethod(&cryptMethod);
HITLS_CRYPT_EcdhMethod ecdhMethod = { 0 };
HITLS_CRYPT_RegisterEcdhMethod(&ecdhMethod);
HITLS_CRYPT_DhMethod dhMethod = { 0 };
HITLS_CRYPT_RegisterDhMethod(&dhMethod);
#else
STUB_Reset(&g_tmpRpInfo[0]);
STUB_Reset(&g_tmpRpInfo[1]);
STUB_Reset(&g_tmpRpInfo[2]);
STUB_Reset(&g_tmpRpInfo[3]);
STUB_Reset(&g_tmpRpInfo[4]);
STUB_Reset(&g_tmpRpInfo[5]);
STUB_Reset(&g_tmpRpInfo[6]);
STUB_Reset(&g_tmpRpInfo[7]);
STUB_Reset(&g_tmpRpInfo[8]);
STUB_Reset(&g_tmpRpInfo[9]);
STUB_Reset(&g_tmpRpInfo[10]);
#endif
return;
}
|
2301_79861745/bench_create
|
testcode/framework/tls/crypt/src/stub_crypt.c
|
C
|
unknown
| 27,132
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include <string.h>
#include "securec.h"
#include "bsl_sal.h"
#include "hitls_error.h"
#include "hs_ctx.h"
#include "hs_common.h"
#include "change_cipher_spec.h"
#include "stub_replace.h"
#include "frame_tls.h"
#include "frame_io.h"
#include "frame_link.h"
#include "parse.h"
#define ENTER_USER_SPECIFY_STATE (HITLS_UIO_FAIL_START + 0xFFFF)
#define READ_BUF_SIZE 18432
HITLS_HandshakeState g_nextState;
bool g_isClient;
int32_t FRAME_TrasferMsgBetweenLink(FRAME_LinkObj *linkA, FRAME_LinkObj *linkB)
{
int32_t ret = HITLS_SUCCESS;
uint32_t readLen = 0;
char *buffer = BSL_SAL_Calloc(1u, MAX_RECORD_LENTH);
if (buffer == NULL) {
return HITLS_MEMALLOC_FAIL;
}
// linkA->io->userData to buffer
ret = FRAME_TransportSendMsg(linkA->io, buffer, MAX_RECORD_LENTH, &readLen);
if (ret != HITLS_SUCCESS) {
BSL_SAL_FREE(buffer);
return ret;
}
if (readLen == 0) {
BSL_SAL_FREE(buffer);
return HITLS_SUCCESS;
}
// buffer to linkB->io->userData
ret = FRAME_TransportRecMsg(linkB->io, buffer, readLen);
if (ret != HITLS_SUCCESS) {
BSL_SAL_FREE(buffer);
return ret;
}
BSL_SAL_FREE(buffer);
return HITLS_SUCCESS;
}
static int32_t STUB_ChangeState(TLS_Ctx *ctx, uint32_t nextState)
{
int32_t ret = HITLS_SUCCESS;
if (g_nextState == nextState) {
if (g_isClient == ctx->isClient) {
HS_CleanMsg(ctx->hsCtx->hsMsg);
ctx->hsCtx->hsMsg = NULL;
ret = HITLS_REC_NORMAL_RECV_BUF_EMPTY;
}
}
HS_Ctx *hsCtx = (HS_Ctx *)ctx->hsCtx;
hsCtx->state = nextState;
return ret;
}
static bool StateCompare(FRAME_LinkObj *link, bool isClient, HITLS_HandshakeState state)
{
if ((isClient == link->ssl->isClient) && (link->ssl->hsCtx != NULL) && (link->ssl->hsCtx->state == state)) {
if (state != TRY_RECV_FINISH && state != TRY_RECV_CERTIFICATE) {
return true;
}
/* In tls1.3, if the single-end verification is used, the server may receive the CCS message in the TRY_RECV_FINISH phase */
if (state == TRY_RECV_FINISH){
if (link->needStopBeforeRecvCCS || CCS_IsRecv(link->ssl) == true ||
(link->ssl->config.tlsConfig.maxVersion == HITLS_VERSION_TLS13 && isClient == true) ||
(link->ssl->config.tlsConfig.maxVersion == HITLS_VERSION_TLS13 &&
link->ssl->config.tlsConfig.isSupportClientVerify == true)) {
return true;
}
}
// In tls1.3, the server may receive the CCS message in the TRY_RECV_CERTIFICATIONATE phase
if (state == TRY_RECV_CERTIFICATE){
if (link->needStopBeforeRecvCCS || CCS_IsRecv(link->ssl) == true ||
#ifdef HITLS_TLS_PROTO_TLS13
link->ssl->hsCtx->haveHrr == true ||
#endif /* HITLS_TLS_PROTO_TLS13 */
link->ssl->config.tlsConfig.maxVersion != HITLS_VERSION_TLS13 || isClient == true) {
return true;
}
}
}
return false;
}
int32_t FRAME_CreateConnection(FRAME_LinkObj *client, FRAME_LinkObj *server, bool isClient, HITLS_HandshakeState state)
{
int32_t clientRet;
int32_t serverRet;
int32_t ret;
uint32_t count = 0;
if (client == NULL || server == NULL) {
return HITLS_NULL_INPUT;
}
g_isClient = isClient;
g_nextState = state;
FuncStubInfo tmpRpInfo = {0};
STUB_Init();
STUB_Replace(&tmpRpInfo, HS_ChangeState, STUB_ChangeState);
do {
// Check whether the client needs to be stopped. If yes, return success
if (StateCompare(client, isClient, state)) {
ret = HITLS_SUCCESS;
break;
}
// Invoke the client to establish a connection
clientRet = HITLS_Connect(client->ssl);
if (clientRet != HITLS_SUCCESS) {
ret = clientRet;
if ((clientRet != HITLS_REC_NORMAL_IO_BUSY) && (clientRet != HITLS_REC_NORMAL_RECV_BUF_EMPTY)) {
break;
}
}
// Transfer the message to the server
ret = FRAME_TrasferMsgBetweenLink(client, server);
if (ret != HITLS_SUCCESS) {
break;
}
// Check whether the server needs to be stopped. If yes, return success
if (StateCompare(server, isClient, state)) {
ret = HITLS_SUCCESS;
break;
}
// Invoke the server to establish a connection
serverRet = HITLS_Accept(server->ssl);
if (serverRet != HITLS_SUCCESS) {
ret = serverRet;
if ((serverRet != HITLS_REC_NORMAL_IO_BUSY) && (serverRet != HITLS_REC_NORMAL_RECV_BUF_EMPTY)) {
break;
}
}
// Transfer the message to the client
ret = FRAME_TrasferMsgBetweenLink(server, client);
if (ret != HITLS_SUCCESS) {
break;
}
/* To receive TLS1.3 new session ticket messages */
if (clientRet == HITLS_SUCCESS) {
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen = 0;
ret = HITLS_Read(client->ssl, readBuf, READ_BUF_SIZE, &readLen);
// No application data. return HITLS_REC_NORMAL_RECV_BUF_EMPTY
if (ret != HITLS_REC_NORMAL_RECV_BUF_EMPTY) {
return ret;
}
}
// If the connection is set up on both sides, return success
if (clientRet == HITLS_SUCCESS && serverRet == HITLS_SUCCESS) {
ret = HITLS_SUCCESS;
break;
}
count++;
ret = HITLS_INTERNAL_EXCEPTION;
// Prevent infinite loop. No more than 30 messages are exchanged between the client and server during the handshake
} while (count < 30);
//Check whether the hsCtx status meets the expectation. If hsCtx is destructed, HITLS_INTERNAL_EXCEPTION is returned
if (state != HS_STATE_BUTT) {
FRAME_LinkObj *point = (isClient) ? (client) : (server);
if (point->ssl->hsCtx == NULL) {
ret = HITLS_INTERNAL_EXCEPTION;
} else if (point->ssl->hsCtx->state != state) {
ret = HITLS_INTERNAL_EXCEPTION;
}
}
STUB_Reset(&tmpRpInfo);
return ret;
}
int32_t FRAME_CreateRenegotiation(FRAME_LinkObj *linkA, FRAME_LinkObj *linkB)
{
int32_t clientRet;
int32_t serverRet;
int32_t ret;
uint32_t count = 0;
// renegotiation signal
uint8_t writeBuf[1] = {1};
uint8_t readBuf[32] = {0}; // buffer for receive temporary messages, 32 bytes long
uint32_t readBufLen = 0;
if (linkA->ssl->state != CM_STATE_RENEGOTIATION) {
return HITLS_SUCCESS;
}
do {
uint32_t len = 0;
clientRet = HITLS_Write(linkA->ssl, writeBuf, sizeof(writeBuf), &len);
if (clientRet != HITLS_SUCCESS) {
ret = clientRet;
if ((clientRet != HITLS_REC_NORMAL_IO_BUSY) && (clientRet != HITLS_REC_NORMAL_RECV_BUF_EMPTY)) {
break;
}
}
ret = FRAME_TrasferMsgBetweenLink(linkA, linkB);
if (ret != HITLS_SUCCESS) {
break;
}
readBufLen = 0;
(void)memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
serverRet = HITLS_Read(linkB->ssl, readBuf, sizeof(readBuf), &readBufLen);
if (serverRet != HITLS_SUCCESS) {
ret = serverRet;
if ((serverRet != HITLS_REC_NORMAL_IO_BUSY) && (serverRet != HITLS_REC_NORMAL_RECV_BUF_EMPTY)) {
break;
}
}
ret = FRAME_TrasferMsgBetweenLink(linkB, linkA);
if (ret != HITLS_SUCCESS) {
break;
}
// If the connection is set up on both sides, return success
if (clientRet == HITLS_SUCCESS && serverRet == HITLS_SUCCESS &&
linkA->ssl->state == CM_STATE_TRANSPORTING && linkB->ssl->state == CM_STATE_TRANSPORTING) {
if ((readBufLen != sizeof(writeBuf)) ||
(memcmp(writeBuf, readBuf, readBufLen) != 0)) {
ret = HITLS_INTERNAL_EXCEPTION;
} else {
ret = HITLS_SUCCESS;
}
break;
}
count++;
ret = HITLS_INTERNAL_EXCEPTION;
// Prevent infinite loop. No more than 30 messages are exchanged between the client and server during the handshake
} while (count < 30);
return ret;
}
int32_t FRAME_CreateRenegotiationServer(FRAME_LinkObj *server, FRAME_LinkObj *client)
{
int32_t clientRet;
int32_t serverRet;
int32_t ret;
uint32_t count = 0;
// renegotiation signal
uint8_t readBuf[32] = {0}; // buffer for receive temporary messages, 32 bytes long
uint32_t readBufLen = 0;
if (server->ssl->state != CM_STATE_RENEGOTIATION) {
return HITLS_SUCCESS;
}
do {
readBufLen = 0;
(void)memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
serverRet = HITLS_Read(server->ssl, readBuf, sizeof(readBuf), &readBufLen);
if (serverRet != HITLS_SUCCESS) {
ret = serverRet;
if ((serverRet != HITLS_REC_NORMAL_IO_BUSY) && (serverRet != HITLS_REC_NORMAL_RECV_BUF_EMPTY)) {
break;
}
}
ret = FRAME_TrasferMsgBetweenLink(server, client);
if (ret != HITLS_SUCCESS) {
break;
}
readBufLen = 0;
(void)memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
clientRet = HITLS_Read(client->ssl, readBuf, sizeof(readBuf), &readBufLen);
if (clientRet != HITLS_SUCCESS) {
ret = clientRet;
if ((clientRet != HITLS_REC_NORMAL_IO_BUSY) && (clientRet != HITLS_REC_NORMAL_RECV_BUF_EMPTY)) {
break;
}
}
ret = FRAME_TrasferMsgBetweenLink(client, server);
if (ret != HITLS_SUCCESS) {
break;
}
// If the connection is set up on both sides, return success
if (clientRet == HITLS_REC_NORMAL_RECV_BUF_EMPTY && serverRet == HITLS_REC_NORMAL_RECV_BUF_EMPTY &&
server->ssl->state == CM_STATE_TRANSPORTING && client->ssl->state == CM_STATE_TRANSPORTING) {
ret = HITLS_SUCCESS;
break;
}
count++;
ret = HITLS_INTERNAL_EXCEPTION;
// Prevent infinite loop. No more than 30 messages are exchanged between the client and server during the handshake
} while (count < 30);
return ret;
}
int32_t FRAME_CreateRenegotiationState(FRAME_LinkObj *client, FRAME_LinkObj *server, bool isClient, HITLS_HandshakeState state)
{
int32_t clientRet;
int32_t serverRet;
int32_t ret;
uint32_t count = 0;
// renegotiation signal
uint8_t writeBuf[1] = {1};
uint8_t readBuf[32] = {0}; // buffer for receive temporary messages, 32 bytes long
uint32_t readBufLen = 0;
if (client->ssl->state != CM_STATE_RENEGOTIATION) {
return HITLS_SUCCESS;
}
g_isClient = isClient;
g_nextState = state;
FuncStubInfo tmpRpInfo = {0};
STUB_Init();
STUB_Replace(&tmpRpInfo, HS_ChangeState, STUB_ChangeState);
do {
// Check whether the client needs to be stopped. If yes, return success
if (StateCompare(client, isClient, state)) {
ret = HITLS_SUCCESS;
break;
}
uint32_t len = 0;
clientRet = HITLS_Write(client->ssl, writeBuf, sizeof(writeBuf), &len);
if (clientRet != HITLS_SUCCESS) {
ret = clientRet;
if ((clientRet != HITLS_REC_NORMAL_IO_BUSY) && (clientRet != HITLS_REC_NORMAL_RECV_BUF_EMPTY)) {
break;
}
}
ret = FRAME_TrasferMsgBetweenLink(client, server);
if (ret != HITLS_SUCCESS) {
break;
}
// Check whether the server needs to be stopped. If yes, return success
if (StateCompare(server, isClient, state)) {
ret = HITLS_SUCCESS;
break;
}
readBufLen = 0;
(void)memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
serverRet = HITLS_Read(server->ssl, readBuf, sizeof(readBuf), &readBufLen);
if (serverRet != HITLS_SUCCESS) {
ret = serverRet;
if ((serverRet != HITLS_REC_NORMAL_IO_BUSY) && (serverRet != HITLS_REC_NORMAL_RECV_BUF_EMPTY)) {
break;
}
}
ret = FRAME_TrasferMsgBetweenLink(server, client);
if (ret != HITLS_SUCCESS) {
break;
}
// If the connection is set up on both sides, return success
if (clientRet == HITLS_SUCCESS && serverRet == HITLS_SUCCESS &&
client->ssl->state == CM_STATE_TRANSPORTING && server->ssl->state == CM_STATE_TRANSPORTING) {
if ((readBufLen != sizeof(writeBuf)) ||
(memcmp(writeBuf, readBuf, readBufLen) != 0)) {
ret = HITLS_INTERNAL_EXCEPTION;
} else {
ret = HITLS_SUCCESS;
}
break;
}
count++;
ret = HITLS_INTERNAL_EXCEPTION;
// Prevent infinite loop. No more than 30 messages are exchanged between the client and server during the handshake
} while (count < 30);
//Check whether the hsCtx status meets the expectation. If hsCtx is destructed, HITLS_INTERNAL_EXCEPTION is returned
if (state != HS_STATE_BUTT) {
FRAME_LinkObj *point = (isClient) ? (client) : (server);
if (point->ssl->hsCtx == NULL) {
ret = HITLS_INTERNAL_EXCEPTION;
} else if (point->ssl->hsCtx->state != state) {
ret = HITLS_INTERNAL_EXCEPTION;
}
}
STUB_Reset(&tmpRpInfo);
return ret;
}
|
2301_79861745/bench_create
|
testcode/framework/tls/frame/src/frame_connect.c
|
C
|
unknown
| 14,226
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include "hitls_build.h"
#include "cert_callback.h"
#include "bsl_sal.h"
#include "bsl_log.h"
#include "bsl_err.h"
#include "crypt_algid.h"
#include "hitls_crypt_init.h"
#include "crypt_eal_rand.h"
#include "hitls_cert_init.h"
#include "bsl_log.h"
static void *StdMalloc(uint32_t len)
{
return malloc((uint32_t)len);
}
static void StdFree(void *addr)
{
free(addr);
}
static void *StdMallocFail(uint32_t len)
{
(void)len;
return NULL;
}
void BinLogFixLenFunc(uint32_t logId, uint32_t logLevel, uint32_t logType,
void *format, void *para1, void *para2, void *para3, void *para4);
void BinLogVarLenFunc(uint32_t logId, uint32_t logLevel, uint32_t logType, void *format, void *para);
void FRAME_Init(void)
{
BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_MALLOC, StdMalloc);
BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_FREE, StdFree);
BSL_ERR_Init();
#ifdef TLS_DEBUG
BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_DEBUG);
BSL_LOG_BinLogFuncs logFunc = { BinLogFixLenFunc, BinLogVarLenFunc };
BSL_LOG_RegBinLogFunc(&logFunc);
#endif
#ifdef HITLS_TLS_FEATURE_PROVIDER
CRYPT_EAL_ProviderRandInitCtx(NULL, CRYPT_RAND_SHA256, "provider=default", NULL, 0, NULL);
#else
CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0);
HITLS_CertMethodInit();
HITLS_CryptMethodInit();
#endif
return;
}
void FRAME_DeInit(void)
{
BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_MALLOC, StdMallocFail);
BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_FREE, StdFree);
BSL_ERR_DeInit();
return;
}
|
2301_79861745/bench_create
|
testcode/framework/tls/frame/src/frame_init.c
|
C
|
unknown
| 2,125
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "securec.h"
#include "bsl_sal.h"
#include "uio_base.h"
#include "uio_abstraction.h"
#include "hitls_crypt_type.h"
#include "hitls_cert_type.h"
#include "hitls_error.h"
#include "hlt_type.h"
#include "cert_callback.h"
#include "frame_tls.h"
#include "frame_io.h"
#include "frame_link.h"
#define MAX_CERT_PATH_LENGTH (1024)
HITLS_Ctx *FRAME_CreateDefaultDtlsObj(void)
{
HITLS_Config *config = HITLS_CFG_NewDTLS12Config();
if (config == NULL) {
return NULL;
}
char verifyPath[MAX_CERT_PATH_LENGTH] = {0};
char chainPath[MAX_CERT_PATH_LENGTH] = {0};
char certPath[MAX_CERT_PATH_LENGTH] = {0};
char keyPath[MAX_CERT_PATH_LENGTH] = {0};
if (sprintf_s(verifyPath, MAX_CERT_PATH_LENGTH, "%s:%s", RSA_SHA_CA_PATH, ECDSA_SHA_CA_PATH) <= 0) {
HITLS_CFG_FreeConfig(config);
return NULL;
}
if (sprintf_s(chainPath, MAX_CERT_PATH_LENGTH, "%s:%s", RSA_SHA_CHAIN_PATH, ECDSA_SHA_CHAIN_PATH) <= 0) {
HITLS_CFG_FreeConfig(config);
return NULL;
}
if (sprintf_s(certPath, MAX_CERT_PATH_LENGTH, "%s:%s", RSA_SHA256_EE_PATH3, ECDSA_SHA256_EE_PATH) <= 0) {
HITLS_CFG_FreeConfig(config);
return NULL;
}
if (sprintf_s(keyPath, MAX_CERT_PATH_LENGTH, "%s:%s", RSA_SHA256_PRIV_PATH3, ECDSA_SHA256_PRIV_PATH) <= 0) {
HITLS_CFG_FreeConfig(config);
return NULL;
}
int32_t ret = HiTLS_X509_LoadCertAndKey(config, verifyPath, chainPath, certPath, NULL, keyPath, NULL);
if (ret != HITLS_SUCCESS) {
HITLS_CFG_FreeConfig(config);
return NULL;
}
HITLS_Ctx *ctx = HITLS_New(config);
if (ctx == NULL) {
HITLS_CFG_FreeConfig(config);
return NULL;
}
HITLS_CFG_FreeConfig(config);
return ctx;
}
FRAME_LinkObj *CreateLink(HITLS_Config *config, BSL_UIO_TransportType type)
{
BSL_UIO_Method method = {0};
BSL_UIO *io = NULL;
FrameUioUserData *ioUserdata = NULL;
const BSL_UIO_Method *ori = NULL;
switch (type) {
case BSL_UIO_TCP:
#ifdef HITLS_BSL_UIO_TCP
ori = BSL_UIO_TcpMethod();
#endif
break;
case BSL_UIO_UDP:
#ifdef HITLS_BSL_UIO_UDP
ori = BSL_UIO_UdpMethod();
#endif
break;
default:
#ifdef HITLS_BSL_UIO_SCTP
ori = BSL_UIO_SctpMethod();
#endif
break;
}
if (memcpy_s(&method, sizeof(BSL_UIO_Method), ori, sizeof(method)) != EOK) {
return NULL;
}
FRAME_LinkObj *linkObj = BSL_SAL_Calloc(1u, sizeof(FRAME_LinkObj));
if (linkObj == NULL) {
return NULL;
}
HITLS_CFG_SetReadAhead(config, 1);
#ifdef HITLS_TLS_FEATURE_FLIGHT
HITLS_CFG_SetFlightTransmitSwitch(config, false);
#endif
HITLS_Ctx *sslObj = HITLS_New(config);
if (sslObj == NULL) {
goto ERR;
}
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
if (type == BSL_UIO_UDP) {
HITLS_SetMtu(sslObj, 16384);
}
#endif
INIT_IO_METHOD(method, type, FRAME_Write, FRAME_Read, FRAME_Ctrl);
io = BSL_UIO_New(&method);
if (io == NULL) {
goto ERR;
}
ioUserdata = FRAME_IO_CreateUserData();
if (ioUserdata == NULL) {
goto ERR;
}
uint32_t ret = BSL_UIO_SetUserData(io, ioUserdata);
if (ret != HITLS_SUCCESS) {
goto ERR;
}
int32_t fd = 666;
// Set any fd as the value of the underlying transfer I/O
ret = BSL_UIO_Ctrl(io, BSL_UIO_SET_FD, (int32_t)sizeof(fd), &fd);
if (ret != HITLS_SUCCESS) {
goto ERR;
}
BSL_UIO_SetInit(io, true);
// must return success
ret = HITLS_SetUio(sslObj, io);
if (ret != HITLS_SUCCESS) {
goto ERR;
}
linkObj->io = io;
linkObj->ssl = sslObj;
return linkObj;
ERR:
FRAME_IO_FreeUserData(ioUserdata);
BSL_UIO_Free(io);
HITLS_Free(sslObj);
BSL_SAL_FREE(linkObj);
return NULL;
}
#ifdef HITLS_TLS_PROTO_TLCP11
FRAME_LinkObj *FRAME_CreateTLCPLink(HITLS_Config *config, BSL_UIO_TransportType type, bool isClient)
{
#ifdef HITLS_TLS_CONFIG_KEY_USAGE
HITLS_CFG_SetCheckKeyUsage(config, false);
#endif
#ifdef HITLS_TLS_FEATURE_SECURITY
HITLS_CFG_SetSecurityLevel(config, HITLS_SECURITY_LEVEL_ZERO);
#endif /* HITLS_TLS_FEATURE_SECURITY */
int32_t ret;
if (isClient) {
ret = HiTLS_X509_LoadCertAndKey(config, SM2_VERIFY_PATH, SM2_CHAIN_PATH, SM2_CLIENT_ENC_CERT_PATH,
SM2_CLIENT_SIGN_CERT_PATH, SM2_CLIENT_ENC_KEY_PATH, SM2_CLIENT_SIGN_KEY_PATH);
} else {
ret = HiTLS_X509_LoadCertAndKey(config, SM2_VERIFY_PATH, SM2_CHAIN_PATH, SM2_SERVER_ENC_CERT_PATH,
SM2_SERVER_SIGN_CERT_PATH, SM2_SERVER_ENC_KEY_PATH, SM2_SERVER_SIGN_KEY_PATH);
}
if (ret != HITLS_SUCCESS) {
return NULL;
}
return CreateLink(config, type);
}
#endif /* HITLS_TLS_PROTO_TLCP11 */
//Set certificate and creating a connection
FRAME_LinkObj *FRAME_CreateLinkBase(HITLS_Config *config, BSL_UIO_TransportType type, bool setCertFlag)
{
int32_t ret;
if (setCertFlag) {
char verifyPath[MAX_CERT_PATH_LENGTH] = {0};
char chainPath[MAX_CERT_PATH_LENGTH] = {0};
char certPath[MAX_CERT_PATH_LENGTH] = {0};
char keyPath[MAX_CERT_PATH_LENGTH] = {0};
sprintf_s(verifyPath, MAX_CERT_PATH_LENGTH, "%s:%s", ECDSA_SHA_CA_PATH, RSA_SHA_CA_PATH);
sprintf_s(chainPath,
MAX_CERT_PATH_LENGTH,
"%s:%s",
ECDSA_SHA_CHAIN_PATH,
RSA_SHA_CHAIN_PATH);
sprintf_s(
certPath, MAX_CERT_PATH_LENGTH, "%s:%s", ECDSA_SHA256_EE_PATH, RSA_SHA256_EE_PATH3);
sprintf_s(keyPath,
MAX_CERT_PATH_LENGTH,
"%s:%s",
ECDSA_SHA256_PRIV_PATH,
RSA_SHA256_PRIV_PATH3);
ret = HiTLS_X509_LoadCertAndKey(config, verifyPath, chainPath, certPath, NULL, keyPath, NULL);
if (ret != HITLS_SUCCESS) {
return NULL;
}
}
return CreateLink(config, type);
}
FRAME_LinkObj *FRAME_CreateLink(HITLS_Config *config, BSL_UIO_TransportType type)
{
#ifdef HITLS_TLS_CONFIG_KEY_USAGE
HITLS_CFG_SetCheckKeyUsage(config, false);
#endif /* HITLS_TLS_CONFIG_KEY_USAGE */
#ifdef HITLS_TLS_FEATURE_SECURITY
HITLS_CFG_SetSecurityLevel(config, HITLS_SECURITY_LEVEL_ZERO);
#endif /* HITLS_TLS_FEATURE_SECURITY */
return FRAME_CreateLinkBase(config, type, true);
}
FRAME_LinkObj *FRAME_CreateLinkEx(HITLS_Config *config, BSL_UIO_TransportType type)
{
#ifdef HITLS_TLS_CONFIG_KEY_USAGE
HITLS_CFG_SetCheckKeyUsage(config, false);
#endif /* HITLS_TLS_CONFIG_KEY_USAGE */
#ifdef HITLS_TLS_FEATURE_SECURITY
HITLS_CFG_SetSecurityLevel(config, HITLS_SECURITY_LEVEL_ZERO);
#endif /* HITLS_TLS_FEATURE_SECURITY */
return FRAME_CreateLinkBase(config, type, false);
}
FRAME_LinkObj *FRAME_CreateLinkWithCert(HITLS_Config *config, BSL_UIO_TransportType type, const FRAME_CertInfo* certInfo)
{
#ifdef HITLS_TLS_CONFIG_KEY_USAGE
HITLS_CFG_SetCheckKeyUsage(config, false);
#endif /* HITLS_TLS_CONFIG_KEY_USAGE */
#ifdef HITLS_TLS_FEATURE_SECURITY
if (config->securityLevel == HITLS_SECURITY_LEVEL_ONE) {
HITLS_CFG_SetSecurityLevel(config, HITLS_SECURITY_LEVEL_ZERO);
}
#endif /* HITLS_TLS_FEATURE_SECURITY */
int32_t ret;
ret = HiTLS_X509_LoadCertAndKey(config,
certInfo->caFile,
certInfo->chainFile,
certInfo->endEquipmentFile,
certInfo->signFile,
certInfo->privKeyFile,
certInfo->signPrivKeyFile);
if (ret != HITLS_SUCCESS) {
return NULL;
}
return CreateLink(config, type);
}
void FRAME_FreeLink(FRAME_LinkObj *linkObj)
{
if (linkObj == NULL) {
return;
}
FRAME_IO_FreeUserData(BSL_UIO_GetUserData(linkObj->io));
// BSL_UIO_Free is automatically invoked twice in HITLS_Free
#ifdef HITLS_TLS_FEATURE_FLIGHT
if (linkObj->io != NULL && linkObj->io->references.count >= 2) {
while (linkObj->io->references.count > 2) {
BSL_UIO_Free(linkObj->io);
}
} else {
#endif
BSL_UIO_Free(linkObj->io);
#ifdef HITLS_TLS_FEATURE_FLIGHT
}
#endif
HITLS_Free(linkObj->ssl);
BSL_SAL_FREE(linkObj);
return;
}
HITLS_Ctx *FRAME_GetTlsCtx(const FRAME_LinkObj *linkObj)
{
if (linkObj == NULL) {
return NULL;
}
return linkObj->ssl;
}
|
2301_79861745/bench_create
|
testcode/framework/tls/frame/src/frame_link.c
|
C
|
unknown
| 8,910
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef FRAME_LINK_H
#define FRAME_LINK_H
#include "hitls.h"
#include "bsl_uio.h"
#ifdef __cplusplus
extern "C" {
#endif
struct FRAME_LinkObj_ {
HITLS_Ctx *ssl;
BSL_UIO *io;
/* For CCS test, make TRY_RECV_FINISH stop before receiving CCS message */
bool needStopBeforeRecvCCS;
};
struct FRAME_CertInfo_ {
const char* caFile;
const char* chainFile;
const char* endEquipmentFile;
const char* signFile; // used TLCP
const char* privKeyFile;
const char* signPrivKeyFile; // used TLCP
};
#define INIT_IO_METHOD(method, tp, pfWrite, pfRead, pfCtrl) \
do { \
(method).uioType = tp; \
(method).uioRead = pfRead; \
(method).uioWrite = pfWrite; \
(method).uioCtrl = pfCtrl; \
} while (0)
#ifdef __cplusplus
}
#endif
#endif // FRAME_LINK_H
|
2301_79861745/bench_create
|
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;
}
|
2301_79861745/bench_create
|
testcode/framework/tls/frame/src/frame_msg.c
|
C
|
unknown
| 1,561
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef REC_WRAPPER_H
#define REC_WRAPPER_H
#include "rec.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief REC_read, REC_write read/write callback
*
* @param ctx [IN] TLS context
* @param buf [IN/OUT] Read/write buffer
* @param bufLen [IN/OUT] Reads and writes len bytes
* @param bufSize [IN] Maximum buffer size
* @param userData [IN/OUT] User-defined data
*/
typedef void (*WrapperFunc)(TLS_Ctx *ctx, uint8_t *buf, uint32_t *bufLen, uint32_t bufSize, void* userData);
typedef struct {
HITLS_HandshakeState ctrlState;
REC_Type recordType;
bool isRecRead;
void *userData;
WrapperFunc func;
} RecWrapper;
void RegisterWrapper(RecWrapper wrapper);
void ClearWrapper(void);
#ifdef __cplusplus
}
#endif
#endif // REC_WRAPPER_H
|
2301_79861745/bench_create
|
testcode/framework/tls/func_wrapper/include/rec_wrapper.h
|
C
|
unknown
| 1,315
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "securec.h"
#include "hitls_build.h"
#include "rec_crypto.h"
#include "hs_ctx.h"
#include "stub_replace.h"
#include "rec_wrapper.h"
#define MAX_BUF 16384
static RecWrapper g_recWrapper;
static bool g_enableWrapper;
static __thread uint8_t g_locBuffer[MAX_BUF] = { 0 };
extern int32_t __real_REC_Read(TLS_Ctx *ctx, REC_Type recordType, uint8_t *data, uint32_t *readLen, uint32_t num);
extern int32_t __real_REC_Write(TLS_Ctx *ctx, REC_Type recordType, const uint8_t *data, uint32_t num);
extern int32_t __wrap_REC_Read(TLS_Ctx *ctx, REC_Type recordType, uint8_t *data, uint32_t *readLen, uint32_t num)
{
return __real_REC_Read(ctx, recordType, data, readLen, num);
}
extern int32_t __wrap_REC_Write(TLS_Ctx *ctx, REC_Type recordType, const uint8_t *data, uint32_t num)
{
// Length that can be manipulated in wrapper
uint32_t manipulateLen = num;
if (!g_enableWrapper || g_recWrapper.isRecRead || g_recWrapper.recordType != recordType) {
return __real_REC_Write(ctx, recordType, data, manipulateLen);
}
if (g_recWrapper.recordType == REC_TYPE_HANDSHAKE && ctx->hsCtx->state != g_recWrapper.ctrlState) {
return __real_REC_Write(ctx, recordType, data, manipulateLen);
}
(void)memcpy_s(g_locBuffer, MAX_BUF, data, num);
// The value of manipulateLen can be greater than or smaller than num
g_recWrapper.func(ctx, g_locBuffer, &manipulateLen, MAX_BUF, g_recWrapper.userData);
if (ctx->hsCtx->bufferLen < manipulateLen) {
uint8_t *tmp = BSL_SAL_Realloc(ctx->hsCtx->msgBuf, manipulateLen, ctx->hsCtx->bufferLen);
if (tmp == NULL) {
return HITLS_MEMALLOC_FAIL;
}
ctx->hsCtx->bufferLen = manipulateLen;
ctx->hsCtx->msgBuf = tmp;
}
if (recordType == REC_TYPE_HANDSHAKE) {
(void)memcpy_s(ctx->hsCtx->msgBuf, ctx->hsCtx->bufferLen, g_locBuffer, manipulateLen);
ctx->hsCtx->msgLen = manipulateLen;
}
int32_t ret = __real_REC_Write(ctx, recordType, g_locBuffer, manipulateLen);
if (recordType == REC_TYPE_HANDSHAKE && ret == HITLS_SUCCESS) {
ctx->hsCtx->msgOffset = manipulateLen - num;
}
return ret;
}
RecCryptoFunc g_aeadFuncs;
RecCryptoFunc g_cbcFuncs;
RecCryptoFunc g_plainFuncs;
void FRAME_InitRecCrypto(void)
{
g_plainFuncs = *RecGetCryptoFuncs(NULL);
RecConnSuitInfo info = {0};
info.cipherType = HITLS_AEAD_CIPHER;
g_aeadFuncs = *RecGetCryptoFuncs(&info);
info.cipherType = HITLS_CBC_CIPHER;
g_cbcFuncs = *RecGetCryptoFuncs(&info);
}
static RecCryptoFunc *RecGetOriginCryptFuncs(RecConnSuitInfo *suiteInfo)
{
if (suiteInfo == NULL) {
return &g_plainFuncs;
}
switch (suiteInfo->cipherType) {
case HITLS_AEAD_CIPHER:
return &g_aeadFuncs;
case HITLS_CBC_CIPHER:
return &g_cbcFuncs;
default:
return &g_plainFuncs;
}
return &g_plainFuncs;
}
static int32_t WrapperDecryptFunc(TLS_Ctx *ctx, RecConnState *state, const REC_TextInput *cryptMsg,
uint8_t *data, uint32_t *dataLen)
{
int32_t ret = RecGetOriginCryptFuncs(state->suiteInfo)->decrypt(ctx, state, cryptMsg, data, dataLen);
if (ret == HITLS_SUCCESS && IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask) && g_recWrapper.isRecRead) {
if (g_recWrapper.recordType != cryptMsg->type) {
return ret;
}
if (g_recWrapper.recordType == REC_TYPE_HANDSHAKE) {
if (ctx->hsCtx == NULL || ctx->hsCtx->state != g_recWrapper.ctrlState) {
return ret;
}
}
g_recWrapper.func(ctx, data, dataLen, *dataLen, g_recWrapper.userData);
}
return ret;
}
static int32_t WrapperDecryptPostProcess(TLS_Ctx *ctx, RecConnSuitInfo *suitInfo, REC_TextInput *cryptMsg,
uint8_t *data, uint32_t *dataLen)
{
int32_t ret = RecGetOriginCryptFuncs(suitInfo)->decryptPostProcess(ctx, suitInfo, cryptMsg, data, dataLen);
if (ret == HITLS_SUCCESS && g_recWrapper.isRecRead) {
if (g_recWrapper.recordType != cryptMsg->type) {
return ret;
}
if (g_recWrapper.recordType == REC_TYPE_HANDSHAKE) {
if (ctx->hsCtx == NULL || ctx->hsCtx->state != g_recWrapper.ctrlState) {
return ret;
}
}
g_recWrapper.func(ctx, data, dataLen, *dataLen, g_recWrapper.userData);
}
return ret;
}
static int32_t WrapperCalPlantextBufLenFunc(TLS_Ctx *ctx, RecConnSuitInfo *suitInfo,
uint32_t ciphertextLen, uint32_t *offset, uint32_t *plainLen)
{
(void)ctx;
(void)suitInfo;
(void)ciphertextLen;
(void)offset;
*plainLen = 16384 + 2048;
return HITLS_SUCCESS;
}
static RecCryptoFunc *Stub_RecCrypto(RecConnSuitInfo *suiteInfo)
{
static RecCryptoFunc recCryptoFunc = { 0 };
recCryptoFunc = *RecGetOriginCryptFuncs(suiteInfo);
recCryptoFunc.calPlantextBufLen = WrapperCalPlantextBufLenFunc;
recCryptoFunc.decrypt = WrapperDecryptFunc;
recCryptoFunc.decryptPostProcess = WrapperDecryptPostProcess;
return &recCryptoFunc;
}
FuncStubInfo g_stubRecFuncs;
void RegisterWrapper(RecWrapper wrapper)
{
if (g_enableWrapper) {
ClearWrapper();
}
FRAME_InitRecCrypto();
STUB_Init();
STUB_Replace(&g_stubRecFuncs, (void *)RecGetCryptoFuncs, (void *)Stub_RecCrypto);
g_enableWrapper = true;
g_recWrapper = wrapper;
}
void ClearWrapper(void)
{
STUB_Reset(&g_stubRecFuncs);
g_enableWrapper = false;
}
|
2301_79861745/bench_create
|
testcode/framework/tls/func_wrapper/src/rec_wrapper.c
|
C
|
unknown
| 6,020
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef FRAME_MSG_H
#define FRAME_MSG_H
#include <stdint.h>
#include "hs_msg.h"
#include "rec.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Used to determine the field status during packing */
typedef enum {
/* field is missing. If this state is set, the field will not be packed into the buffer during packing */
MISSING_FIELD = 0,
/* field initial status. The field status in the parsed msg structure is filled with the value. */
INITIAL_FIELD,
/* Specifies the value of the field. If the field content is modified, set the status to the value. */
ASSIGNED_FIELD,
/* Repeat the field. During the packing, the field will be packed again */
DUPLICATE_FIELD,
/* Only one byte length is packed and used to construct abnormal messages.
It is used for two or more bytes of fields (such as the cipher suite length). */
SET_LEN_TO_ONE_BYTE,
} FieldState;
// uint64_t data with status
typedef struct {
FieldState state; /* Field state */
uint64_t data; /* Content */
} FRAME_Integer;
// uint8_t data with status
typedef struct {
FieldState state; /* Field state */
uint32_t size; /* Number of data records */
uint8_t *data; /* Content */
} FRAME_Array8;
// uint16_t data with status
typedef struct {
FieldState state; /* Field state */
uint32_t size; /* Number of data records */
uint16_t *data; /* Content */
} FRAME_Array16;
typedef struct {
FieldState exState; /* extension Field state */
FRAME_Integer exType; /* extension type */
FRAME_Integer exLen; /* Full length of extension */
FRAME_Integer exDataLen; /* Length of extension content */
FRAME_Array8 exData; /* extension content */
} FRAME_HsExtArray8;
// The handshake extension with state carries a variable-length array with uint16_t
// such as the signature algorithm extension
typedef struct {
FieldState exState; /* extension Field state */
FRAME_Integer exType; /* extension type */
FRAME_Integer exLen; /* Full length of extension */
FRAME_Integer exDataLen; /* Length of extension content */
FRAME_Array16 exData; /* extension content */
} FRAME_HsExtArray16;
typedef struct {
FieldState state; /* Field state */
FRAME_Integer group; /* group */
FRAME_Integer keyExchangeLen; /* key exchange size */
FRAME_Array8 keyExchange;
} FRAME_HsKeyShareEntry;
typedef struct {
FieldState state; /* Field state */
uint32_t size; /* Number of entries */
FRAME_HsKeyShareEntry *data; /* key shareContent */
} FRAME_HsArrayKeyShare;
typedef struct {
FieldState exState; /* extension Field state */
FRAME_Integer exType; /* extension type */
FRAME_Integer exLen; /* Full length of extension */
FRAME_Integer exKeyShareLen; /* keyshare Array length */
FRAME_HsArrayKeyShare exKeyShares; /* keyshare array content */
} FRAME_HsExtKeyShare;
typedef struct {
FieldState state; /* Field state */
FRAME_Integer identityLen;
FRAME_Array8 identity;
FRAME_Integer obfuscatedTicketAge;
} FRAME_HsPskIdentity;
typedef struct {
FieldState state; /* Field state */
uint32_t size; /* Number of identities */
FRAME_HsPskIdentity *data; /* identity Content */
} FRAME_HsArrayPskIdentity;
typedef struct {
FieldState state; /* Field state */
FRAME_Integer binderLen;
FRAME_Array8 binder;
} FRAME_HsPskBinder;
typedef struct {
FieldState state; /* Field state */
uint32_t size; /* Number of identities */
FRAME_HsPskBinder *data; /* identity Content */
} FRAME_HsArrayPskBinder;
typedef struct {
FieldState exState; /* extension Field state */
FRAME_Integer exType; /* extension type */
FRAME_Integer exLen; /* Full length of extension */
FRAME_Integer identitySize;
FRAME_HsArrayPskIdentity identities;
FRAME_Integer binderSize;
FRAME_HsArrayPskBinder binders;
} FRAME_HsExtOfferedPsks;
typedef struct {
FieldState exState; /* extension Field state */
FRAME_Integer exType; /* extension type */
FRAME_Integer exLen; /* Full length of extension */
FRAME_Array8 list; /* CA list */
FRAME_Integer listSize; /* CA list length */
} FRAME_HsExtCaList;
typedef struct {
FRAME_Integer version; /* Version number */
FRAME_Array8 randomValue; /* Random number */
FRAME_Integer sessionIdSize; /* session ID length */
FRAME_Array8 sessionId; /* session ID */
FRAME_Integer cookiedLen; /* Cookie length (for DTLS) */
FRAME_Array8 cookie; /* cookie(for DTLS) */
FRAME_Integer cipherSuitesSize; /* cipher suite length */
FRAME_Array16 cipherSuites; /* cipher suite */
FRAME_Integer compressionMethodsLen; /* compression method length */
FRAME_Array8 compressionMethods; /* compression method */
FieldState extensionState; /* Indicates whether the extension is packed */
FRAME_Integer extensionLen; /* Total length of the extension */
FRAME_HsExtArray8 pointFormats;
FRAME_HsExtArray16 supportedGroups;
FRAME_HsExtArray16 signatureAlgorithms;
FRAME_HsExtArray8 encryptThenMac;
FRAME_HsExtArray8 extendedMasterSecret;
FRAME_HsExtArray8 secRenego; /* security renegotiation */
FRAME_HsExtArray8 sessionTicket;
FRAME_HsExtArray8 serverName; /* sni */
FRAME_HsExtArray8 alpn; /* alpn */
FRAME_HsExtArray8 tls13Cookie; /* tls1.3 cookie */
FRAME_HsExtKeyShare keyshares; /* tls1.3 key share */
FRAME_HsExtArray8 pskModes; /* tls1.3 psk exchange mode */
FRAME_HsExtArray16 supportedVersion; /* tls1.3 support version */
FRAME_HsExtOfferedPsks psks; /* tls1.3 psk */
FRAME_HsExtCaList caList;
} FRAME_ClientHelloMsg;
typedef struct {
FieldState exState; /* extension Field state */
FRAME_Integer exType; /* extension type */
FRAME_Integer exLen; /* Full length of extension */
FRAME_Integer data; /* extension content */
} FRAME_HsExtUint16;
typedef struct {
FieldState exState; /* extension Field state */
FRAME_Integer exType; /* extension type */
FRAME_Integer exLen; /* Full length of extension */
FRAME_HsKeyShareEntry data; /* extension content */
} FRAME_HsExtServerKeyShare;
typedef struct {
FRAME_Integer version; /* Version number */
FRAME_Array8 randomValue; /* Random number */
FRAME_Integer sessionIdSize; /* session ID length */
FRAME_Array8 sessionId; /* session ID */
FRAME_Integer cipherSuite;
FRAME_Integer compressionMethod;
FRAME_Integer extensionLen; /* Full length of the extended field */
FRAME_HsExtArray8 pointFormats;
FRAME_HsExtArray8 extendedMasterSecret;
FRAME_HsExtArray8 secRenego; /* security renegotiation */
FRAME_HsExtArray8 sessionTicket; /* sessionTicket */
FRAME_HsExtArray8 serverName; /* sni */
FRAME_HsExtArray8 alpn; /* alpn */
FRAME_HsExtUint16 supportedVersion; /* tls1.3 supported version */
FRAME_HsExtServerKeyShare keyShare; /* tls1.3 key share */
FRAME_HsExtUint16 pskSelectedIdentity; /* tls1.3 psk extension */
FRAME_HsExtArray8 tls13Cookie; /* tls1.3 cookie */
FRAME_HsExtArray8 encryptThenMac;
} FRAME_ServerHelloMsg;
typedef struct {
FRAME_Array8 extra; /* server hello done is a null message. This field is used to construct abnormal messages */
} FRAME_ServerHelloDoneMsg;
typedef struct FrameCertItem_ {
FieldState state; /* Certificate Field state */
FRAME_Integer certLen; /* Certificate length */
FRAME_Array8 cert; /* Certificate Content */
FRAME_Integer extensionLen; /* Certificate extension length. only for tls1.3 */
FRAME_Array8 extension; /* Certificate extension Content. only for tls1.3 */
struct FrameCertItem_ *next;
} FrameCertItem;
typedef struct {
FRAME_Integer certsLen; /* Certificate total length */
FrameCertItem *certItem; /* Certificate */
FRAME_Array8 certificateReqCtx; /* For TLS 1.3 */
FRAME_Integer certificateReqCtxSize; /* For TLS 1.3 */
} FRAME_CertificateMsg;
typedef struct {
FRAME_Integer curveType; /* Curve type */
FRAME_Integer namedcurve; /* Named curve */
FRAME_Integer pubKeySize; /* ecdh public key size */
FRAME_Array8 pubKey; /* ecdh public key content */
FRAME_Integer signAlgorithm; /* Signature hash algorithm, for TLS1.2 and DTLS1.2 */
FRAME_Integer signSize; /* Signature length */
FRAME_Array8 signData; /* Signature Content */
} FRAME_ServerEcdh;
typedef struct {
FRAME_Integer plen;
FRAME_Array8 p;
FRAME_Integer glen;
FRAME_Array8 g;
FRAME_Integer pubKeyLen; /* dh public key */
FRAME_Array8 pubKey; /* dH public key content */
FRAME_Integer signAlgorithm; /* Signature hash algorithm, for TLS1.2 and DTLS1.2 */
FRAME_Integer signSize; /* Signature length */
FRAME_Array8 signData; /* Signature content */
} FRAME_ServerDh;
typedef struct {
union {
FRAME_ServerEcdh ecdh;
FRAME_ServerDh dh;
} keyEx;
} FRAME_ServerKeyExchangeMsg;
typedef struct {
FRAME_Integer pubKeySize; /* Key exchange data length */
FRAME_Array8 pubKey; /* Key exchange data */
} FRAME_ClientKeyExchangeMsg;
typedef struct {
FieldState state; /* Field state */
FRAME_Integer certTypesSize; /* certificate type length */
FRAME_Array8 certTypes; /* Certificate type list */
FRAME_Integer signatureAlgorithmsSize; /* signature algorithm length */
FRAME_Array16 signatureAlgorithms; /* signature algorithm list */
FRAME_Integer reserved; /* Four-byte alignment */
FRAME_Integer distinguishedNamesSize; /* DN length */
FRAME_Array8 distinguishedNames; /* DN */
FRAME_Array8 certificateReqCtx; /* For TLS 1.3 */
FRAME_Integer certificateReqCtxSize; /* For TLS 1.3 */
FRAME_Integer exMsgLen;
} FRAME_CertificateRequestMsg;
/* Used to transmit certificate verification packets. */
typedef struct {
FRAME_Integer signHashAlg; /* Signature hash algorithm, used for TLS1.2 and DTLS1.2 */
FRAME_Integer signSize; /* Length of the signature data */
FRAME_Array8 sign; /* Signature data */
} FRAME_CertificateVerifyMsg;
typedef struct {
FRAME_Integer ticketLifetime;
FRAME_Integer ticketAgeAdd;
FRAME_Integer ticketNonceSize;
FRAME_Array8 ticketNonce;
FRAME_Integer ticketSize;
FRAME_Array8 ticket;
FRAME_Integer extensionLen; /* Total length of the extension */
} FRAME_NewSessionTicketMsg;
/* Transmit the Finish message */
typedef struct {
FRAME_Array8 verifyData; /* verify data Content */
} FRAME_FinishedMsg;
typedef struct {
FRAME_Integer type; /* Handshake type */
FRAME_Integer length; /* Length of the handshake message */
/* Sequence number of DTLS handshake messages. Increases by 1 each time a new handshake message is sent.
*Does not increase for retransmission */
FRAME_Integer sequence;
FRAME_Integer fragmentOffset; /* Fragment offset of DTLS handshake message */
FRAME_Integer fragmentLength; /* DTLS Handshake message Fragment Length */
union {
FRAME_ClientHelloMsg clientHello;
FRAME_ServerHelloMsg serverHello;
FRAME_CertificateMsg certificate;
FRAME_ServerKeyExchangeMsg serverKeyExchange;
FRAME_CertificateRequestMsg certificateReq;
FRAME_ServerHelloDoneMsg serverHelloDone;
FRAME_ClientKeyExchangeMsg clientKeyExchange;
FRAME_CertificateVerifyMsg certificateVerify;
FRAME_NewSessionTicketMsg newSessionTicket;
FRAME_FinishedMsg finished;
} body;
} FRAME_HsMsg;
typedef struct {
uint8_t level; /* To be deleted. The member is not processed because some code uses it */
uint8_t description; /* To be deleted. The member is not processed because some code uses it */
FRAME_Integer alertLevel; /* Alert level: See ALERT_Level */
FRAME_Integer alertDescription; /* Alert description: See ALERT_Description */
FRAME_Array8 extra; /* This field is used to construct abnormal messages */
} FRAME_AlertMsg;
typedef struct {
uint8_t type; /* To be deleted. The member is not processed because some code uses it */
FRAME_Integer ccsType; /* ccs type */
FRAME_Array8 extra; /* This field is used to construct abnormal messages */
} FRAME_CcsMsg;
typedef struct {
char *buffer; /* To be deleted. The member is not processed because some code uses it */
uint32_t len; /* To be deleted. The member is not processed because some code uses it */
FRAME_Array8 appData; /* app data */
} FRAME_AppMsg;
typedef struct {
uint8_t type; /* To be deleted. The member is not processed because some code uses it */
uint8_t reverse; /* To be deleted. The member is not processed because some code uses it */
uint16_t version; /* To be deleted. The member is not processed because some code uses it */
uint16_t bodyLen; /* To be deleted. The member is not processed because some code uses it */
BSL_UIO_TransportType transportType;
uint64_t epochSeq; /* To be deleted. The member is not processed because some code uses it */
FRAME_Integer recType; /* record the message type */
FRAME_Integer recVersion; /* record version */
FRAME_Integer epoch; /* Counter value that increases each time the password status changes.
This counter is used by DTLS */
FRAME_Integer sequence; /* Record message sequence number, for DTLS */
FRAME_Integer length; /* Length of the record message */
union {
HS_Msg handshakeMsg; /* To be deleted. The member is not processed because some code uses it */
FRAME_HsMsg hsMsg;
FRAME_AlertMsg alertMsg;
FRAME_CcsMsg ccsMsg;
FRAME_AppMsg appMsg;
} body;
uint8_t *buffer; /* To be deleted. The member is not processed because some code uses it */
uint32_t len; /* To be deleted. The member is not processed because some code uses it */
} FRAME_Msg;
/* Used to transfer the message type. The framework packs and parses the corresponding message based on the field value
* of this structure */
typedef struct {
uint16_t versionType;
/* To ensure that the memory can be released normally, a value is assigned to the member during parsing */
REC_Type recordType;
/* To ensure that the memory can be released normally, a value is assigned to the member during parsing */
HS_MsgType handshakeType;
HITLS_KeyExchAlgo keyExType;
BSL_UIO_TransportType transportType;
} FRAME_Type;
/**
* @brief Generate a TLS record byte stream based on the specified parameter of frameType
* and the field content of the msg structure and save the stream to the buffer
* @param frameType [IN] Specified packing parameters
* @param msg [IN] Message structure
* @param buf [OUT] Returned handshake message
* @param bufLen [IN] Input buffer size
* @param usedLen [OUT] Returned message length
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_PackMsg(FRAME_Type *frameType, const FRAME_Msg *msg, uint8_t *buffer, uint32_t bufLen, uint32_t *usedLen);
/**
* @brief Generate tls13 handshake message according to type
* @param type [IN] Specified packing parameters
* @param buf [OUT] Returned handshake message
* @param bufLen [IN] Input buffer size
* @param usedLen [OUT] Returned message length
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_GetTls13DisorderHsMsg(HS_MsgType type, uint8_t *buffer, uint32_t bufLen, uint32_t *usedLen);
/**
* @brief Generate a TLS record body byte stream based on the specified parameter of frameType
* and the field content of the msg structure and save the byte stream to the buffer.
*
* @param frameType [IN] Specified packing parameters
* @param msg [IN] Message structure
* @param buffer [OUT] Returned handshake message
* @param bufLen [IN] Input buffer size
* @param usedLen [OUT] Returned message length
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_PackRecordBody(FRAME_Type *frameType, const FRAME_Msg *msg,
uint8_t *buffer, uint32_t bufLen, uint32_t *usedLen);
/**
* @brief Parse the MSG structure based on the specified parameter of frameType and the TLS record byte stream.
* Only the record message header is parsed
*
* @param frameType [IN] Specified parsing parameter, mainly versionType
* @param buffer [IN] TLS record byte stream
* @param bufLen [IN] Input buffer size
* @param msg [OUT] Parsed Message structure
* @param parseLen [OUT] Length of the parsed message
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_ParseMsgHeader(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_Msg *msg, uint32_t *parseLen);
/**
* @brief parse TLS record header
*
* @param buffer [IN] TLS record byte stream
* @param bufferLen [IN] Input buffer size
* @param msg [OUT] Parsed Message structure
* @param headerLen [OUT] Length of the parsed message
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_ParseTLSRecordHeader(const uint8_t *buffer, uint32_t bufferLen,
FRAME_Msg *msg, uint32_t *parseLen);
/**
* @brief Parse the body of the TLS non-handshake record
*
* @param buffer [IN] TLS record byte stream
* @param bufferLen [IN] Input buffer size
* @param msg [OUT] Parsed Message structure
* @param headerLen [OUT] Length of the parsed message
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_ParseTLSNonHsRecordBody(const uint8_t *buffer, uint32_t bufferLen,
FRAME_Msg *msg, uint32_t *parseLen);
/**
* @brief Parse the TLS non-handshake record
*
* @param buffer [IN] TLS record byte stream
* @param bufferLen [IN] Input buffer size
* @param msg [OUT] Parsed Message structure
* @param headerLen [OUT] Length of the parsed message
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_ParseTLSNonHsRecord(const uint8_t *buffer, uint32_t bufferLen,
FRAME_Msg *msg, uint32_t *parseLen);
/**
* @brief Parse the record of the handshake type
*
* @param buffer [IN] TLS record byte stream
* @param bufferLen [IN] Input buffer size
* @param msg [OUT] Parsed Message structure
* @param headerLen [OUT] Length of the parsed message
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_ParseHsRecord(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufferLen,
FRAME_Msg *msg, uint32_t *parseLen);
/**
* @brief Parse the MSG structure based on the specified parameter of frameType and the TLS record byte stream.
* Only the record message body is parsed
*
* @attention Invoke the Frame_ParseMsgHeader interface to parse the message header
*
* @param frameType [IN] Specified parsing parameters, mainly versionType and keyExType
* @param buffer [IN] TLS record byte stream
* @param bufLen [IN] Input buffer size
* @param msg [OUT] Parsed Message structure
* @param parseLen [OUT] Length of the parsed message
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_ParseMsgBody(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_Msg *msg, uint32_t *parseLen);
/**
* @brief Parse the message into the msg structure based on the specified parameter of frameType and
* the TLS record byte stream
*
* @param frameType [IN] Specified parsing parameters, mainly versionType and keyExType
* @param buffer [IN] TLS record byte stream
* @param bufLen [IN] Input buffer size
* @param msg [OUT] Parsed Message structure
* @param parseLen [OUT] Length of the parsed message
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_ParseMsg(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_Msg *msg, uint32_t *parseLen);
/**
* @brief Clear the memory allocated during parsing
*
* @param frameType [IN] Specified parsing parameters, mainly versionType and keyExType
* @param msg [IN] Message structure
*/
void FRAME_CleanMsg(FRAME_Type *frameType, FRAME_Msg *msg);
/**
* @brief Clear the memory allocated during parsing
*
* @param recType [IN] Specified record type
* @param msg [IN] Message structure
*/
void FRAME_CleanNonHsRecord(REC_Type recType, FRAME_Msg *msg);
/**
* @brief Obtain a structure of a specified message type
*
* @attention This interface does not set the callback function. User need to set the callback interface first
* This interface obtains only the HANDSHAKE,Change_CIPHER_SPEC, and ALERT messages
* The existing framework does not support parsing of encrypted finished messages.
* Therefore, the finished messages cannot be obtained.
*
* @param frameType [IN] Specified message parameters
* @param msg [OUT] Returned Message structure
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_GetDefaultMsg(FRAME_Type *frameType, FRAME_Msg *msg);
/**
* @brief Modify a message field
* This method is used to modify the contents of integer fields in a message, such as the message type,
* version number, and field length
*
* @param data [IN] Data content
* @param frameInteger [IN/OUT] IN original field; OUT New field
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_ModifyMsgInteger(const uint64_t data, FRAME_Integer *frameInteger);
/**
* @brief Modify the message field content. User can increase or decrease the length of the message field and modify
* the field content.
* (This implementation performs deep copy of the data content.)
* This method is used to modify the content of the uint8_t array field in a message, such as the session ID,
* cookie, and signature data
*
* @param data [IN] Data content
* @param dataLen [IN] Number of data records
* @param frameArray [IN/OUT] IN original field; OUT New field
* @param frameArrayLen [IN/OUT] IN Original field length; Length of the new field in the OUT field. This parameter
* can be none
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_ModifyMsgArray8(const uint8_t *data, uint32_t dataLen,
FRAME_Array8 *frameArray, FRAME_Integer *frameArrayLen);
/**
* @brief Retain the original handshake message field content and add a string of data data to the end of the data.
* (This implementation performs deep copy of the data content.)
* This method is used to modify the content of the uint8_t array field in a message, such as the session ID,
* cookie, and signature data.
*
* @param data [IN] Data content
* @param dataLen [IN] Number of data records
* @param frameArray [IN/OUT] IN original field; OUT New field
* @param frameArrayLen [IN/OUT] IN Original field length; Length of the new field in the OUT field. This parameter
* can be none
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_AppendMsgArray8(const uint8_t *data, uint32_t dataLen,
FRAME_Array8 *frameArray, FRAME_Integer *frameArrayLen);
/**
* @brief Modify the message field content. User can increase or decrease the length of the message field and modify
* the field content.
* (This implementation performs deep copy of the data content.)
* This method is used to modify the uint16_t array field in a message, for example, cipher suite and support
* group extension
*
* @param data [IN] Data content
* @param dataLen [IN] Number of data records
* @param frameArray [IN/OUT] IN original field; OUT New field
* @param frameArrayLen [IN/OUT] IN Original field length; Length of the new field in the OUT field. This parameter
* can be none
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_ModifyMsgArray16(const uint16_t *data, uint32_t dataLen,
FRAME_Array16 *frameArray, FRAME_Integer *frameArrayLen);
/**
* @brief Retain the original handshake message field content and add a string of data data to the end of the data.
* (This implementation performs deep copy of the data content.)
* This method is used to modify the uint16_t array field in a message, for example, the cipher suite and
* support group extension
*
* @param data [IN] Data content
* @param dataLen [IN] Number of data records
* @param frameArray [IN/OUT] IN original field; OUT New field
* @param frameArrayLen [IN/OUT] IN Original field length; Length of the new field in the OUT field. This parameter
* can be none
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t FRAME_AppendMsgArray16(const uint16_t *data, uint32_t dataLen,
FRAME_Array16 *frameArray, FRAME_Integer *frameArrayLen);
#ifdef __cplusplus
}
#endif
#endif // FRAME_MSG_H
|
2301_79861745/bench_create
|
testcode/framework/tls/include/frame_msg.h
|
C
|
unknown
| 26,690
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef FRAME_TLS_H
#define FRAME_TLS_H
#include "bsl_uio.h"
#include "hs_ctx.h"
#include "frame_msg.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct FRAME_LinkObj_ FRAME_LinkObj;
typedef struct FRAME_CertInfo_ FRAME_CertInfo;
typedef struct SSL_LINK_OBJ_ SSL_LINK_OBJ;
HITLS_Ctx *FRAME_CreateDefaultDtlsObj(void);
/**
* @brief Load the certificate to the connection configuration context resource.
*
* @return If the value 0 is returned, the certificate is loaded successfully.
* Otherwise, the certificate fails to be loaded
*/
int32_t FRAME_LoadCertToConfig(HITLS_Config *config, const char *verifyCert, const char *chainCert, const char *eeCert,
const char *prvKey);
/**
* @brief Create a TLCP connection.
This interface loads the certificate, applies for SSL CTX, and creates the underlying UIO
*
* @return Return the connection object, which can be used by the test framework to perform operations
*/
FRAME_LinkObj *FRAME_CreateTLCPLink(HITLS_Config *config, BSL_UIO_TransportType type, bool isClient);
/**
* @brief Create an SSL connection. This interface will complete the SSL CTX application,
bottom-layer UIO creation, and load the default certificate
*
* @return Return the connection object, which can be used by the test framework to perform operations
*/
FRAME_LinkObj *FRAME_CreateLink(HITLS_Config *config, BSL_UIO_TransportType type);
// This interface is used to create an SSL connection.
// The SSL CTX application and bottom-layer UIO creation are completed. The default certificate is not loaded.
FRAME_LinkObj *FRAME_CreateLinkEx(HITLS_Config *config, BSL_UIO_TransportType type);
FRAME_LinkObj *FRAME_CreateLinkWithCert(
HITLS_Config *config, BSL_UIO_TransportType type, const FRAME_CertInfo *certInfo);
/**
* @brief Create an SSL connection with configurable certificate loading.
* This interface will complete the SSL CTX application and bottom-layer UIO creation.
* The setCertFlag parameter controls whether to load the default certificate.
*
* @param config [IN] TLS configuration
* @param type [IN] Transport type
* @param setCertFlag [IN] Whether to load default certificate
*
* @return Return the connection object, which can be used by the test framework to perform operations
*/
FRAME_LinkObj *FRAME_CreateLinkBase(HITLS_Config *config, BSL_UIO_TransportType type, bool setCertFlag);
/**
* @brief Releases an SSL connection, which corresponds to Frame_CreateLink
*
* @return
*/
void FRAME_FreeLink(FRAME_LinkObj *linkObj);
/**
* @brief Obtain the TLS ctx from the Frame_LinkObj to facilitate the test of HiTLS APIs because HiTLS APIs use
* HITLS_Ctx as the input parameter.
* Do not call HiTLS_Free to release the return values of this API.
* The values will be released in the Frame_FreeLink.
*
* @return Return the CTX object of the TLS
*/
HITLS_Ctx *FRAME_GetTlsCtx(const FRAME_LinkObj *linkObj);
/*
* @brief Simulate link establishment or simulate an SSL link in a certain state.
* For example, if state is TRY_RECV_SERVER_HELLO, the client is ready to receive the SERVER Hello message,
* and The server link is just sent SERVER_HELLO.
*
* @return If the operation is successful, HITLS_SUCCESS is returned.
*/
int32_t FRAME_CreateConnection(FRAME_LinkObj *client, FRAME_LinkObj *server, bool isClient, HITLS_HandshakeState state);
/**
* @brief Simulate renegotiation
* @attention Internally invokes HITLS_Write and HITLS_Read to perform renegotiation.
* Ensure that linkA is the initiator of the renegotiation request and
* linkB is the receiver of the renegotiation request
*
* @param server [IN] Initiator of the renegotiation request
* @param client [IN] Recipient of the renegotiation request
*
* @return If the operation is successful, HITLS_SUCCESS is returned
*/
int32_t FRAME_CreateRenegotiationServer(FRAME_LinkObj *server, FRAME_LinkObj *client);
/*
* @ingroup Simulate connection establishment or an SSL connection in a certain state.
* For example, if the value of state is TRY_RECV_SERVER_HELLO,
* the client is ready to receive the SERVER Hello message,
* and the server connection is SERVER_HELLO has just been sent.
*
*
* @return If the operation is successful, HITLS_SUCCESS is returned
*/
int32_t FRAME_CreateRenegotiationState(FRAME_LinkObj *client, FRAME_LinkObj *server, bool isClient, HITLS_HandshakeState state);
/**
* @brief Simulate renegotiation
* @attention Internally invokes HITLS_Write and HITLS_Read to perform renegotiation.
* Ensure that linkA is the initiator of the renegotiation request and
* linkB is the receiver of the renegotiation request
*
* @param linkA [IN] Initiator of the renegotiation request
* @param linkB [IN] Recipient of the renegotiation request
*
* @return If the operation is successful, HITLS_SUCCESS is returned
*/
int32_t FRAME_CreateRenegotiation(FRAME_LinkObj *linkA, FRAME_LinkObj *linkB);
/**
* @brief Obtain a message from the I/O receiving buffer of the connection
*
* @return If the operation is successful, HITLS_SUCCESS is returned
*/
int32_t FRAME_GetLinkRecMsg(FRAME_LinkObj *link, uint8_t *buffer, uint32_t len, uint32_t *msgLen);
/**
* @brief Obtain a message from the I/O sending buffer of the connection.
*
* @return If the operation is successful, HITLS_SUCCESS is returned.
*/
int32_t FRAME_GetLinkSndMsg(FRAME_LinkObj *link, uint8_t *buffer, uint32_t len, uint32_t *msgLen);
/**
* @brief Generate a framework message based on the content in the message buffer
*
* @return Return the Constructed Frame_Msg object
*/
FRAME_Msg *FRAME_GenerateMsgFromBuffer(const FRAME_LinkObj *linkObj, const uint8_t *buffer, uint32_t len);
/**
* @brief Send data from connection A to connection B
*
* @return If the operation is successful, HITLS_SUCCESS is returned
*/
int32_t FRAME_TrasferMsgBetweenLink(FRAME_LinkObj *linkA, FRAME_LinkObj *linkB);
/**
* @brief Initialize the framework
*/
void FRAME_Init(void);
/**
* @brief Deinitialize the framework
*/
void FRAME_DeInit(void);
#ifdef __cplusplus
}
#endif
#endif // FRAME_TLS_H
|
2301_79861745/bench_create
|
testcode/framework/tls/include/frame_tls.h
|
C
|
unknown
| 6,723
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef HLT_H
#define HLT_H
#include <stddef.h>
#include "hlt_type.h"
#ifdef __cplusplus
extern "C" {
#endif
void HLT_ConfigTimeOut(const char* timeout);
void HLT_UnsetTimeOut();
// Create a process
HLT_Process* InitSrcProcess(TLS_TYPE tlsType, char* srcDomainPath);
HLT_Process* InitPeerProcess(TLS_TYPE tlsType, HILT_TransportType connType, int port, bool isBlock);
#define HLT_InitLocalProcess(tlsType) InitSrcProcess(tlsType, __FILE__)
#define HLT_CreateRemoteProcess(tlsType) InitPeerProcess(tlsType, NONE_TYPE, 0, 0)
#define HLT_LinkRemoteProcess(tlsType, connType, port, isBlock) InitPeerProcess(tlsType, connType, port, isBlock)
// Clear all process resources
void HLT_FreeAllProcess(void);
int HLT_FreeResFormSsl(const void *ssl);
// Create a local data connection
HLT_FD HLT_CreateDataChannel(HLT_Process* process1, HLT_Process* process2, DataChannelParam channelParam);
int HLT_DataChannelConnect(DataChannelParam* dstChannelParam);
pthread_t HLT_DataChannelAccept(DataChannelParam* channelParam);
void HLT_CloseFd(int fd, int linkType);
// Interface for setting connection information
int HLT_SetVersion(HLT_Ctx_Config* ctxConfig, uint16_t minVersion, uint16_t maxVersion);
int HLT_SetSecurityLevel(HLT_Ctx_Config *ctxConfig, int32_t level);
int HLT_SetRenegotiationSupport(HLT_Ctx_Config* ctxConfig, bool support);
int HLT_SetLegacyRenegotiateSupport(HLT_Ctx_Config* ctxConfig, bool support);
int HLT_SetClientRenegotiateSupport(HLT_Ctx_Config* ctxConfig, bool support);
int HLT_SetEmptyRecordsNum(HLT_Ctx_Config *ctxConfig, uint32_t emptyNum);
int HLT_SetFlightTransmitSwitch(HLT_Ctx_Config *ctxConfig, bool support);
int HLT_SetKeyLogCb(HLT_Ctx_Config *ctxConfig, char *SetKeyLogCb);
int HLT_SetClientVerifySupport(HLT_Ctx_Config* ctxConfig, bool support);
int HLT_SetNoClientCertSupport(HLT_Ctx_Config* ctxConfig, bool support);
int HLT_SetPostHandshakeAuth(HLT_Ctx_Config *ctxConfig, bool support);
int HLT_SetExtenedMasterSecretSupport(HLT_Ctx_Config* ctxConfig, bool support);
int HLT_SetEncryptThenMac(HLT_Ctx_Config *ctxConfig, int support);
int HLT_SetMiddleBoxCompat(HLT_Ctx_Config *ctxConfig, int support);
int HLT_SetModeSupport(HLT_Ctx_Config *ctxConfig, uint32_t mode);
int HLT_SetCipherSuites(HLT_Ctx_Config* ctxConfig, const char* cipherSuites);
int HLT_SetProviderPath(HLT_Ctx_Config *ctxConfig, char *providerPath);
int HLT_SetProviderAttrName(HLT_Ctx_Config *ctxConfig, char *attrName);
int HLT_AddProviderInfo(HLT_Ctx_Config *ctxConfig, char *providerName, int providerLibFmt);
int HLT_SetTls13CipherSuites(HLT_Ctx_Config *ctxConfig, const char *cipherSuites);
int HLT_SetEcPointFormats(HLT_Ctx_Config* ctxConfig, const char* pointFormat);
int HLT_SetGroups(HLT_Ctx_Config* ctxConfig, const char* groups);
int HLT_SetSignature(HLT_Ctx_Config* ctxConfig, const char* signature);
int HLT_SetCaCertPath(HLT_Ctx_Config* ctxConfig, const char* caCertPath);
int HLT_SetChainCertPath(HLT_Ctx_Config* ctxConfig, const char* chainCertPath);
int HLT_SetEeCertPath(HLT_Ctx_Config* ctxConfig, const char* eeCertPath);
int HLT_SetPrivKeyPath(HLT_Ctx_Config* ctxConfig, const char* privKeyPath);
int HLT_SetPassword(HLT_Ctx_Config* ctxConfig, const char* password);
void HLT_SetCertPath(HLT_Ctx_Config* ctxConfig, const char *caPath,
const char *chainPath, const char *EePath, const char *PrivPath, const char *signCert, const char *signPrivKey);
int HLT_SetPsk(HLT_Ctx_Config *ctxConfig, char *psk);
int HLT_SetKeyExchMode(HLT_Ctx_Config *config, uint32_t mode);
int HLT_SetTicketKeyCb(HLT_Ctx_Config *ctxConfig, char *ticketKeyCbName);
int HLT_SetServerName(HLT_Ctx_Config *ctxConfig, const char *serverName);
int HLT_SetServerNameArg(HLT_Ctx_Config *ctxConfig, char *arg);
int HLT_SetServerNameCb(HLT_Ctx_Config *ctxConfig, char *sniCbName);
int HLT_SetAlpnProtos(HLT_Ctx_Config *ctxConfig, const char *alpnProtos);
int HLT_SetAlpnProtosSelectCb(HLT_Ctx_Config *ctxConfig, char *callback, char *userData);
// Interface for setting abnormal message operations
int HLT_SetFrameHandle(HLT_FrameHandle *frameHandle);
void HLT_CleanFrameHandle(void);
int HLT_FreeResFromSsl(const void *ssl);
int HLT_SetClientHelloCb(HLT_Ctx_Config *ctxConfig, HITLS_ClientHelloCb callback, void *arg);
int HLT_SetCertCb(HLT_Ctx_Config *ctxConfig, HITLS_CertCb certCb, void *arg);
int HLT_SetCAList(HLT_Ctx_Config *ctxConfig, HITLS_TrustedCAList *caList);
// General initialization interface
int HLT_LibraryInit(TLS_TYPE tlsType);
// The local process invokes TLS functions
HLT_Tls_Res* HLT_ProcessTlsInit(HLT_Process *process, TLS_VERSION tlsVersion,
HLT_Ctx_Config *ctxConfig, HLT_Ssl_Config *sslConfig);
void* HLT_TlsNewCtx(TLS_VERSION tlsVersion);
void* HLT_TlsProviderNewCtx(char *providerPath, char (*providerNames)[MAX_PROVIDER_NAME_LEN], int *providerLibFmts,
int providerCnt, char *attrName, TLS_VERSION tlsVersion);
HLT_Ctx_Config* HLT_NewCtxConfig(char* setFile, const char* key);
HLT_Ctx_Config* HLT_NewCtxConfigTLCP(char *setFile, const char *key, bool isClient);
int HLT_TlsSetCtx(void* ctx, HLT_Ctx_Config* config);
HLT_Ssl_Config* HLT_NewSslConfig(char* setFile);
void* HLT_TlsNewSsl(void* ctx);
int HLT_TlsSetSsl(void* ssl, HLT_Ssl_Config* config);
unsigned long int HLT_TlsListen(void *ssl);
unsigned long int HLT_TlsAccept(void* ssl);
int HLT_TlsListenBlock(void* ssl);
int HLT_TlsAcceptBlock(void* ssl);
int HLT_GetTlsAcceptResultFromId(unsigned long int threadId);
int HLT_GetTlsAcceptResult(HLT_Tls_Res* tlsRes);
int HLT_TlsConnect(void* ssl);
int HLT_TlsRead(void* ssl, uint8_t *data, uint32_t bufSize, uint32_t *readLen);
int HLT_TlsWrite(void* ssl, uint8_t *data, uint32_t dataLen);
int HLT_TlsRegCallback(TlsCallbackType type);
int HLT_TlsRenegotiate(void *ssl);
int HLT_TlsVerifyClientPostHandshake(void *ssl);
int HLT_TlsClose(void *ssl);
int HLT_TlsSetSession(void *ssl, void *session);
int HLT_TlsSessionReused(void *ssl);
void *HLT_TlsGet1Session(void *ssl);
int32_t HLT_SetSessionCacheMode(HLT_Ctx_Config* config, HITLS_SESS_CACHE_MODE mode);
int32_t HLT_SetSessionTicketSupport(HLT_Ctx_Config* config, bool issupport);
int HLT_TlsSessionHasTicket(void *session);
int HLT_TlsSessionIsResumable(void *session);
void HLT_TlsFreeSession(void *session);
// The RPC controls the remote process to invoke TLS functions
int HLT_RpcTlsNewCtx(HLT_Process* peerProcess, TLS_VERSION tlsVersion, bool isClient);
int HLT_RpcProviderTlsNewCtx(HLT_Process *peerProcess, TLS_VERSION tlsVersion, bool isClient, char *providerPath,
char (*providerNames)[MAX_PROVIDER_NAME_LEN], int32_t *providerLibFmts, int32_t providerCnt, char *attrName);
int HLT_RpcTlsSetCtx(HLT_Process* peerProcess, int ctxId, HLT_Ctx_Config* config);
int HLT_RpcTlsNewSsl(HLT_Process* peerProcess, int ctxId);
int HLT_RpcTlsSetSsl(HLT_Process* peerProcess, int sslId, HLT_Ssl_Config* config);
int HLT_RpcTlsListen(HLT_Process* peerProcess, int sslId);
int HLT_RpcTlsAccept(HLT_Process* peerProcess, int sslId);
int HLT_RpcGetTlsListenResult(int acceptId);
int HLT_RpcGetTlsAcceptResult(int acceptId);
int HLT_RpcTlsConnect(HLT_Process* peerProcess, int sslId);
int HLT_RpcTlsConnectUnBlock(HLT_Process *peerProcess, int sslId);
int HLT_RpcGetTlsConnectResult(int cmdIndex);
int HLT_RpcTlsRead(HLT_Process* peerProcess, int sslId, uint8_t *data, uint32_t bufSize, uint32_t *readLen);
int HLT_RpcTlsReadUnBlock(HLT_Process *peerProcess, int sslId, uint8_t *data, uint32_t bufSize, uint32_t *readLen);
int HLT_RpcGetTlsReadResult(int cmdIndex, uint8_t *data, uint32_t bufSize, uint32_t *readLen);
int HLT_RpcTlsWrite(HLT_Process* peerProcess, int sslId, uint8_t *data, uint32_t bufSize);
int HLT_RpcTlsWriteUnBlock(HLT_Process *peerProcess, int sslId, uint8_t *data, uint32_t bufSize);
int HLT_RpcGetTlsWriteResult(int cmdIndex);
int HLT_RpcTlsRenegotiate(HLT_Process *peerProcess, int sslId);
int HLT_RpcTlsVerifyClientPostHandshake(HLT_Process *peerProcess, int sslId);
int HLT_RpcTlsRegCallback(HLT_Process* peerProcess, TlsCallbackType type);
int HLT_RpcProcessExit(HLT_Process* peerProcess);
int HLT_RpcDataChannelBind(HLT_Process *peerProcess, DataChannelParam *channelParam);
int HLT_RpcDataChannelAccept(HLT_Process* peerProcess, DataChannelParam* channelParam);
int HLT_RpcGetAcceptFd(int acceptId);
int HLT_RpcDataChannelConnect(HLT_Process* peerProcess, DataChannelParam* channelParam);
int HLT_RpcTlsGetStatus(HLT_Process *peerProcess, int sslId);
int HLT_RpcTlsGetAlertFlag(HLT_Process *peerProcess, int sslId);
int HLT_RpcTlsGetAlertLevel(HLT_Process *peerProcess, int sslId);
int HLT_RpcTlsGetAlertDescription(HLT_Process *peerProcess, int sslId);
int HLT_RpcTlsClose(HLT_Process *peerProcess, int sslId);
int HLT_RpcFreeResFormSsl(HLT_Process *peerProcess, int sslId);
int HLT_RpcSctpClose(HLT_Process *peerProcess, int fd);
int HLT_RpcCloseFd(HLT_Process *peerProcess, int fd, int linkType);
int HLT_RpcTlsSetMtu(HLT_Process *peerProcess, int sslId, uint16_t mtu);
int HLT_RpcTlsGetErrorCode(HLT_Process *peerProcess, int sslId);
// TLS connection establishment encapsulation interface
HLT_Tls_Res* HLT_ProcessTlsAccept(HLT_Process *process, TLS_VERSION tlsVersion,
HLT_Ctx_Config *ctxConfig, HLT_Ssl_Config *sslConfig);
HLT_Tls_Res* HLT_ProcessTlsConnect(HLT_Process *process, TLS_VERSION tlsVersion,
HLT_Ctx_Config *ctxConfig, HLT_Ssl_Config *sslConfig);
int HLT_ProcessTlsRead(HLT_Process *process, HLT_Tls_Res* tlsRes, uint8_t *data, uint32_t bufSize, uint32_t *dataLen);
int HLT_ProcessTlsWrite(HLT_Process *process, HLT_Tls_Res* tlsRes, uint8_t *data, uint32_t dataLen);
int HLT_TlsSetMtu(void *ssl, uint16_t mtu);
int HLT_TlsGetErrorCode(void *ssl);
bool IsEnableSctpAuth(void);
#ifdef __cplusplus
}
#endif
#endif // HLT_H
|
2301_79861745/bench_create
|
testcode/framework/tls/include/hlt.h
|
C
|
unknown
| 10,222
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef HLT_TYPE_H
#define HLT_TYPE_H
#include <stdint.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdbool.h>
#include "uio_base.h"
#include "bsl_uio.h"
#include "hitls_type.h"
#include "tls_config.h"
#ifdef __cplusplus
extern "C" {
#endif
#define IP_LEN (32)
#define MAX_CIPHERSUITES_LEN (512)
#define MAX_POINTFORMATS_LEN (512)
#define MAX_GROUPS_LEN (512)
#define MAX_SIGNALGORITHMS_LEN (512)
#define MAX_CERT_LEN (512)
#define PSK_MAX_LEN (256)
#define TICKET_KEY_CB_NAME_LEN (50)
#define MAX_SERVER_NAME_LEN (256)
#define SERVER_NAME_CB_NAME_LEN (50)
#define SERVER_NAME_ARG_NAME_LEN (50)
#define MAX_ALPN_LEN (256)
#define ALPN_CB_NAME_LEN (50)
#define ALPN_DATA_NAME_LEN (50)
#define MAX_NO_RENEGOTIATIONCB_LEN (1024)
#define MAX_PROVIDER_NAME_LEN (256)
#define MAX_ATTR_NAME_LEN (256)
#define MAX_PROVIDER_PATH_LEN (256)
#define MAX_PROVIDER_COUNT (10)
#define KEY_LOG_CB_LEN (1024)
#define DEFAULT_CERT_PATH "../../testcode/testdata/tls/certificate/der/"
#define RSAPSS_SHA256_CA_PATH "rsa_pss_sha256/rsa_pss_root.der:rsa_pss_sha256/rsa_pss_intCa.der"
#define RSAPSS_SHA256_CHAIN_PATH "rsa_pss_sha256/rsa_pss_intCa.der"
#define RSAPSS_SHA256_EE_PATH "rsa_pss_sha256/rsa_pss_dev.der"
#define RSAPSS_SHA256_PRIV_PATH "rsa_pss_sha256/rsa_pss_dev.key.der"
#define RSAPSS_RSAE_CA_PATH "rsa_pss_rsae/rsa_root.der:rsa_pss_rsae/rsa_intCa.der"
#define RSAPSS_RSAE_CHAIN_PATH "rsa_pss_rsae/rsa_intCa.der"
#define RSAPSS_RSAE_EE_PATH "rsa_pss_rsae/rsa_dev.der"
#define RSAPSS_RSAE_PRIV_PATH "rsa_pss_rsae/rsa_dev.key.der"
#define RSA_SHA_CA_PATH "rsa_sha/ca-3072.der:rsa_sha/inter-3072.der"
#define RSA_SHA_CHAIN_PATH "rsa_sha/inter-3072.der"
#define RSA_SHA1_EE_PATH "rsa_sha/end-sha1.der"
#define RSA_SHA1_PRIV_PATH "rsa_sha/end-sha1.key.der"
#define RSA_SHA384_EE_PATH "rsa_sha/end-sha384.der"
#define RSA_SHA384_PRIV_PATH "rsa_sha/end-sha384.key.der"
#define RSA_SHA512_EE_PATH "rsa_sha/end-sha512.der"
#define RSA_SHA512_PRIV_PATH "rsa_sha/end-sha512.key.der"
#define ED25519_SHA512_CA_PATH "ed25519/ed25519.ca.der:ed25519/ed25519.intca.der"
#define ED25519_SHA512_CHAIN_PATH "ed25519/ed25519.intca.der"
#define ED25519_SHA512_EE_PATH "ed25519/ed25519.end.der"
#define ED25519_SHA512_PRIV_PATH "ed25519/ed25519.end.key.der"
#define ECDSA_SHA_CA_PATH "ecdsa/ca-nist521.der:ecdsa/inter-nist521.der"
#define ECDSA_SHA_CHAIN_PATH "ecdsa/inter-nist521.der"
#define ECDSA_SHA256_EE_PATH "ecdsa/end256-sha256.der"
#define ECDSA_SHA256_PRIV_PATH "ecdsa/end256-sha256.key.der"
#define ECDSA_SHA384_EE_PATH "ecdsa/end384-sha384.der"
#define ECDSA_SHA384_PRIV_PATH "ecdsa/end384-sha384.key.der"
#define ECDSA_SHA512_EE_PATH "ecdsa/end521-sha512.der"
#define ECDSA_SHA512_PRIV_PATH "ecdsa/end521-sha512.key.der"
#define ECDSA_SHA1_CA_PATH "ecdsa_sha1/ca-nist521.der:ecdsa_sha1/inter-nist521.der"
#define ECDSA_SHA1_CHAIN_PATH "ecdsa_sha1/inter-nist521.der"
#define ECDSA_SHA1_EE_PATH "ecdsa_sha1/end384-sha1.der"
#define ECDSA_SHA1_PRIV_PATH "ecdsa_sha1/end384-sha1.key.der"
#define RSA_SHA256_CA_PATH "rsa_sha256/ca.der:rsa_sha256/inter.der"
#define RSA_SHA256_CHAIN_PATH "rsa_sha256/inter.der"
#define RSA_SHA256_EE_PATH1 "rsa_sha256/server.der"
#define RSA_SHA256_PRIV_PATH1 "rsa_sha256/server.key.der"
#define RSA_SHA256_EE_PATH2 "rsa_sha256/client.der"
#define RSA_SHA256_PRIV_PATH2 "rsa_sha256/client.key.der"
#define RSA_SHA256_EE_PATH3 "rsa_sha/end-sha256.der"
#define RSA_SHA256_PRIV_PATH3 "rsa_sha/end-sha256.key.der"
#define ECDSA_SHA256_CA_PATH "ecdsa_sha256/ca.der:ecdsa_sha256/inter.der"
#define ECDSA_SHA256_CHAIN_PATH "ecdsa_sha256/inter.der"
#define ECDSA_SHA256_EE_PATH1 "ecdsa_sha256/server.der"
#define ECDSA_SHA256_PRIV_PATH1 "ecdsa_sha256/server.key.der"
#define ECDSA_SHA256_EE_PATH2 "ecdsa_sha256/client.der"
#define ECDSA_SHA256_PRIV_PATH2 "ecdsa_sha256/client.key.der"
#define SM2_VERIFY_PATH "sm2_with_userid/ca.der:sm2_with_userid/inter.der"
#define SM2_CHAIN_PATH "sm2_with_userid/inter.der"
#define SM2_SERVER_ENC_CERT_PATH "sm2_with_userid/enc.der"
#define SM2_SERVER_ENC_KEY_PATH "sm2_with_userid/enc.key.der"
#define SM2_SERVER_SIGN_CERT_PATH "sm2_with_userid/sign.der"
#define SM2_SERVER_SIGN_KEY_PATH "sm2_with_userid/sign.key.der"
#define SM2_CLIENT_ENC_CERT_PATH "sm2_with_userid/enc22.der"
#define SM2_CLIENT_ENC_KEY_PATH "sm2_with_userid/enc22.key.der"
#define SM2_CLIENT_SIGN_CERT_PATH "sm2_with_userid/sign22.der"
#define SM2_CLIENT_SIGN_KEY_PATH "sm2_with_userid/sign22.key.der"
typedef struct ProcessSt HLT_Process;
typedef enum {
HITLS,
HITLS_PROVIDER,
} TLS_TYPE;
typedef enum {
CLIENT,
SERVER
} TLS_ROLE;
typedef enum {
DTLS_ALL,
DTLS1_0,
DTLS1_2,
TLS_ALL,
SSL3_0,
TLS1_0,
TLS1_1,
TLS1_2,
TLS1_3,
TLCP1_1,
DTLCP1_1,
} TLS_VERSION;
typedef enum {
TCP = 0, /**< TCP protocol */
SCTP = 1, /**< SCTP protocol */
UDP = 2, /**< UDP protocol */
NONE_TYPE = 10,
} HILT_TransportType;
typedef enum {
CERT_CALLBACK_DEFAULT,
} CertCallbackType;
typedef enum {
MEM_CALLBACK_DEFAULT,
} MemCallbackType;
typedef enum {
HITLS_CALLBACK_DEFAULT,
} TlsCallbackType;
typedef enum {
COOKIE_CB_DEFAULT, // Normal cookie callback
COOKIE_CB_LEN_0, // The length of the generated cookie is 0
} CookieCallbackType;
typedef struct {
struct sockaddr_in sockAddr;
HILT_TransportType type;
char ip[IP_LEN];
int port;
int bindFd;
bool isBlock;
} DataChannelParam;
typedef struct {
struct sockaddr_in sockAddr;
int connPort;
int srcFd;
int peerFd;
} HLT_FD;
typedef enum {
SERVER_CTX_SET_TRUE = 1,
SERVER_CTX_SET_FALSE = 2,
SERVER_CFG_SET_TRUE = 3,
SERVER_CFG_SET_FALSE = 4,
} HILT_SupportType;
typedef struct {
uint16_t mtu; // Set the MTU in the dtls.
// The maximum version number and minimum version number must be both TLS and DTLS.
// Currently, only DTLS 1.2 is supported
uint32_t minVersion;
uint32_t maxVersion;
char cipherSuites[MAX_CIPHERSUITES_LEN]; // cipher suite
char tls13CipherSuites[MAX_CIPHERSUITES_LEN]; // TLS13 cipher suite
char pointFormats[MAX_POINTFORMATS_LEN]; // ec Point Format
// According to RFC 8446 4.2.7, before TLS 1.3: ec curves; TLS 1.3: group supported by the key exchange.
char groups[MAX_GROUPS_LEN];
char signAlgorithms[MAX_SIGNALGORITHMS_LEN]; // signature algorithm
char serverName[MAX_SERVER_NAME_LEN]; // Client server_name
// Name of the server_name callback function for processing the first handshake on the server
char sniDealCb[SERVER_NAME_CB_NAME_LEN];
// name of the value function related to the server_name registered by the product
char sniArg[SERVER_NAME_ARG_NAME_LEN];
char alpnList[MAX_ALPN_LEN]; // alpn
char alpnUserData[ALPN_CB_NAME_LEN];
char alpnSelectCb[ALPN_DATA_NAME_LEN]; // Application Layer Protocol Select Callback
char keyLogCb[KEY_LOG_CB_LEN];
// Indicates whether renegotiation is supported. The default value is False, indicating that renegotiation is not
// supported
bool isSupportRenegotiation;
bool allowClientRenegotiate; /* allow a renegotiation initiated by the client */
bool allowLegacyRenegotiate; /* whether to abort handshake when server doesn't support SecRenegotiation */
int SupportType; // 1:The server algorithm is preferred
bool needCheckKeyUsage; // Client verification is supported. The default value is False
// Indicates whether to allow the empty certificate list on the client. The default value is False
bool isSupportClientVerify;
bool isSupportNoClientCert; // supports extended master keys. The default value is True
// The handshake will be continued regardless of the verification result. for server and client
bool isSupportVerifyNone;
bool isSupportPostHandshakeAuth; // Indicates whether to support post handshake auth. The default value is false.
bool isSupportExtendMasterSecret; // supports extended master keys. The default value is True
bool isSupportSessionTicket; // Support session ticket
bool isEncryptThenMac; // Encrypt-then-mac is supported
// Users can set the DH parameter to be automatically selected. If the switch is enabled,
// the DH parameter is automatically selected based on the length of the certificate private key
bool isSupportDhAuto;
int32_t setSessionCache; // Setting the Session Storage Mode
uint32_t keyExchMode; // TLS1.3 key exchange mode
void *infoCb; // connection establishment callback function
void *msgCb; // Message callback function
void *msgArg; // Message callback parameter function
void *certCb;
void *certArg;
void *clientHelloCb;
void *clientHelloArg;
// Indicates whether to enable the function of sending handshake information by flight
bool isFlightTransmitEnable;
bool isNoSetCert; // Indicates whether the certificate does not need to be set
int32_t securitylevel; // Security level
int32_t readAhead;
void *caList;
char psk[PSK_MAX_LEN]; // psk password
char ticketKeyCb[TICKET_KEY_CB_NAME_LEN]; // ticket key Callback Function Name
char eeCert[MAX_CERT_LEN];
char privKey[MAX_CERT_LEN];
char signCert[MAX_CERT_LEN];
char signPrivKey[MAX_CERT_LEN];
char password[MAX_CERT_LEN];
char caCert[MAX_CERT_LEN];
char chainCert[MAX_CERT_LEN];
bool isClient;
uint32_t emptyRecordsNum;
char providerPath[MAX_PROVIDER_PATH_LEN];
char providerNames[MAX_PROVIDER_COUNT][MAX_PROVIDER_NAME_LEN];
int32_t providerLibFmts[MAX_PROVIDER_COUNT];
int32_t providerCnt;
char attrName[MAX_ATTR_NAME_LEN];
uint32_t modeSupport; // support features, such as HITLS_MODE_SEND_FALLBACK_SCSV. All mode at hitls_type.h
bool isMiddleBoxCompat; // Indicates whether to enable the middle box compatibility mode.
} HLT_Ctx_Config;
typedef struct {
struct sockaddr_in sockAddr;
int connPort;
int sockFd;
HILT_TransportType connType;
int SupportType; // 3:The server algorithm is preferred
int sctpCtrlCmd;
} HLT_Ssl_Config;
typedef struct {
void *ctx; // hitls config
void *ssl; // hitls ctx
int ctxId;
int sslId;
unsigned long int acceptId;
} HLT_Tls_Res;
typedef enum {
EXP_NONE,
EXP_IO_BUSY,
EXP_RECV_BUF_EMPTY,
} HLT_ExpectIoState;
typedef enum {
POINT_NONE,
POINT_RECV,
POINT_SEND,
} HLT_PointType;
/**
* @brief msg processing callback
*/
typedef void (*HLT_FrameCallBack)(void *msg, void *userData);
typedef struct {
BSL_UIO_Method method; /**< User-defined message sending and receiving control function */
HLT_FrameCallBack frameCallBack; /**< msg processing callback */
void *ctx; /**< TLS context */
int32_t expectReType; /**< Corresponding enumeration REC_Type */
int32_t expectHsType; /**< Corresponding enumerated value HS_MsgType */
HLT_ExpectIoState ioState; /**< customized I/O status */
HLT_PointType pointType; /**< Callback function for recording keys */
void *userData; /**< Customized data, which will be transferred to the msg processing callback */
} HLT_FrameHandle;
#if (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
#define TIME_OUT_SEC 50
#else
#define TIME_OUT_SEC 8
#endif
#ifdef __cplusplus
}
#endif
#endif // HLT_TYPE_H
|
2301_79861745/bench_create
|
testcode/framework/tls/include/hlt_type.h
|
C
|
unknown
| 12,384
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef FRAME_IO_H
#define FRAME_IO_H
#include "bsl_errno.h"
#include "bsl_uio.h"
#ifdef __cplusplus
extern "C" {
#endif
#define MAX_RECORD_LENTH (20 * 1024) // Simulates the bottom-layer sending and receiving processing of the DT framework.
typedef struct FrameUioUserData_ FrameUioUserData;
/**
* @brief SCTP bottom-layer I/O function, which is used to simulate the SCTP message sending interface.
*
* @par Description:
* SCTP bottom-layer I/O function, which is used to simulate the SCTP message sending interface.
*
* @attention
* @return If the operation is successful, success is returned. Otherwise, other values are returned. In this framework,
* a success message is returned without special reasons.
*/
int32_t FRAME_Write(BSL_UIO *uio, const void *buf, uint32_t len, uint32_t *writeLen);
/**
* @brief SCTP bottom-layer I/O function, which is used to simulate the SCTP message receiving interface.
*
* @par Description:
* SCTP bottom-layer I/O function, which is used to simulate the SCTP message receiving interface.
*
* @attention
* @return If the operation is successful, success is returned. Otherwise, other values are returned.
*/
int32_t FRAME_Read(BSL_UIO *uio, void *buf, uint32_t len, uint32_t *readLen);
/**
* @brief SCTP bottom-layer I/O function, which is used to simulate the SCTP control interface.
*
* @par Description:
* SCTP bottom-layer I/O function, which is used to simulate the SCTP control interface.
*
* @attention
* @return If the operation is successful, success is returned. Otherwise, other values are returned.
*/
int32_t FRAME_Ctrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *param);
/**
* @brief Create a UIO user data. The user data must be used when the I/O of the test framework is used. The user data
* stores the data to be sent and received by the I/O.
*
* @return If the operation is successful, the pointer of userdata is returned.
*/
FrameUioUserData *FRAME_IO_CreateUserData(void);
/**
* @brief Releases userdata created by the Frame_IO_CreateUserData function.
*
* @return NA
*/
void FRAME_IO_FreeUserData(FrameUioUserData *userData);
/**
* @brief Frame_TransportSendMsg sends the messages in the sending buffer in the I/O.
*
* @return If the operation is successful, 0 is returned. Otherwise, another value is returned.
*/
int32_t FRAME_TransportSendMsg(BSL_UIO *uio, void *buf, uint32_t len, uint32_t *readLen);
/**
* @brief Frame_TransportRecMsg simulates receiving messages from the I/O.
*
* @return If the operation is successful, 0 is returned. Otherwise, another value is returned.
*/
int32_t FRAME_TransportRecMsg(BSL_UIO *uio, void *buf, uint32_t len);
#ifdef __cplusplus
}
#endif
#endif // FRAME_IO_H
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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;
}
|
2301_79861745/bench_create
|
testcode/framework/tls/msg/src/frame_msg_method.c
|
C
|
unknown
| 14,060
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "securec.h"
#include "bsl_bytes.h"
#include "hitls_error.h"
#include "hitls.h"
#include "tls.h"
#include "hs_ctx.h"
#include "frame_msg.h"
#include "hs_extensions.h"
#define TLS_RECORD_HEADER_LEN 5
#define DTLS_RECORD_HEADER_LEN 13
#define SIZE_OF_UINT24 3
#define SIZE_OF_UINT32 4
#define SIZE_OF_UINT48 6
#define ONE_TIME 1
#define TWO_TIMES 2
// Assemble 8-bit data(1 byte)
static int32_t PackInteger8(const FRAME_Integer *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
uint32_t bufOffset = 0;
// No assembly required
if (field->state == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Repeated assembly
if (field->state == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Not enough to assemble
if (bufLen < (sizeof(uint8_t) * repeats)) {
return HITLS_INTERNAL_EXCEPTION;
}
for (uint32_t i = 0; i < repeats; i++) {
uint8_t data = (uint8_t)(field->data);
buf[bufOffset] = data;
bufOffset += sizeof(uint8_t);
*offset += sizeof(uint8_t);
}
return HITLS_SUCCESS;
}
// Assemble 16-bit data(2 bytes)
static int32_t PackInteger16(const FRAME_Integer *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
uint32_t bufOffset = 0;
// No assembly required
if (field->state == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Repeated assembly
if (field->state == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Not enough to assemble
if (bufLen < (sizeof(uint16_t) * repeats)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (field->state == SET_LEN_TO_ONE_BYTE) {
uint8_t data = (uint8_t)field->data;
buf[0] = data;
*offset += sizeof(uint8_t);
return HITLS_SUCCESS;
}
for (uint32_t i = 0; i < repeats; i++) {
uint16_t data = (uint16_t)(field->data);
BSL_Uint16ToByte(data, &buf[bufOffset]);
bufOffset += sizeof(uint16_t);
*offset += sizeof(uint16_t);
}
return HITLS_SUCCESS;
}
// Assemble 24-bit data(3 bytes)
static int32_t PackInteger24(const FRAME_Integer *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
uint32_t bufOffset = 0;
// No assembly required
if (field->state == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Repeated assembly
if (field->state == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Not enough to assemble
if (bufLen < (SIZE_OF_UINT24 * repeats)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (field->state == SET_LEN_TO_ONE_BYTE) {
uint8_t data = (uint8_t)field->data;
buf[0] = data;
*offset += sizeof(uint8_t);
return HITLS_SUCCESS;
}
for (uint32_t i = 0; i < repeats; i++) {
uint32_t data = (uint32_t)field->data;
BSL_Uint24ToByte(data, &buf[bufOffset]);
bufOffset += SIZE_OF_UINT24;
*offset += SIZE_OF_UINT24;
}
return HITLS_SUCCESS;
}
// Assemble 32-bit data(8 bytes)
static int32_t PackInteger32(const FRAME_Integer *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
uint32_t bufOffset = 0;
// No assembly required
if (field->state == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Repeated assembly
if (field->state == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Not enough to assemble
if (bufLen < (SIZE_OF_UINT32 * repeats)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (field->state == SET_LEN_TO_ONE_BYTE) {
uint8_t data = (uint8_t)field->data;
buf[0] = data;
*offset += sizeof(uint8_t);
return HITLS_SUCCESS;
}
for (uint32_t i = 0; i < repeats; i++) {
uint32_t data = (uint32_t)field->data;
BSL_Uint32ToByte(data, &buf[bufOffset]);
bufOffset += SIZE_OF_UINT32;
*offset += SIZE_OF_UINT32;
}
return HITLS_SUCCESS;
}
// Assemble 48-bit data(8 bytes)
static int32_t PackInteger48(const FRAME_Integer *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
uint32_t bufOffset = 0;
// No assembly required
if (field->state == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Repeated assembly
if (field->state == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Not enough to assemble
if (bufLen < (SIZE_OF_UINT48 * repeats)) {
return HITLS_INTERNAL_EXCEPTION;
}
if (field->state == SET_LEN_TO_ONE_BYTE) {
uint8_t data = (uint8_t)field->data;
buf[0] = data;
*offset += sizeof(uint8_t);
return HITLS_SUCCESS;
}
for (uint32_t i = 0; i < repeats; i++) {
uint64_t data = (uint64_t)field->data;
BSL_Uint48ToByte(data, &buf[bufOffset]);
bufOffset += SIZE_OF_UINT48;
*offset += SIZE_OF_UINT48;
}
return HITLS_SUCCESS;
}
// Assembles the buffer of 8-bit data.(1 byte * n)
static int32_t PackArray8(const FRAME_Array8 *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
// No assembly required
if (field->state == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Total length to be assembled
uint32_t length = field->size;
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
if (memcpy_s(buf, bufLen, field->data, field->size) != EOK) {
return HITLS_MEMCPY_FAIL;
}
*offset += length;
return HITLS_SUCCESS;
}
// Assemble the buffer of 16-bit data.(2 bytes * n)
static int32_t PackArray16(const FRAME_Array16 *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
// No assembly required
if (field->state == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Total length to be assembled
uint32_t length = field->size * sizeof(uint16_t);
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t bufoffset = 0;
for (uint32_t i = 0; i < field->size; i++) {
BSL_Uint16ToByte(field->data[i], &buf[bufoffset]);
bufoffset += sizeof(uint16_t);
}
*offset += length;
return HITLS_SUCCESS;
}
static int32_t PackHsExtArray8(const FRAME_HsExtArray8 *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
// This extension does not need to be assembled.
if (field->exState == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Currently, duplicate extension types can be assembled. Only one extension type can be assembled.
if (field->exState == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Calculate the total length to be assembled
uint32_t length = 0;
length += ((field->exType.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exDataLen.state == MISSING_FIELD) ? 0 : sizeof(uint8_t));
length += ((field->exData.state == MISSING_FIELD) ? 0 : sizeof(uint8_t) * field->exData.size);
length *= repeats;
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
// Assembly extension type. Duplicate extensions exist. Currently, assembly is performed twice consecutively.
uint32_t bufoffset = 0;
uint32_t tmpOffset;
for (uint32_t i = 0; i < repeats; i++) {
PackInteger16(&field->exType, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->exLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger8(&field->exDataLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackArray8(&field->exData, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->exLen.state == INITIAL_FIELD) {
uint32_t len = bufoffset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackHsExtArrayForList(const FRAME_HsExtArray8 *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
// This extension does not need to be assembled.
if (field->exState == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Currently, duplicate extension types can be assembled. Only one extension type can be assembled.
if (field->exState == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Calculate the total length to be assembled
uint32_t length = 0;
length += ((field->exType.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exDataLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exData.state == MISSING_FIELD) ? 0 : sizeof(uint8_t) * field->exData.size);
length *= repeats;
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
// Assembly extension type. Duplicate extensions exist. Currently, assembly is performed twice consecutively.
uint32_t bufoffset = 0;
uint32_t tmpOffset;
for (uint32_t i = 0; i < repeats; i++) {
PackInteger16(&field->exType, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->exLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger16(&field->exDataLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackArray8(&field->exData, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->exLen.state == INITIAL_FIELD) {
uint32_t len = bufoffset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackHsExtArrayForTicket(const FRAME_HsExtArray8 *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
// This extension does not need to be assembled.
if (field->exState == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Currently, duplicate extension types can be assembled. Only one extension type can be assembled.
if (field->exState == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Calculate the total length to be assembled
uint32_t length = 0;
length += ((field->exType.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exDataLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exData.state == MISSING_FIELD) ? 0 : sizeof(uint8_t) * field->exData.size);
length *= repeats;
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
// Assembly extension type. Duplicate extensions exist. Currently, assembly is performed twice consecutively.
uint32_t bufoffset = 0;
uint32_t tmpOffset;
for (uint32_t i = 0; i < repeats; i++) {
PackInteger16(&field->exType, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->exDataLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackArray8(&field->exData, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->exDataLen.state == INITIAL_FIELD) {
uint32_t len = bufoffset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackHsExtArray16(const FRAME_HsExtArray16 *field, uint8_t *buf,
uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
// This extension does not need to be assembled.
if (field->exState == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Currently, duplicate extension types can be assembled. Only one extension type can be assembled.
if (field->exState == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Calculate the total length to be assembled
uint32_t length = 0;
length += ((field->exType.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exDataLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exData.state == MISSING_FIELD) ? 0 : sizeof(uint16_t) * field->exData.size);
length *= repeats;
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
// Assembly extension type. Duplicate extensions exist. Currently, assembly is performed twice consecutively.
uint32_t bufoffset = 0;
uint32_t tmpOffset;
for (uint32_t i = 0; i < repeats; i++) {
PackInteger16(&field->exType, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->exLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger16(&field->exDataLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackArray16(&field->exData, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->exLen.state == INITIAL_FIELD) {
uint32_t len = bufoffset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackPskIdentity(const FRAME_HsArrayPskIdentity *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
// This extension does not need to be assembled.
if (field->state == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Duplicate identity arrays are meaningless. The configuration value can be duplicated.
uint32_t bufoffset = 0;
uint32_t tmpOffset = 0;
for (uint32_t j = 0; j < field->size; j++) {
uint32_t innerRepeat = ONE_TIME;
if (field->data[j].state == MISSING_FIELD) {
continue;
}
if (field->data[j].state == DUPLICATE_FIELD) {
innerRepeat = TWO_TIMES;
}
for (uint32_t k = 0; k < innerRepeat; k++) {
tmpOffset = bufoffset;
PackInteger16(&field->data[j].identityLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackArray8(&field->data[j].identity, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->data[j].identityLen.state == INITIAL_FIELD) {
BSL_Uint16ToByte(field->data[j].identity.size, &buf[tmpOffset]);
}
PackInteger32(&field->data[j].obfuscatedTicketAge, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackPskBinder(const FRAME_HsArrayPskBinder *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
// This extension does not need to be assembled.
if (field->state == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Duplicate identity arrays are meaningless. The configuration value can be duplicated.
uint32_t bufoffset = 0;
uint32_t tmpOffset = 0;
for (uint32_t j = 0; j < field->size; j++) {
uint32_t innerRepeat = ONE_TIME;
if (field->data[j].state == MISSING_FIELD) {
continue;
}
if (field->data[j].state == DUPLICATE_FIELD) {
innerRepeat = TWO_TIMES;
}
for (uint32_t k = 0; k < innerRepeat; k++) {
tmpOffset = bufoffset;
PackInteger8(&field->data[j].binderLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackArray8(&field->data[j].binder, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->data[j].binderLen.state == INITIAL_FIELD) {
buf[tmpOffset] = field->data[j].binder.size;
}
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackHsExtCaList(const FRAME_HsExtCaList *field, uint8_t *buf,
uint32_t bufLen, uint32_t *offset)
{
if (field->exState == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Calculate the total length to be assembled
uint32_t length = 0;
length += ((field->exType.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->listSize.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->list.state == MISSING_FIELD) ? 0 : sizeof(uint8_t) * field->list.size);
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t bufoffset = 0;
uint32_t tmpOffset = 0;
PackInteger16(&field->exType, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->exLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger16(&field->listSize, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackArray8(&field->list, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->exLen.state == INITIAL_FIELD) {
uint32_t len = bufoffset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackHsExtOfferedPsks(const FRAME_HsExtOfferedPsks *field, uint8_t *buf,
uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
// This extension does not need to be assembled.
if (field->exState == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Currently, duplicate extension types can be assembled. Only one extension type can be assembled.
if (field->exState == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Calculate the total length to be assembled
uint32_t length = 0;
length += ((field->exType.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += field->exLen.data;
length *= repeats;
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t bufoffset = 0;
uint32_t tmpOffset = 0;
for (uint32_t i = 0; i < repeats; i++) {
PackInteger16(&field->exType, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->exLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger16(&field->identitySize, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
// identity len INITIAL_FIELD Not supported currently
PackPskIdentity(&field->identities, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger16(&field->binderSize, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
// binder len INITIAL_FIELD Not supported currently
PackPskBinder(&field->binders, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->exLen.state == INITIAL_FIELD) {
uint32_t len = bufoffset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackKeyShareArray(const FRAME_HsArrayKeyShare *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
// This extension does not need to be assembled.
if (field->state == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Duplicate key share arrays are meaningless. The configuration value can be duplicated.
uint32_t bufoffset = 0;
uint32_t tmpOffset = 0;
for (uint32_t j = 0; j < field->size; j++) {
uint32_t innerRepeat = ONE_TIME;
if (field->data[j].state == MISSING_FIELD) {
continue;
}
if (field->data[j].state == DUPLICATE_FIELD) {
innerRepeat = TWO_TIMES;
}
for (uint32_t k = 0; k < innerRepeat; k++) {
PackInteger16(&field->data[j].group, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->data[j].keyExchangeLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackArray8(&field->data[j].keyExchange, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->data[j].keyExchangeLen.state == INITIAL_FIELD) {
BSL_Uint16ToByte(field->data[j].keyExchange.size, &buf[tmpOffset]);
}
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackHsExtKeyShare(const FRAME_HsExtKeyShare *field, uint8_t *buf,
uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
// This extension does not need to be assembled.
if (field->exState == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Currently, duplicate extension types can be assembled. Only one extension type can be assembled.
if (field->exState == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Calculate the total length to be assembled
uint32_t length = 0;
length += ((field->exType.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += field->exLen.data;
length *= repeats;
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t bufoffset = 0;
uint32_t tmpOffset = 0;
for (uint32_t i = 0; i < repeats; i++) {
PackInteger16(&field->exType, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->exLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger16(&field->exKeyShareLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
// exKeyShareLen INITIAL_FIELD Not supported currently
PackKeyShareArray(&field->exKeyShares, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->exLen.state == INITIAL_FIELD) {
uint32_t len = bufoffset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackHsExtSupportedVersion(const FRAME_HsExtArray16 *field, uint8_t *buf,
uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
// This extension does not need to be assembled.
if (field->exState == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Currently, duplicate extension types can be assembled. Only one extension type can be assembled.
if (field->exState == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Calculate the total length to be assembled
uint32_t length = 0;
length += ((field->exType.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exDataLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exData.state == MISSING_FIELD) ? 0 : sizeof(uint16_t) * field->exData.size);
length *= repeats;
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
// Assembly extension type. Duplicate extensions exist. Currently, assembly is performed twice consecutively.
uint32_t bufoffset = 0;
uint32_t tmpOffset;
for (uint32_t i = 0; i < repeats; i++) {
PackInteger16(&field->exType, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->exLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger8(&field->exDataLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackArray16(&field->exData, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->exLen.state == INITIAL_FIELD) {
uint32_t len = bufoffset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackClientHelloMsg(const FRAME_ClientHelloMsg *clientHello, uint8_t *buf,
uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
uint32_t bufOffset;
PackInteger16(&clientHello->version, &buf[offset], bufLen, &offset);
PackArray8(&clientHello->randomValue, &buf[offset], bufLen - offset, &offset);
PackInteger8(&clientHello->sessionIdSize, &buf[offset], bufLen - offset, &offset);
PackArray8(&clientHello->sessionId, &buf[offset], bufLen - offset, &offset);
PackInteger8(&clientHello->cookiedLen, &buf[offset], bufLen - offset, &offset);
PackArray8(&clientHello->cookie, &buf[offset], bufLen - offset, &offset);
PackInteger16(&clientHello->cipherSuitesSize, &buf[offset], bufLen - offset, &offset);
PackArray16(&clientHello->cipherSuites, &buf[offset], bufLen - offset, &offset);
PackInteger8(&clientHello->compressionMethodsLen, &buf[offset], bufLen - offset, &offset);
PackArray8(&clientHello->compressionMethods, &buf[offset], bufLen - offset, &offset);
bufOffset = offset;
if (clientHello->extensionState != MISSING_FIELD) {
PackInteger16(&clientHello->extensionLen, &buf[offset], bufLen - offset, &offset);
if (clientHello->extensionLen.state == SET_LEN_TO_ONE_BYTE) {
goto EXIT;
}
PackHsExtArrayForList(&clientHello->serverName, &buf[offset], bufLen - offset, &offset);
PackHsExtArray16(&clientHello->signatureAlgorithms, &buf[offset], bufLen - offset, &offset);
PackHsExtArray16(&clientHello->supportedGroups, &buf[offset], bufLen - offset, &offset);
PackHsExtArray8(&clientHello->pointFormats, &buf[offset], bufLen - offset, &offset);
PackHsExtSupportedVersion(&clientHello->supportedVersion, &buf[offset], bufLen - offset, &offset);
PackHsExtArrayForList(&clientHello->tls13Cookie, &buf[offset], bufLen - offset, &offset);
PackHsExtArray8(&clientHello->extendedMasterSecret, &buf[offset], bufLen - offset, &offset);
PackHsExtArrayForList(&clientHello->alpn, &buf[offset], bufLen - offset, &offset);
PackHsExtArray8(&clientHello->pskModes, &buf[offset], bufLen - offset, &offset);
PackHsExtKeyShare(&clientHello->keyshares, &buf[offset], bufLen - offset, &offset);
PackHsExtArray8(&clientHello->secRenego, &buf[offset], bufLen - offset, &offset);
PackHsExtArrayForTicket(&clientHello->sessionTicket, &buf[offset], bufLen - offset, &offset);
PackHsExtArray8(&clientHello->encryptThenMac, &buf[offset], bufLen - offset, &offset);
PackHsExtOfferedPsks(&clientHello->psks, &buf[offset], bufLen - offset, &offset);
PackHsExtCaList(&clientHello->caList, &buf[offset], bufLen - offset, &offset);
if (clientHello->extensionLen.state == INITIAL_FIELD) {
uint32_t extensionLen = offset - sizeof(uint16_t) - bufOffset;
BSL_Uint16ToByte(extensionLen, &buf[bufOffset]);
}
}
EXIT:
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackHsExtUint16(const FRAME_HsExtUint16 *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
// This extension does not need to be assembled.
if (field->exState == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Currently, duplicate extension types can be assembled. Only one extension type can be assembled.
if (field->exState == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Calculate the total length to be assembled
uint32_t length = 0;
length += ((field->exType.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += field->exLen.data;
length *= repeats;
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
// Assembly extension type. Duplicate extensions exist. Currently, assembly is performed twice consecutively.
uint32_t bufoffset = 0;
uint32_t tmpOffset;
for (uint32_t i = 0; i < repeats; i++) {
PackInteger16(&field->exType, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->exLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger16(&field->data, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->exLen.state == INITIAL_FIELD) {
uint32_t len = bufoffset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackHsExtServerKeyShare(
const FRAME_HsExtServerKeyShare *field, uint8_t *buf, uint32_t bufLen, uint32_t *offset)
{
uint32_t repeats = ONE_TIME;
// This extension does not need to be assembled.
if (field->exState == MISSING_FIELD) {
return HITLS_SUCCESS;
}
// Currently, duplicate extension types can be assembled. Only one extension type can be assembled.
if (field->exState == DUPLICATE_FIELD) {
repeats = TWO_TIMES;
}
// Calculate the total length to be assembled
uint32_t length = 0;
length += ((field->exType.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += ((field->exLen.state == MISSING_FIELD) ? 0 : sizeof(uint16_t));
length += field->exLen.data;
length *= repeats;
// Not enough to assemble
if (bufLen < length) {
return HITLS_INTERNAL_EXCEPTION;
}
// Assembly extension type. Duplicate extensions exist. Currently, assembly is performed twice consecutively.
uint32_t bufoffset = 0;
uint32_t tmpOffset;
for (uint32_t i = 0; i < repeats; i++) {
PackInteger16(&field->exType, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
tmpOffset = bufoffset;
PackInteger16(&field->exLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger16(&field->data.group, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackInteger16(&field->data.keyExchangeLen, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
PackArray8(&field->data.keyExchange, &buf[bufoffset], bufLen - bufoffset, &bufoffset);
if (field->exLen.state == INITIAL_FIELD) {
uint32_t len = bufoffset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
}
*offset += bufoffset;
return HITLS_SUCCESS;
}
static int32_t PackServerHelloMsg(const FRAME_ServerHelloMsg *serverHello, uint8_t *buf,
uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
uint32_t bufOffset;
PackInteger16(&serverHello->version, &buf[offset], bufLen, &offset);
PackArray8(&serverHello->randomValue, &buf[offset], bufLen - offset, &offset);
PackInteger8(&serverHello->sessionIdSize, &buf[offset], bufLen - offset, &offset);
PackArray8(&serverHello->sessionId, &buf[offset], bufLen - offset, &offset);
PackInteger16(&serverHello->cipherSuite, &buf[offset], bufLen - offset, &offset);
PackInteger8(&serverHello->compressionMethod, &buf[offset], bufLen - offset, &offset);
bufOffset = offset;
PackInteger16(&serverHello->extensionLen, &buf[offset], bufLen - offset, &offset);
PackHsExtArrayForList(&serverHello->serverName, &buf[offset], bufLen - offset, &offset);
PackHsExtArrayForList(&serverHello->tls13Cookie, &buf[offset], bufLen - offset, &offset);
PackHsExtArrayForTicket(&serverHello->sessionTicket, &buf[offset], bufLen - offset, &offset);
PackHsExtUint16(&serverHello->supportedVersion, &buf[offset], bufLen - offset, &offset);
PackHsExtArray8(&serverHello->extendedMasterSecret, &buf[offset], bufLen - offset, &offset);
PackHsExtArrayForList(&serverHello->alpn, &buf[offset], bufLen - offset, &offset);
PackHsExtServerKeyShare(&serverHello->keyShare, &buf[offset], bufLen - offset, &offset);
// hello retry request key share
PackHsExtArray8(&serverHello->secRenego, &buf[offset], bufLen - offset, &offset);
PackHsExtArray8(&serverHello->pointFormats, &buf[offset], bufLen - offset, &offset);
PackHsExtUint16(&serverHello->pskSelectedIdentity, &buf[offset], bufLen - offset, &offset);
// encrypt then mac
PackHsExtArray8(&serverHello->encryptThenMac, &buf[offset], bufLen - offset, &offset);
if (serverHello->extensionLen.state == INITIAL_FIELD) {
uint32_t extensionLen = offset - sizeof(uint16_t) - bufOffset;
BSL_Uint16ToByte(extensionLen, &buf[bufOffset]);
}
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackCertificateMsg(FRAME_Type *type, const FRAME_CertificateMsg *certificate, uint8_t *buf,
uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
uint32_t bufOffset;
if (type->versionType == HITLS_VERSION_TLS13) {
PackInteger8(&certificate->certificateReqCtxSize, &buf[offset], bufLen - offset, &offset);
PackArray8(&certificate->certificateReqCtx, &buf[offset], bufLen - offset, &offset);
}
bufOffset = offset;
PackInteger24(&certificate->certsLen, &buf[offset], bufLen - offset, &offset);
const FrameCertItem *next = certificate->certItem;
while (next != NULL) {
if (next->state == MISSING_FIELD) {
break;
}
PackInteger24(&next->certLen, &buf[offset], bufLen - offset, &offset);
PackArray8(&next->cert, &buf[offset], bufLen - offset, &offset);
if (type->versionType == HITLS_VERSION_TLS13) {
PackInteger16(&next->extensionLen, &buf[offset], bufLen - offset, &offset);
PackArray8(&next->extension, &buf[offset], bufLen - offset, &offset);
}
next = next->next;
}
if (certificate->certsLen.state == INITIAL_FIELD) {
uint32_t certsLen = offset - SIZE_OF_UINT24 - bufOffset;
BSL_Uint24ToByte(certsLen, &buf[bufOffset]);
}
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackServerEcdheMsg(FRAME_Type *type, const FRAME_ServerKeyExchangeMsg *serverKeyExchange, uint8_t *buf,
uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
// Fill in the following values in sequence: curve type, curve ID, pubkeylen, pubkey value, signature algorithm,
// signature len, and signature value.
PackInteger8(&serverKeyExchange->keyEx.ecdh.curveType, &buf[offset], bufLen, &offset);
PackInteger16(&serverKeyExchange->keyEx.ecdh.namedcurve, &buf[offset], bufLen - offset, &offset);
PackInteger8(&serverKeyExchange->keyEx.ecdh.pubKeySize, &buf[offset], bufLen- offset, &offset);
PackArray8(&serverKeyExchange->keyEx.ecdh.pubKey, &buf[offset], bufLen- offset, &offset);
if (((IS_DTLS_VERSION(type->versionType)) && (type->versionType <= HITLS_VERSION_DTLS12)) ||
((!IS_DTLS_VERSION(type->versionType)) && (type->versionType >= HITLS_VERSION_TLS12))) {
// DTLS1.2, TLS1.2, and later versions
PackInteger16(&serverKeyExchange->keyEx.ecdh.signAlgorithm, &buf[offset], bufLen- offset, &offset);
}
PackInteger16(&serverKeyExchange->keyEx.ecdh.signSize, &buf[offset], bufLen- offset, &offset);
PackArray8(&serverKeyExchange->keyEx.ecdh.signData, &buf[offset], bufLen- offset, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackServerDheMsg(FRAME_Type *type, const FRAME_ServerKeyExchangeMsg *serverKeyExchange, uint8_t *buf,
uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
// Fill in the following values in sequence: plen, p value, glen, g value, pubkeylen, pubkey value,
// signature algorithm, signature len, and signature value.
PackInteger16(&serverKeyExchange->keyEx.dh.plen, &buf[offset], bufLen, &offset);
PackArray8(&serverKeyExchange->keyEx.dh.p, &buf[offset], bufLen - offset, &offset);
PackInteger16(&serverKeyExchange->keyEx.dh.glen, &buf[offset], bufLen - offset, &offset);
PackArray8(&serverKeyExchange->keyEx.dh.g, &buf[offset], bufLen - offset, &offset);
PackInteger16(&serverKeyExchange->keyEx.dh.pubKeyLen, &buf[offset], bufLen- offset, &offset);
PackArray8(&serverKeyExchange->keyEx.dh.pubKey, &buf[offset], bufLen- offset, &offset);
if (((IS_DTLS_VERSION(type->versionType)) && (type->versionType <= HITLS_VERSION_DTLS12)) ||
((!IS_DTLS_VERSION(type->versionType)) && (type->versionType >= HITLS_VERSION_TLS12))) {
// DTLS1.2, TLS1.2, and later versions
PackInteger16(&serverKeyExchange->keyEx.dh.signAlgorithm, &buf[offset], bufLen- offset, &offset);
}
PackInteger16(&serverKeyExchange->keyEx.dh.signSize, &buf[offset], bufLen- offset, &offset);
PackArray8(&serverKeyExchange->keyEx.dh.signData, &buf[offset], bufLen- offset, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackServerEccMsg(const FRAME_ServerKeyExchangeMsg *serverKeyExchange, uint8_t *buf,
uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
PackInteger16(&serverKeyExchange->keyEx.ecdh.signSize, &buf[offset], bufLen- offset, &offset);
PackArray8(&serverKeyExchange->keyEx.ecdh.signData, &buf[offset], bufLen- offset, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackServerKeyExchangeMsg(FRAME_Type *type, const FRAME_ServerKeyExchangeMsg *serverKeyExchange,
uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
// Currently, ECDHE and DHE key exchange packets can be assembled.
if (type->keyExType == HITLS_KEY_EXCH_ECDHE) {
return PackServerEcdheMsg(type, serverKeyExchange, buf, bufLen, usedLen);
} else if (type->keyExType == HITLS_KEY_EXCH_DHE) {
return PackServerDheMsg(type, serverKeyExchange, buf, bufLen, usedLen);
} else if (type->keyExType == HITLS_KEY_EXCH_ECC) {
return PackServerEccMsg(serverKeyExchange, buf, bufLen, usedLen);
}
return HITLS_PACK_UNSUPPORT_KX_ALG;
}
static int32_t PackCertificateRequestExt(uint32_t type, const FRAME_CertificateRequestMsg *certificateRequest,
uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
FRAME_Integer exType;
FRAME_Integer size;
switch (type) {
case HS_EX_TYPE_SIGNATURE_ALGORITHMS:
exType.data = HS_EX_TYPE_SIGNATURE_ALGORITHMS;
exType.state = INITIAL_FIELD;
PackInteger16(&exType, &buf[offset], bufLen, &offset);
size.data = certificateRequest->signatureAlgorithmsSize.data + sizeof(uint16_t);
size.state = INITIAL_FIELD;
PackInteger16(&size, &buf[offset], bufLen, &offset);
PackInteger16(&certificateRequest->signatureAlgorithmsSize, &buf[offset], bufLen, &offset);
PackArray16(&certificateRequest->signatureAlgorithms, &buf[offset], bufLen - offset, &offset);
break;
default:
break;
}
*usedLen += offset;
return HITLS_SUCCESS;
}
static int32_t PackCertificateRequestMsg(FRAME_Type *type, const FRAME_CertificateRequestMsg *certificateRequest,
uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
if (certificateRequest->state == MISSING_FIELD){
return HITLS_SUCCESS;
}
if (type->versionType != HITLS_VERSION_TLS13) {
PackInteger8(&certificateRequest->certTypesSize, &buf[offset], bufLen, &offset);
PackArray8(&certificateRequest->certTypes, &buf[offset], bufLen - offset, &offset);
PackInteger16(&certificateRequest->signatureAlgorithmsSize, &buf[offset], bufLen, &offset);
PackArray16(&certificateRequest->signatureAlgorithms, &buf[offset], bufLen - offset, &offset);
PackInteger16(&certificateRequest->distinguishedNamesSize, &buf[offset], bufLen, &offset);
PackArray8(&certificateRequest->distinguishedNames, &buf[offset], bufLen - offset, &offset);
} else {
PackInteger8(&certificateRequest->certificateReqCtxSize, &buf[offset], bufLen, &offset);
PackArray8(&certificateRequest->certificateReqCtx, &buf[offset], bufLen - offset, &offset);
// Packaged extension
uint32_t tmpOffset = offset;
PackInteger16(&certificateRequest->exMsgLen, &buf[offset], bufLen, &offset);
bool ifPackSign = (certificateRequest->signatureAlgorithmsSize.state != MISSING_FIELD);
// Package HS_EX_TYPE_SIGNATURE_ALGORITHMS Extensions
if(ifPackSign) {
PackCertificateRequestExt(HS_EX_TYPE_SIGNATURE_ALGORITHMS, certificateRequest, &buf[offset],
bufLen - offset, &offset);
}
if(certificateRequest->signatureAlgorithmsSize.state == DUPLICATE_FIELD) {
PackCertificateRequestExt(HS_EX_TYPE_SIGNATURE_ALGORITHMS, certificateRequest, &buf[offset],
bufLen - offset, &offset);
}
if (certificateRequest->exMsgLen.state == INITIAL_FIELD) {
uint32_t len = offset - sizeof(uint16_t) - tmpOffset;
BSL_Uint16ToByte(len, &buf[tmpOffset]);
}
}
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackServerHelloDoneMsg(const FRAME_ServerHelloDoneMsg *serverHelloDone, uint8_t *buf,
uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
/* The ServerHelloDone packet is an empty packet. Extra data is assembled here to construct abnormal packets. */
PackArray8(&serverHelloDone->extra, &buf[offset], bufLen, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackClientEcdheMsg(FRAME_Type *type, const FRAME_ClientKeyExchangeMsg *clientKeyExchange, uint8_t *buf,
uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
if (type->versionType == HITLS_VERSION_TLCP_DTLCP11) { /* Three bytes are added to the client key exchange. */
buf[offset] = HITLS_EC_CURVE_TYPE_NAMED_CURVE;
offset += sizeof(uint8_t);
BSL_Uint16ToByte(HITLS_EC_GROUP_SM2, &buf[offset]);
offset += sizeof(uint16_t);
}
PackInteger8(&clientKeyExchange->pubKeySize, &buf[offset], bufLen, &offset);
PackArray8(&clientKeyExchange->pubKey, &buf[offset], bufLen - offset, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackClientDheMsg(const FRAME_ClientKeyExchangeMsg *clientKeyExchange, uint8_t *buf,
uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
PackInteger16(&clientKeyExchange->pubKeySize, &buf[offset], bufLen, &offset);
PackArray8(&clientKeyExchange->pubKey, &buf[offset], bufLen - offset, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackClientKeyExchangeMsg(FRAME_Type *type, const FRAME_ClientKeyExchangeMsg *clientKeyExchange,
uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
// Currently, ECDHE and DHE key exchange packets can be assembled.
if (type->keyExType == HITLS_KEY_EXCH_ECDHE) {
return PackClientEcdheMsg(type, clientKeyExchange, buf, bufLen, usedLen);
} else if (type->keyExType == HITLS_KEY_EXCH_DHE || type->keyExType == HITLS_KEY_EXCH_RSA) {
return PackClientDheMsg(clientKeyExchange, buf, bufLen, usedLen);
}
return HITLS_PACK_UNSUPPORT_KX_ALG;
}
static int32_t PackCertificateVerifyMsg(FRAME_Type *type, const FRAME_CertificateVerifyMsg *certificateVerify,
uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
if (((IS_DTLS_VERSION(type->versionType)) && (type->versionType <= HITLS_VERSION_DTLS12)) ||
((!IS_DTLS_VERSION(type->versionType)) && (type->versionType >= HITLS_VERSION_TLS12))) {
// DTLS1.2, TLS1.2, and later versions
PackInteger16(&certificateVerify->signHashAlg, &buf[offset], bufLen, &offset);
}
PackInteger16(&certificateVerify->signSize, &buf[offset], bufLen - offset, &offset);
PackArray8(&certificateVerify->sign, &buf[offset], bufLen - offset, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackFinishedMsg(const FRAME_FinishedMsg *finished, uint8_t *buf,
uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
PackArray8(&finished->verifyData, &buf[offset], bufLen - offset, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static void PackHsMsgHeader(uint16_t version, const FRAME_HsMsg *hsMsg, uint32_t bodyLen,
uint8_t *buf, uint32_t bufLen, uint32_t *usedLen, BSL_UIO_TransportType transportType)
{
(void)version;
uint32_t offset = 0;
uint32_t bufOffset;
PackInteger8(&hsMsg->type, &buf[offset], bufLen, &offset);
bufOffset = offset;
PackInteger24(&hsMsg->length, &buf[offset], bufLen - offset, &offset);
if (IS_TRANSTYPE_DATAGRAM(transportType)) {
PackInteger16(&hsMsg->sequence, &buf[offset], bufLen - offset, &offset);
PackInteger24(&hsMsg->fragmentOffset, &buf[offset], bufLen - offset, &offset);
if (hsMsg->fragmentLength.state == INITIAL_FIELD) {
BSL_Uint24ToByte(bodyLen, &buf[offset]);
offset += SIZE_OF_UINT24;
} else {
PackInteger24(&hsMsg->fragmentLength, &buf[offset], bufLen - offset, &offset);
}
}
if (hsMsg->length.state == INITIAL_FIELD) {
BSL_Uint24ToByte(bodyLen, &buf[bufOffset]);
}
*usedLen = offset;
}
static int32_t PackNewSessionTicketMsg(FRAME_Type *type, const FRAME_NewSessionTicketMsg *newSessionTicket,
uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
PackInteger32(&newSessionTicket->ticketLifetime, &buf[offset], bufLen - offset, &offset);
if (type->versionType != HITLS_VERSION_TLS13) {
PackInteger16(&newSessionTicket->ticketSize, &buf[offset], bufLen - offset, &offset);
PackArray8(&newSessionTicket->ticket, &buf[offset], bufLen - offset, &offset);
} else {
PackInteger32(&newSessionTicket->ticketAgeAdd, &buf[offset], bufLen - offset, &offset);
PackInteger8(&newSessionTicket->ticketNonceSize, &buf[offset], bufLen - offset, &offset);
PackArray8(&newSessionTicket->ticketNonce, &buf[offset], bufLen - offset, &offset);
PackInteger16(&newSessionTicket->ticketSize, &buf[offset], bufLen - offset, &offset);
PackArray8(&newSessionTicket->ticket, &buf[offset], bufLen - offset, &offset);
PackInteger16(&newSessionTicket->extensionLen, &buf[offset], bufLen - offset, &offset);
}
*usedLen = offset;
if (offset != bufLen) {
return HITLS_PACK_UNSUPPORT_HANDSHAKE_MSG;
}
return HITLS_SUCCESS;
}
static int32_t PackHsMsgBody(FRAME_Type *type, const FRAME_Msg *msg,
uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
int32_t ret;
const FRAME_HsMsg *hsMsg = &(msg->body.hsMsg);
switch (type->handshakeType) {
case CLIENT_HELLO:
ret = PackClientHelloMsg(&(hsMsg->body.clientHello), buf, bufLen, usedLen);
break;
case SERVER_HELLO:
ret = PackServerHelloMsg(&(hsMsg->body.serverHello), buf, bufLen, usedLen);
break;
case CERTIFICATE:
ret = PackCertificateMsg(type, &(hsMsg->body.certificate), buf, bufLen, usedLen);
break;
case SERVER_KEY_EXCHANGE:
ret = PackServerKeyExchangeMsg(type, &(hsMsg->body.serverKeyExchange), buf, bufLen, usedLen);
break;
case CERTIFICATE_REQUEST:
ret = PackCertificateRequestMsg(type, &(hsMsg->body.certificateReq), buf, bufLen, usedLen);
break;
case SERVER_HELLO_DONE:
ret = PackServerHelloDoneMsg(&(hsMsg->body.serverHelloDone), buf, bufLen, usedLen);
break;
case CLIENT_KEY_EXCHANGE:
ret = PackClientKeyExchangeMsg(type, &(hsMsg->body.clientKeyExchange), buf, bufLen, usedLen);
break;
case CERTIFICATE_VERIFY:
ret = PackCertificateVerifyMsg(type, &(hsMsg->body.certificateVerify), buf, bufLen, usedLen);
break;
case FINISHED:
ret = PackFinishedMsg(&(hsMsg->body.finished), buf, bufLen, usedLen);
break;
case NEW_SESSION_TICKET:
ret = PackNewSessionTicketMsg(type, &(hsMsg->body.newSessionTicket), buf, bufLen, usedLen);
break;
default:
ret = HITLS_PACK_UNSUPPORT_HANDSHAKE_MSG;
break;
}
return ret;
}
static int32_t PackHandShakeMsg(FRAME_Type *type, const FRAME_Msg *msg,
uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
const FRAME_HsMsg *hsMsg = &(msg->body.hsMsg);
uint32_t ret;
uint32_t offset;
uint32_t bodyMaxLen;
uint32_t headerLen;
uint32_t bodyLen = 0;
if (IS_TRANSTYPE_DATAGRAM(type->transportType)) { // DTLS
if (bufLen < DTLS_HS_MSG_HEADER_SIZE) {
return HITLS_INTERNAL_EXCEPTION;
}
bodyMaxLen = bufLen - DTLS_HS_MSG_HEADER_SIZE;
offset = DTLS_HS_MSG_HEADER_SIZE;
headerLen = DTLS_HS_MSG_HEADER_SIZE;
} else { // TLS
if (bufLen < HS_MSG_HEADER_SIZE) {
return HITLS_INTERNAL_EXCEPTION;
}
bodyMaxLen = bufLen - HS_MSG_HEADER_SIZE;
offset = HS_MSG_HEADER_SIZE;
headerLen = HS_MSG_HEADER_SIZE;
}
// Assemble the body of the handshake message.
ret = PackHsMsgBody(type, msg, &buf[offset], bodyMaxLen, &bodyLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
// Assemble the handshake packet header.
PackHsMsgHeader(type->versionType, hsMsg, bodyLen, buf, headerLen, &headerLen, type->transportType);
// Splicing body and head
// If some fields are missing in the header, the packet body is filled with an offset forward.
if (headerLen != offset) {
ret = memmove_s(&buf[headerLen], bufLen - headerLen, &buf[offset], bodyLen);
if (ret != EOK) {
return ret;
}
}
*usedLen = headerLen + bodyLen;
return ret;
}
static int32_t PackCcsMsg(const FRAME_Msg *msg, uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
PackInteger8(&msg->body.ccsMsg.ccsType, &buf[offset], bufLen, &offset);
/* Extra data is used to construct abnormal packets. */
PackArray8(&msg->body.ccsMsg.extra, &buf[offset], bufLen - offset, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackAlertMsg(const FRAME_Msg *msg, uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
PackInteger8(&msg->body.alertMsg.alertLevel, &buf[offset], bufLen, &offset);
PackInteger8(&msg->body.alertMsg.alertDescription, &buf[offset], bufLen - offset, &offset);
/* Extra data is used to construct abnormal packets. */
PackArray8(&msg->body.alertMsg.extra, &buf[offset], bufLen - offset, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackAppMsg(const FRAME_Msg *msg, uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
uint32_t offset = 0;
PackArray8(&msg->body.appMsg.appData, &buf[offset], bufLen, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
static int32_t PackRecordHeader(uint16_t version, const FRAME_Msg *msg, uint32_t bodyLen,
uint8_t *buf, uint32_t bufLen, uint32_t *usedLen, BSL_UIO_TransportType transportType)
{
(void)version;
uint32_t offset = 0;
PackInteger8(&msg->recType, &buf[offset], bufLen, &offset);
PackInteger16(&msg->recVersion, &buf[offset], bufLen - offset, &offset);
if (IS_TRANSTYPE_DATAGRAM(transportType)) {
PackInteger16(&msg->epoch, &buf[offset], bufLen - offset, &offset);
PackInteger48(&msg->sequence, &buf[offset], bufLen - offset, &offset);
}
if (msg->length.state == INITIAL_FIELD) {
BSL_Uint16ToByte(bodyLen, &buf[offset]);
offset += sizeof(uint16_t);
} else {
PackInteger16(&msg->length, &buf[offset], bufLen - offset, &offset);
}
*usedLen = offset;
return HITLS_SUCCESS;
}
int32_t FRAME_PackRecordBody(FRAME_Type *frameType, const FRAME_Msg *msg,
uint8_t *buffer, uint32_t bufLen, uint32_t *usedLen)
{
int32_t ret;
// pack Body
switch (frameType->recordType) {
case REC_TYPE_HANDSHAKE:
ret = PackHandShakeMsg(frameType, msg, buffer, bufLen, usedLen);
break;
case REC_TYPE_CHANGE_CIPHER_SPEC:
ret = PackCcsMsg(msg, buffer, bufLen, usedLen);
break;
case REC_TYPE_ALERT:
ret = PackAlertMsg(msg, buffer, bufLen, usedLen);
break;
case REC_TYPE_APP:
ret = PackAppMsg(msg, buffer, bufLen, usedLen);
break;
default:
ret = HITLS_INTERNAL_EXCEPTION;
break;
}
return ret;
}
int32_t FRAME_PackMsg(FRAME_Type *frameType, const FRAME_Msg *msg, uint8_t *buffer, uint32_t bufLen, uint32_t *usedLen)
{
int32_t ret;
uint32_t offset;
uint32_t bodyMaxLen;
uint32_t headerLen;
uint32_t bodyLen = 0;
if (msg == NULL || buffer == NULL || usedLen == NULL) {
return HITLS_INTERNAL_EXCEPTION;
}
if (IS_TRANSTYPE_DATAGRAM(frameType->transportType)) { // DTLS
if (bufLen < DTLS_RECORD_HEADER_LEN) {
return HITLS_INTERNAL_EXCEPTION;
}
bodyMaxLen = bufLen - DTLS_RECORD_HEADER_LEN;
offset = DTLS_RECORD_HEADER_LEN;
headerLen = DTLS_RECORD_HEADER_LEN;
} else { // TLS
if (bufLen < TLS_RECORD_HEADER_LEN) {
return HITLS_INTERNAL_EXCEPTION;
}
bodyMaxLen = bufLen - TLS_RECORD_HEADER_LEN;
offset = TLS_RECORD_HEADER_LEN;
headerLen = TLS_RECORD_HEADER_LEN;
}
// Assemble the message body.
ret = FRAME_PackRecordBody(frameType, msg, &buffer[offset], bodyMaxLen, &bodyLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
// Assemble the packet header.
PackRecordHeader(frameType->versionType, msg, bodyLen, buffer, headerLen, &headerLen, frameType->transportType);
// Splicing body and head
// If some fields are missing in the header, the packet body is filled with an offset forward.
if (headerLen != offset) {
ret = memmove_s(&buffer[headerLen], bufLen - headerLen, &buffer[offset], bodyLen);
if (ret != EOK) {
return ret;
}
}
*usedLen = headerLen + bodyLen;
return ret;
}
int32_t FRAME_GetTls13DisorderHsMsg(HS_MsgType type, uint8_t *buffer, uint32_t bufLen, uint32_t *usedLen)
{
if (bufLen < 5) {
return HITLS_INTERNAL_EXCEPTION;
}
buffer[0] = type;
buffer[1] = 0;
buffer[2] = 0;
buffer[3] = 1;
buffer[4] = 0;
*usedLen = 5;
return HITLS_SUCCESS;
}
|
2301_79861745/bench_create
|
testcode/framework/tls/msg/src/frame_pack_msg.c
|
C
|
unknown
| 55,281
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "securec.h"
#include "bsl_bytes.h"
#include "bsl_sal.h"
#include "hitls_error.h"
#include "hitls_crypt_type.h"
#include "tls.h"
#include "hs_ctx.h"
#include "hs_extensions.h"
#include "frame_tls.h"
#include "frame_msg.h"
#define SIZE_OF_UINT_24 3u
#define SIZE_OF_UINT_48 6u
static int32_t ParseFieldInteger8(const uint8_t *buffer, uint32_t bufLen, FRAME_Integer *field, uint32_t *offset)
{
if (bufLen < sizeof(uint8_t)) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
field->state = INITIAL_FIELD;
field->data = buffer[0];
*offset += sizeof(uint8_t);
return HITLS_SUCCESS;
}
static int32_t ParseFieldInteger16(const uint8_t *buffer, uint32_t bufLen, FRAME_Integer *field, uint32_t *offset)
{
if (bufLen < sizeof(uint16_t)) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
field->state = INITIAL_FIELD;
field->data = BSL_ByteToUint16(buffer);
*offset += sizeof(uint16_t);
return HITLS_SUCCESS;
}
static int32_t ParseFieldInteger24(const uint8_t *buffer, uint32_t bufLen, FRAME_Integer *field, uint32_t *offset)
{
if (bufLen < SIZE_OF_UINT_24) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
field->state = INITIAL_FIELD;
field->data = BSL_ByteToUint24(buffer);
*offset += SIZE_OF_UINT_24;
return HITLS_SUCCESS;
}
static int32_t ParseFieldInteger32(const uint8_t *buffer, uint32_t bufLen, FRAME_Integer *field, uint32_t *offset)
{
if (bufLen < sizeof(uint32_t)) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
field->state = INITIAL_FIELD;
field->data = BSL_ByteToUint32(buffer);
*offset += sizeof(uint32_t);
return HITLS_SUCCESS;
}
static int32_t ParseFieldInteger48(const uint8_t *buffer, uint32_t bufLen, FRAME_Integer *field, uint32_t *offset)
{
if (bufLen < SIZE_OF_UINT_48) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
field->state = INITIAL_FIELD;
field->data = BSL_ByteToUint48(buffer);
*offset += SIZE_OF_UINT_48;
return HITLS_SUCCESS;
}
static int32_t ParseFieldArray8(const uint8_t *buffer, uint32_t bufLen, FRAME_Array8 *field, uint32_t fieldLen,
uint32_t *offset)
{
if (bufLen < fieldLen) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
BSL_SAL_FREE(field->data);
field->data = BSL_SAL_Dump(buffer, fieldLen);
if (field->data == NULL) {
return HITLS_MEMALLOC_FAIL;
}
field->size = fieldLen;
field->state = INITIAL_FIELD;
*offset += fieldLen;
return HITLS_SUCCESS;
}
static int32_t ParseFieldArray16(const uint8_t *buffer, uint32_t bufLen, FRAME_Array16 *field, uint32_t fieldLen,
uint32_t *offset)
{
if ((bufLen < fieldLen) || (fieldLen % sizeof(uint16_t) != 0)) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
field->data = BSL_SAL_Calloc(1u, fieldLen);
if (field->data == NULL) {
return HITLS_MEMALLOC_FAIL;
}
field->size = fieldLen / sizeof(uint16_t);
for (uint32_t i = 0; i < field->size; i++) {
field->data[i] = BSL_ByteToUint16(&buffer[i * sizeof(uint16_t)]);
}
field->state = INITIAL_FIELD;
*offset += fieldLen;
return HITLS_SUCCESS;
}
static int32_t ParseHsExtArray8(const uint8_t *buffer, uint32_t bufLen, FRAME_HsExtArray8 *field, uint32_t *offset)
{
uint32_t exOffset = 0;
field->exState = INITIAL_FIELD;
ParseFieldInteger16(&buffer[0], bufLen, &field->exType, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exLen, &exOffset);
if (field->exLen.data == 0u) {
*offset += exOffset;
return HITLS_SUCCESS;
}
ParseFieldInteger8(&buffer[exOffset], bufLen - exOffset, &field->exDataLen, &exOffset);
ParseFieldArray8(&buffer[exOffset], bufLen - exOffset, &field->exData, field->exDataLen.data, &exOffset);
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseHsExtArrayForList(
const uint8_t *buffer, uint32_t bufLen, FRAME_HsExtArray8 *field, uint32_t *offset)
{
uint32_t exOffset = 0;
field->exState = INITIAL_FIELD;
ParseFieldInteger16(&buffer[0], bufLen, &field->exType, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exLen, &exOffset);
if (field->exLen.data == 0u) {
*offset += exOffset;
return HITLS_SUCCESS;
}
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exDataLen, &exOffset);
ParseFieldArray8(&buffer[exOffset], bufLen - exOffset, &field->exData, field->exDataLen.data, &exOffset);
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseHsSessionTicketExtArray8(
const uint8_t *buffer, uint32_t bufLen, FRAME_HsExtArray8 *field, uint32_t *offset)
{
uint32_t exOffset = 0;
field->exState = INITIAL_FIELD;
ParseFieldInteger16(&buffer[0], bufLen, &field->exType, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exDataLen, &exOffset);
if (field->exDataLen.data == 0u) {
*offset += exOffset;
return HITLS_SUCCESS;
}
ParseFieldArray8(&buffer[exOffset], bufLen - exOffset, &field->exData, field->exDataLen.data, &exOffset);
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseHsExtArray16(const uint8_t *buffer, uint32_t bufLen, FRAME_HsExtArray16 *field, uint32_t *offset)
{
uint32_t exOffset = 0;
field->exState = INITIAL_FIELD;
ParseFieldInteger16(&buffer[0], bufLen - exOffset, &field->exType, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exLen, &exOffset);
if (field->exLen.data == 0u) {
*offset += exOffset;
return HITLS_SUCCESS;
}
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exDataLen, &exOffset);
ParseFieldArray16(&buffer[exOffset], bufLen - exOffset, &field->exData, field->exDataLen.data, &exOffset);
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseHsExtPskIdentity(const uint8_t *buffer, uint32_t bufLen, FRAME_HsArrayPskIdentity *field,
uint32_t fieldLen, uint32_t *offset)
{
uint32_t exOffset = 0;
field->state = INITIAL_FIELD;
uint32_t size = 0;
FRAME_Integer tmpIdentityLen = { 0 };
while (exOffset < fieldLen) {
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &tmpIdentityLen, &exOffset);
exOffset += (tmpIdentityLen.data + sizeof(uint32_t));
if (exOffset <= fieldLen) {
size++;
}
}
if (size == 0) {
return HITLS_SUCCESS;
}
field->data = BSL_SAL_Calloc(size, sizeof(FRAME_HsPskIdentity));
if (field->data == NULL) {
return HITLS_MEMALLOC_FAIL;
}
field->size = size;
exOffset = 0;
for (uint32_t i = 0; i < size; i++) {
field->data[i].state = INITIAL_FIELD;
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->data[i].identityLen, &exOffset);
ParseFieldArray8(&buffer[exOffset], bufLen - exOffset, &field->data[i].identity,
field->data[i].identityLen.data, &exOffset);
ParseFieldInteger32(&buffer[exOffset], bufLen - exOffset, &field->data[i].obfuscatedTicketAge, &exOffset);
}
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseHsExtPskBinder(const uint8_t *buffer, uint32_t bufLen, FRAME_HsArrayPskBinder *field,
uint32_t fieldLen, uint32_t *offset)
{
uint32_t exOffset = 0;
field->state = INITIAL_FIELD;
uint32_t size = 0;
FRAME_Integer tmpBinderLen = { 0 };
while (exOffset < fieldLen) {
ParseFieldInteger8(&buffer[exOffset], bufLen - exOffset, &tmpBinderLen, &exOffset);
exOffset += tmpBinderLen.data;
if (exOffset <= fieldLen) {
size++;
}
}
if (size == 0) {
return HITLS_SUCCESS;
}
field->data = BSL_SAL_Calloc(size, sizeof(FRAME_HsPskBinder));
if (field->data == NULL) {
return HITLS_MEMALLOC_FAIL;
}
field->size = size;
exOffset = 0;
for (uint32_t i = 0; i < size; i++) {
field->data[i].state = INITIAL_FIELD;
ParseFieldInteger8(&buffer[exOffset], bufLen - exOffset, &field->data[i].binderLen, &exOffset);
ParseFieldArray8(&buffer[exOffset], bufLen - exOffset, &field->data[i].binder,
field->data[i].binderLen.data, &exOffset);
}
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseHsExtPsk(const uint8_t *buffer, uint32_t bufLen, FRAME_HsExtOfferedPsks *field, uint32_t *offset)
{
uint32_t exOffset = 0;
field->exState = INITIAL_FIELD;
ParseFieldInteger16(&buffer[0], bufLen - exOffset, &field->exType, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exLen, &exOffset);
if (field->exLen.data == 0u) {
*offset += exOffset;
return HITLS_SUCCESS;
}
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->identitySize, &exOffset);
ParseHsExtPskIdentity(&buffer[exOffset], bufLen - exOffset, &field->identities,
field->identitySize.data, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->binderSize, &exOffset);
ParseHsExtPskBinder(&buffer[exOffset], bufLen - exOffset, &field->binders, field->binderSize.data, &exOffset);
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseHsExtArrayKeyShare(const uint8_t *buffer, uint32_t bufLen, FRAME_HsArrayKeyShare *field,
uint32_t fieldLen, uint32_t *offset)
{
uint32_t exOffset = 0;
field->state = INITIAL_FIELD;
uint32_t size = 0;
FRAME_Integer tmpIdentityLen = { 0 };
while (exOffset < fieldLen) {
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &tmpIdentityLen, &exOffset); // group
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &tmpIdentityLen, &exOffset); // key_exchange len
exOffset += tmpIdentityLen.data;
if (exOffset <= fieldLen) {
size++;
}
}
if (size == 0) {
return HITLS_SUCCESS;
}
field->data = BSL_SAL_Calloc(size, sizeof(FRAME_HsKeyShareEntry));
if (field->data == NULL) {
return HITLS_MEMALLOC_FAIL;
}
field->size = size;
exOffset = 0;
for (uint32_t i = 0; i < size; i++) {
field->data[i].state = INITIAL_FIELD;
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->data[i].group, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->data[i].keyExchangeLen, &exOffset);
ParseFieldArray8(&buffer[exOffset], bufLen - exOffset, &field->data[i].keyExchange,
field->data[i].keyExchangeLen.data, &exOffset);
}
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseHsExtKeyShare(const uint8_t *buffer, uint32_t bufLen, FRAME_HsExtKeyShare *field, uint32_t *offset)
{
uint32_t exOffset = 0;
field->exState = INITIAL_FIELD;
ParseFieldInteger16(&buffer[0], bufLen - exOffset, &field->exType, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exLen, &exOffset);
if (field->exLen.data == 0u) {
*offset += exOffset;
return HITLS_SUCCESS;
}
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exKeyShareLen, &exOffset);
ParseHsExtArrayKeyShare(&buffer[exOffset], bufLen - exOffset, &field->exKeyShares,
field->exKeyShareLen.data, &exOffset);
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseHsSupportedVersion(const uint8_t *buffer, uint32_t bufLen,
FRAME_HsExtArray16 *field, uint32_t *offset)
{
uint32_t exOffset = 0;
field->exState = INITIAL_FIELD;
ParseFieldInteger16(&buffer[0], bufLen - exOffset, &field->exType, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exLen, &exOffset);
if (field->exLen.data == 0u) {
*offset += exOffset;
return HITLS_SUCCESS;
}
ParseFieldInteger8(&buffer[exOffset], bufLen - exOffset, &field->exDataLen, &exOffset);
ParseFieldArray16(&buffer[exOffset], bufLen - exOffset, &field->exData, field->exDataLen.data, &exOffset);
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseClientHelloMsg(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_ClientHelloMsg *clientHello, uint32_t *parseLen)
{
uint32_t offset = 0;
ParseFieldInteger16(&buffer[0], bufLen, &clientHello->version, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &clientHello->randomValue, HS_RANDOM_SIZE, &offset);
ParseFieldInteger8(&buffer[offset], bufLen - offset, &clientHello->sessionIdSize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &clientHello->sessionId,
clientHello->sessionIdSize.data, &offset);
if (IS_TRANSTYPE_DATAGRAM(frameType->transportType)) {
ParseFieldInteger8(&buffer[offset], bufLen - offset, &clientHello->cookiedLen, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &clientHello->cookie, clientHello->cookiedLen.data, &offset);
}
ParseFieldInteger16(&buffer[offset], bufLen - offset, &clientHello->cipherSuitesSize, &offset);
ParseFieldArray16(&buffer[offset], bufLen - offset, &clientHello->cipherSuites,
clientHello->cipherSuitesSize.data, &offset);
ParseFieldInteger8(&buffer[offset], bufLen - offset, &clientHello->compressionMethodsLen, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &clientHello->compressionMethods,
clientHello->compressionMethodsLen.data, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &clientHello->extensionLen, &offset);
clientHello->extensionState = INITIAL_FIELD;
/* Parsing extended fields */
while (offset < bufLen) {
FRAME_Integer tmpField = {0};
uint32_t tmpOffset = offset;
ParseFieldInteger16(&buffer[tmpOffset], bufLen - tmpOffset, &tmpField, &tmpOffset);
switch (tmpField.data) {
case HS_EX_TYPE_POINT_FORMATS:
ParseHsExtArray8(&buffer[offset], bufLen - offset, &clientHello->pointFormats, &offset);
break;
case HS_EX_TYPE_SUPPORTED_GROUPS:
ParseHsExtArray16(&buffer[offset], bufLen - offset, &clientHello->supportedGroups, &offset);
break;
case HS_EX_TYPE_SIGNATURE_ALGORITHMS:
ParseHsExtArray16(&buffer[offset], bufLen - offset, &clientHello->signatureAlgorithms, &offset);
break;
case HS_EX_TYPE_EXTENDED_MASTER_SECRET:
ParseHsExtArray8(&buffer[offset], bufLen - offset, &clientHello->extendedMasterSecret, &offset);
break;
case HS_EX_TYPE_RENEGOTIATION_INFO:
ParseHsExtArray8(&buffer[offset], bufLen - offset, &clientHello->secRenego, &offset);
break;
case HS_EX_TYPE_SESSION_TICKET:
ParseHsSessionTicketExtArray8(&buffer[offset], bufLen - offset, &clientHello->sessionTicket, &offset);
break;
case HS_EX_TYPE_SERVER_NAME:
ParseHsExtArrayForList(&buffer[offset], bufLen - offset, &clientHello->serverName, &offset);
break;
case HS_EX_TYPE_APP_LAYER_PROTOCOLS:
ParseHsExtArrayForList(&buffer[offset], bufLen - offset, &clientHello->alpn, &offset);
break;
case HS_EX_TYPE_KEY_SHARE:
ParseHsExtKeyShare(&buffer[offset], bufLen - offset, &clientHello->keyshares, &offset);
break;
case HS_EX_TYPE_PRE_SHARED_KEY:
ParseHsExtPsk(&buffer[offset], bufLen - offset, &clientHello->psks, &offset);
break;
case HS_EX_TYPE_PSK_KEY_EXCHANGE_MODES:
ParseHsExtArray8(&buffer[offset], bufLen - offset, &clientHello->pskModes, &offset);
break;
case HS_EX_TYPE_SUPPORTED_VERSIONS:
ParseHsSupportedVersion(&buffer[offset], bufLen - offset, &clientHello->supportedVersion, &offset);
break;
case HS_EX_TYPE_COOKIE:
ParseHsExtArrayForList(&buffer[offset], bufLen - offset, &clientHello->tls13Cookie, &offset);
break;
case HS_EX_TYPE_ENCRYPT_THEN_MAC:
ParseHsExtArray8(&buffer[offset], bufLen - offset, &clientHello->encryptThenMac, &offset);
break;
default: /* Unrecognized extension. Skip parsing the extension. */
ParseFieldInteger16(&buffer[tmpOffset], bufLen - tmpOffset, &tmpField, &tmpOffset);
tmpOffset += tmpField.data;
offset = tmpOffset;
break;
}
if (tmpOffset == offset) {
break;
}
}
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanClientHelloMsg(FRAME_ClientHelloMsg *clientHello)
{
BSL_SAL_FREE(clientHello->randomValue.data);
BSL_SAL_FREE(clientHello->sessionId.data);
BSL_SAL_FREE(clientHello->cookie.data);
BSL_SAL_FREE(clientHello->cipherSuites.data);
BSL_SAL_FREE(clientHello->compressionMethods.data);
BSL_SAL_FREE(clientHello->pointFormats.exData.data);
BSL_SAL_FREE(clientHello->supportedGroups.exData.data);
BSL_SAL_FREE(clientHello->signatureAlgorithms.exData.data);
BSL_SAL_FREE(clientHello->extendedMasterSecret.exData.data);
BSL_SAL_FREE(clientHello->secRenego.exData.data);
BSL_SAL_FREE(clientHello->sessionTicket.exData.data);
BSL_SAL_FREE(clientHello->serverName.exData.data);
BSL_SAL_FREE(clientHello->alpn.exData.data);
for (uint32_t i = 0; i < clientHello->keyshares.exKeyShares.size; i++) {
BSL_SAL_FREE(clientHello->keyshares.exKeyShares.data[i].keyExchange.data);
}
for (uint32_t i = 0; i < clientHello->psks.identities.size; i++) {
BSL_SAL_FREE(clientHello->psks.identities.data[i].identity.data);
}
for (uint32_t i = 0; i < clientHello->psks.binders.size; i++) {
BSL_SAL_FREE(clientHello->psks.binders.data[i].binder.data);
}
BSL_SAL_FREE(clientHello->keyshares.exKeyShares.data);
BSL_SAL_FREE(clientHello->psks.binders.data);
BSL_SAL_FREE(clientHello->psks.identities.data);
BSL_SAL_FREE(clientHello->supportedVersion.exData.data);
BSL_SAL_FREE(clientHello->tls13Cookie.exData.data);
BSL_SAL_FREE(clientHello->pskModes.exData.data);
BSL_SAL_FREE(clientHello->caList.list.data);
return;
}
static int32_t ParseHsExtUint16(const uint8_t *buffer, uint32_t bufLen, FRAME_HsExtUint16 *field, uint32_t *offset)
{
uint32_t exOffset = 0;
field->exState = INITIAL_FIELD;
ParseFieldInteger16(&buffer[0], bufLen, &field->exType, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exLen, &exOffset);
if (field->exLen.data == 0u) {
*offset += exOffset;
return HITLS_SUCCESS;
}
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->data, &exOffset);
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseHsExtServerKeyShare(const uint8_t *buffer, uint32_t bufLen,
FRAME_HsExtServerKeyShare *field, uint32_t *offset)
{
uint32_t exOffset = 0;
field->exState = INITIAL_FIELD;
ParseFieldInteger16(&buffer[0], bufLen, &field->exType, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->exLen, &exOffset);
if (field->exLen.data == 0u) {
*offset += exOffset;
return HITLS_SUCCESS;
}
field->data.state = INITIAL_FIELD;
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->data.group, &exOffset);
ParseFieldInteger16(&buffer[exOffset], bufLen - exOffset, &field->data.keyExchangeLen, &exOffset);
ParseFieldArray8(&buffer[exOffset], bufLen - exOffset, &field->data.keyExchange,
field->data.keyExchangeLen.data, &exOffset);
*offset += exOffset;
return HITLS_SUCCESS;
}
static int32_t ParseServerHelloMsg(const uint8_t *buffer, uint32_t bufLen, FRAME_ServerHelloMsg *serverHello,
uint32_t *parseLen)
{
uint32_t offset = 0;
ParseFieldInteger16(&buffer[0], bufLen, &serverHello->version, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &serverHello->randomValue, HS_RANDOM_SIZE, &offset);
ParseFieldInteger8(&buffer[offset], bufLen - offset, &serverHello->sessionIdSize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &serverHello->sessionId,
serverHello->sessionIdSize.data, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &serverHello->cipherSuite, &offset);
ParseFieldInteger8(&buffer[offset], bufLen - offset, &serverHello->compressionMethod, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &serverHello->extensionLen, &offset);
/* Parsing extended fields */
while (offset < bufLen) {
FRAME_Integer tmpField = {0};
uint32_t tmpOffset = offset;
ParseFieldInteger16(&buffer[tmpOffset], bufLen - tmpOffset, &tmpField, &tmpOffset);
switch (tmpField.data) {
case HS_EX_TYPE_POINT_FORMATS:
ParseHsExtArray8(&buffer[offset], bufLen - offset, &serverHello->pointFormats, &offset);
break;
case HS_EX_TYPE_EXTENDED_MASTER_SECRET:
ParseHsExtArray8(&buffer[offset], bufLen - offset, &serverHello->extendedMasterSecret, &offset);
break;
case HS_EX_TYPE_RENEGOTIATION_INFO:
ParseHsExtArray8(&buffer[offset], bufLen - offset, &serverHello->secRenego, &offset);
break;
case HS_EX_TYPE_SESSION_TICKET:
ParseHsSessionTicketExtArray8(&buffer[offset], bufLen - offset, &serverHello->sessionTicket, &offset);
break;
case HS_EX_TYPE_SERVER_NAME:
ParseHsExtArrayForList(&buffer[offset], bufLen - offset, &serverHello->serverName, &offset);
break;
case HS_EX_TYPE_APP_LAYER_PROTOCOLS:
ParseHsExtArrayForList(&buffer[offset], bufLen - offset, &serverHello->alpn, &offset);
break;
case HS_EX_TYPE_SUPPORTED_VERSIONS:
ParseHsExtUint16(&buffer[offset], bufLen - offset, &serverHello->supportedVersion, &offset);
break;
case HS_EX_TYPE_KEY_SHARE:
ParseHsExtServerKeyShare(&buffer[offset], bufLen - offset, &serverHello->keyShare, &offset);
break;
case HS_EX_TYPE_PRE_SHARED_KEY:
ParseHsExtUint16(&buffer[offset], bufLen - offset, &serverHello->pskSelectedIdentity, &offset);
break;
case HS_EX_TYPE_COOKIE:
ParseHsExtArray8(&buffer[offset], bufLen - offset, &serverHello->tls13Cookie, &offset);
break;
case HS_EX_TYPE_ENCRYPT_THEN_MAC:
ParseHsExtArray8(&buffer[offset], bufLen - offset, &serverHello->encryptThenMac, &offset);
break;
default: /* Unrecognized extension, return error */
*parseLen += offset;
return HITLS_PARSE_UNSUPPORTED_EXTENSION;
}
}
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanServerHelloMsg(FRAME_ServerHelloMsg *serverHello)
{
BSL_SAL_FREE(serverHello->randomValue.data);
BSL_SAL_FREE(serverHello->sessionId.data);
BSL_SAL_FREE(serverHello->pointFormats.exData.data);
BSL_SAL_FREE(serverHello->extendedMasterSecret.exData.data);
BSL_SAL_FREE(serverHello->secRenego.exData.data);
BSL_SAL_FREE(serverHello->sessionTicket.exData.data);
BSL_SAL_FREE(serverHello->serverName.exData.data);
BSL_SAL_FREE(serverHello->alpn.exData.data);
BSL_SAL_FREE(serverHello->keyShare.data.keyExchange.data);
BSL_SAL_FREE(serverHello->tls13Cookie.exData.data);
return;
}
static int32_t ParseCertificateMsg(
FRAME_Type *type, const uint8_t *buffer, uint32_t bufLen, FRAME_CertificateMsg *certificate, uint32_t *parseLen)
{
uint32_t offset = 0;
if (type->versionType == HITLS_VERSION_TLS13) {
ParseFieldInteger8(&buffer[0], bufLen, &certificate->certificateReqCtxSize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &certificate->certificateReqCtx,
certificate->certificateReqCtxSize.data, &offset);
}
ParseFieldInteger24(&buffer[offset], bufLen - offset, &certificate->certsLen, &offset);
if (certificate->certsLen.data == 0) {
*parseLen += offset;
return HITLS_SUCCESS;
}
FrameCertItem *certItem = NULL;
while (offset < bufLen) {
uint32_t tmpOffset = offset;
FrameCertItem *item = BSL_SAL_Calloc(1u, sizeof(FrameCertItem));
if (item == NULL) {
return HITLS_MEMALLOC_FAIL;
}
item->state = INITIAL_FIELD;
ParseFieldInteger24(&buffer[offset], bufLen - offset, &item->certLen, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &item->cert, item->certLen.data, &offset);
if (type->versionType == HITLS_VERSION_TLS13) {
ParseFieldInteger16(&buffer[offset], bufLen - offset, &item->extensionLen, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &item->extension, item->extensionLen.data, &offset);
}
if (certificate->certItem == NULL) {
certificate->certItem = item;
} else {
certItem->next = item;
}
certItem = item;
if (tmpOffset == offset) {
break;
}
}
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanCertificateMsg(FRAME_CertificateMsg *certificate)
{
BSL_SAL_FREE(certificate->certificateReqCtx.data);
FrameCertItem *certItem = certificate->certItem;
while (certItem != NULL) {
FrameCertItem *temp = certItem->next;
BSL_SAL_FREE(certItem->cert.data);
BSL_SAL_FREE(certItem->extension.data);
BSL_SAL_FREE(certItem);
certItem = temp;
}
certificate->certItem = NULL;
return;
}
static int32_t ParseServerKxEcdhMsg(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_ServerEcdh *ecdh, uint32_t *parseLen)
{
uint32_t offset = 0;
ParseFieldInteger8(&buffer[0], bufLen, &ecdh->curveType, &offset);
if (ecdh->curveType.data != HITLS_EC_CURVE_TYPE_NAMED_CURVE) {
return HITLS_PARSE_UNSUPPORT_KX_ALG;
}
ParseFieldInteger16(&buffer[offset], bufLen - offset, &ecdh->namedcurve, &offset);
ParseFieldInteger8(&buffer[offset], bufLen - offset, &ecdh->pubKeySize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &ecdh->pubKey, ecdh->pubKeySize.data, &offset);
if (((!IS_DTLS_VERSION(frameType->versionType)) && (frameType->versionType >= HITLS_VERSION_TLS12)) ||
((IS_DTLS_VERSION(frameType->versionType)) && (frameType->versionType <= HITLS_VERSION_DTLS12))) {
ParseFieldInteger16(&buffer[offset], bufLen - offset, &ecdh->signAlgorithm, &offset);
}
ParseFieldInteger16(&buffer[offset], bufLen - offset, &ecdh->signSize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &ecdh->signData, ecdh->signSize.data, &offset);
*parseLen += offset;
return HITLS_SUCCESS;
}
static int32_t ParseServerKxDhMsg(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_ServerDh *dh, uint32_t *parseLen)
{
uint32_t offset = 0;
ParseFieldInteger16(&buffer[0], bufLen, &dh->plen, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &dh->p, dh->plen.data, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &dh->glen, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &dh->g, dh->glen.data, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &dh->pubKeyLen, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &dh->pubKey, dh->pubKeyLen.data, &offset);
if (((!IS_DTLS_VERSION(frameType->versionType)) && (frameType->versionType >= HITLS_VERSION_TLS12)) ||
((IS_DTLS_VERSION(frameType->versionType)) && (frameType->versionType <= HITLS_VERSION_DTLS12))) {
ParseFieldInteger16(&buffer[offset], bufLen - offset, &dh->signAlgorithm, &offset);
}
ParseFieldInteger16(&buffer[offset], bufLen - offset, &dh->signSize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &dh->signData, dh->signSize.data, &offset);
*parseLen += offset;
return HITLS_SUCCESS;
}
static int32_t ParseServerKxEccMsg(const uint8_t *buffer, uint32_t bufLen,
FRAME_ServerEcdh *ecdh, uint32_t *parseLen)
{
uint32_t offset = 0;
ParseFieldInteger16(&buffer[offset], bufLen - offset, &ecdh->signSize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &ecdh->signData, ecdh->signSize.data, &offset);
*parseLen += offset;
return HITLS_SUCCESS;
}
static int32_t ParseServerKxMsg(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_ServerKeyExchangeMsg *serverKx, uint32_t *parseLen)
{
switch (frameType->keyExType) {
case HITLS_KEY_EXCH_ECDHE:
return ParseServerKxEcdhMsg(frameType, buffer, bufLen, &serverKx->keyEx.ecdh, parseLen);
case HITLS_KEY_EXCH_DHE:
return ParseServerKxDhMsg(frameType, buffer, bufLen, &serverKx->keyEx.dh, parseLen);
case HITLS_KEY_EXCH_ECC:
return ParseServerKxEccMsg(buffer, bufLen, &serverKx->keyEx.ecdh, parseLen);
default:
break;
}
return HITLS_PARSE_UNSUPPORT_KX_ALG;
}
static void CleanServerKxMsg(HITLS_KeyExchAlgo kexType, FRAME_ServerKeyExchangeMsg *serverKx)
{
FRAME_ServerEcdh *ecdh = &serverKx->keyEx.ecdh;
FRAME_ServerDh *dh = &serverKx->keyEx.dh;
switch (kexType) {
case HITLS_KEY_EXCH_ECDHE:
BSL_SAL_FREE(ecdh->pubKey.data);
BSL_SAL_FREE(ecdh->signData.data);
break;
case HITLS_KEY_EXCH_DHE:
BSL_SAL_FREE(dh->p.data);
BSL_SAL_FREE(dh->g.data);
BSL_SAL_FREE(dh->pubKey.data);
BSL_SAL_FREE(dh->signData.data);
break;
default:
break;
}
return;
}
static int32_t ParseCertReqMsgExBody(uint16_t extMsgType, const uint8_t *buffer, uint32_t bufLen,
FRAME_CertificateRequestMsg *certReq, uint32_t *parseLen)
{
uint32_t offset = 0;
switch (extMsgType) {
case HS_EX_TYPE_SIGNATURE_ALGORITHMS:
ParseFieldInteger16(&buffer[offset], bufLen - offset, &certReq->signatureAlgorithmsSize, &offset);
ParseFieldArray16(&buffer[offset], bufLen - offset, &certReq->signatureAlgorithms,
certReq->signatureAlgorithmsSize.data, &offset);
break;
default:
break;
}
*parseLen += offset;
return HITLS_SUCCESS;
}
static int32_t ParseCertReqMsg(
FRAME_Type *type, const uint8_t *buffer, uint32_t bufLen, FRAME_CertificateRequestMsg *certReq, uint32_t *parseLen)
{
uint32_t offset = 0;
certReq->state = INITIAL_FIELD;
if (type->versionType != HITLS_VERSION_TLS13) {
ParseFieldInteger8(&buffer[0], bufLen, &certReq->certTypesSize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &certReq->certTypes, certReq->certTypesSize.data, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &certReq->signatureAlgorithmsSize, &offset);
ParseFieldArray16(&buffer[offset], bufLen - offset, &certReq->signatureAlgorithms,
certReq->signatureAlgorithmsSize.data, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &certReq->distinguishedNamesSize, &offset);
if (certReq->distinguishedNamesSize.data != 0u) {
ParseFieldArray8(&buffer[offset], bufLen - offset, &certReq->distinguishedNames,
certReq->distinguishedNamesSize.data, &offset);
}
} else {
ParseFieldInteger8(&buffer[0], bufLen, &certReq->certificateReqCtxSize, &offset);
ParseFieldArray8(&buffer[offset],
bufLen - offset,
&certReq->certificateReqCtx,
certReq->certificateReqCtxSize.data,
&offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &certReq->exMsgLen, &offset);
while (offset < bufLen) {
uint32_t tmpOffset = offset;
FRAME_Integer extMsgType ;
FRAME_Integer extMsgLen ;
ParseFieldInteger16(&buffer[offset], bufLen - offset, &extMsgType, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &extMsgLen, &offset);
ParseCertReqMsgExBody(extMsgType.data, &buffer[offset], bufLen - offset, certReq, &offset);
if (offset == tmpOffset) {
break;
}
}
}
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanCertReqMsg(FRAME_CertificateRequestMsg *certReq)
{
BSL_SAL_FREE(certReq->certTypes.data);
BSL_SAL_FREE(certReq->signatureAlgorithms.data);
BSL_SAL_FREE(certReq->distinguishedNames.data);
BSL_SAL_FREE(certReq->certificateReqCtx.data);
return;
}
static int32_t ParseServerHelloDoneMsg(uint32_t bufLen)
{
if (bufLen != 0) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
return HITLS_SUCCESS;
}
static void CleanServerHelloDoneMsg(FRAME_ServerHelloDoneMsg *serverHelloDone)
{
/* The ServerHelloDone packet is an empty packet. If there is any constructed data, release it. */
BSL_SAL_FREE(serverHelloDone->extra.data);
return;
}
static int32_t ParseClientKxMsg(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_ClientKeyExchangeMsg *clientKx, uint32_t *parseLen)
{
uint32_t offset = 0;
switch (frameType->keyExType) {
case HITLS_KEY_EXCH_ECDHE:
/* Compatible with OpenSSL. Three bytes are added to the client key exchange. */
#ifdef HITLS_TLS_PROTO_TLCP11
if (frameType->versionType == HITLS_VERSION_TLCP_DTLCP11) {
// Curve type + Curve ID + Public key length
uint8_t minLen = sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint8_t);
if (bufLen < minLen) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
// Ignore the first three bytes.
offset += sizeof(uint8_t) + sizeof(uint16_t);
}
#endif
ParseFieldInteger8(&buffer[offset], bufLen - offset, &clientKx->pubKeySize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &clientKx->pubKey, clientKx->pubKeySize.data, &offset);
break;
case HITLS_KEY_EXCH_DHE:
case HITLS_KEY_EXCH_RSA:
ParseFieldInteger16(&buffer[offset], bufLen - offset, &clientKx->pubKeySize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &clientKx->pubKey, clientKx->pubKeySize.data, &offset);
break;
default:
return HITLS_PARSE_UNSUPPORT_KX_ALG;
}
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanClientKxMsg(FRAME_ClientKeyExchangeMsg *clientKx)
{
BSL_SAL_FREE(clientKx->pubKey.data);
return;
}
static int32_t ParseCertVerifyMsg(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_CertificateVerifyMsg *certVerify, uint32_t *parseLen)
{
uint32_t offset = 0;
if (((!IS_DTLS_VERSION(frameType->versionType)) && (frameType->versionType >= HITLS_VERSION_TLS12)) ||
((IS_DTLS_VERSION(frameType->versionType)) && (frameType->versionType <= HITLS_VERSION_DTLS12))) {
ParseFieldInteger16(&buffer[0], bufLen, &certVerify->signHashAlg, &offset);
}
ParseFieldInteger16(&buffer[offset], bufLen - offset, &certVerify->signSize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &certVerify->sign, certVerify->signSize.data, &offset);
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanCertVerifyMsg(FRAME_CertificateVerifyMsg *certVerify)
{
BSL_SAL_FREE(certVerify->sign.data);
return;
}
static int32_t ParseFinishedMsg(const uint8_t *buffer, uint32_t bufLen, FRAME_FinishedMsg *finished, uint32_t *parseLen)
{
uint32_t offset = 0;
ParseFieldArray8(buffer, bufLen, &finished->verifyData, bufLen, &offset);
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanFinishedMsg(FRAME_FinishedMsg *finished)
{
BSL_SAL_FREE(finished->verifyData.data);
return;
}
static int32_t ParseNewSessionTicket(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_NewSessionTicketMsg *sessionTicket, uint32_t *parseLen)
{
uint32_t offset = 0;
ParseFieldInteger32(&buffer[0], bufLen, &sessionTicket->ticketLifetime, &offset);
if (frameType->versionType != HITLS_VERSION_TLS13) {
ParseFieldInteger16(&buffer[offset], bufLen - offset, &sessionTicket->ticketSize, &offset);
ParseFieldArray8(
&buffer[offset], bufLen - offset, &sessionTicket->ticket, sessionTicket->ticketSize.data, &offset);
} else {
ParseFieldInteger32(&buffer[offset], bufLen - offset, &sessionTicket->ticketAgeAdd, &offset);
ParseFieldInteger8(&buffer[offset], bufLen - offset, &sessionTicket->ticketNonceSize, &offset);
ParseFieldArray8(&buffer[offset], bufLen - offset, &sessionTicket->ticketNonce,
sessionTicket->ticketNonceSize.data, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &sessionTicket->ticketSize, &offset);
ParseFieldArray8(
&buffer[offset], bufLen - offset, &sessionTicket->ticket, sessionTicket->ticketSize.data, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &sessionTicket->extensionLen, &offset);
while (offset < bufLen) {
FRAME_Integer tmpField = {0};
uint32_t tmpOffset = offset;
ParseFieldInteger16(&buffer[tmpOffset], bufLen - tmpOffset, &tmpField, &tmpOffset);
switch (tmpField.data) {
default:
/* The extensions in the tls 1.3 new session ticket cannot be parsed currently. Skip this step. */
ParseFieldInteger16(&buffer[tmpOffset], bufLen - tmpOffset, &tmpField, &tmpOffset);
tmpOffset += tmpField.data;
offset = tmpOffset;
break;
}
}
}
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanNewSessionTicket(FRAME_NewSessionTicketMsg *sessionTicket)
{
BSL_SAL_FREE(sessionTicket->ticket.data);
BSL_SAL_FREE(sessionTicket->ticketNonce.data);
return;
}
static int32_t ParseHsMsg(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_HsMsg *hsMsg, uint32_t *parseLen)
{
uint32_t offset = 0;
ParseFieldInteger8(&buffer[0], bufLen, &hsMsg->type, &offset);
ParseFieldInteger24(&buffer[offset], bufLen - offset, &hsMsg->length, &offset);
if (IS_TRANSTYPE_DATAGRAM(frameType->transportType)) {
ParseFieldInteger16(&buffer[offset], bufLen - offset, &hsMsg->sequence, &offset);
ParseFieldInteger24(&buffer[offset], bufLen - offset, &hsMsg->fragmentOffset, &offset);
ParseFieldInteger24(&buffer[offset], bufLen - offset, &hsMsg->fragmentLength, &offset);
}
*parseLen += offset;
/* To ensure that the memory can be normally released after users modify hsMsg->type.data,
* assign a value to frameType. */
frameType->handshakeType = hsMsg->type.data;
switch (hsMsg->type.data) {
case CLIENT_HELLO:
return ParseClientHelloMsg(frameType, &buffer[offset], bufLen - offset, &hsMsg->body.clientHello, parseLen);
case SERVER_HELLO:
return ParseServerHelloMsg(&buffer[offset], bufLen - offset, &hsMsg->body.serverHello, parseLen);
case CERTIFICATE:
return ParseCertificateMsg(frameType, &buffer[offset], bufLen - offset, &hsMsg->body.certificate, parseLen);
case SERVER_KEY_EXCHANGE:
return ParseServerKxMsg(frameType, &buffer[offset], bufLen - offset, &hsMsg->body.serverKeyExchange,
parseLen);
case CERTIFICATE_REQUEST:
return ParseCertReqMsg(frameType, &buffer[offset], bufLen - offset, &hsMsg->body.certificateReq, parseLen);
case CLIENT_KEY_EXCHANGE:
return ParseClientKxMsg(frameType, &buffer[offset], bufLen - offset, &hsMsg->body.clientKeyExchange,
parseLen);
case CERTIFICATE_VERIFY:
return ParseCertVerifyMsg(frameType, &buffer[offset], bufLen - offset, &hsMsg->body.certificateVerify,
parseLen);
case FINISHED:
return ParseFinishedMsg(&buffer[offset], bufLen - offset, &hsMsg->body.finished, parseLen);
case SERVER_HELLO_DONE:
return ParseServerHelloDoneMsg(bufLen - offset);
case NEW_SESSION_TICKET:
return ParseNewSessionTicket(frameType, &buffer[offset], bufLen - offset, &hsMsg->body.newSessionTicket,
parseLen);
default:
break;
}
return HITLS_PARSE_UNSUPPORT_HANDSHAKE_MSG;
}
static int32_t ParseCcsMsg(const uint8_t *buffer, uint32_t bufLen, FRAME_CcsMsg *ccsMsg, uint32_t *parseLen)
{
/* The length of the CCS message is 1 byte. */
if (bufLen != 1u) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
uint32_t offset = 0;
ParseFieldInteger8(buffer, bufLen, &ccsMsg->ccsType, &offset);
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanCcsMsg(FRAME_CcsMsg *ccsMsg)
{
/* This field is used to construct abnormal packets. Data is not written during parsing. However,
* users may apply for memory. Therefore, this field needs to be released. */
BSL_SAL_FREE(ccsMsg->extra.data);
return;
}
static int32_t ParseAlertMsg(const uint8_t *buffer, uint32_t bufLen, FRAME_AlertMsg *alertMsg, uint32_t *parseLen)
{
/* The length of the alert message is 2 bytes. */
if (bufLen != 2u) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
uint32_t offset = 0;
ParseFieldInteger8(&buffer[0], bufLen, &alertMsg->alertLevel, &offset);
ParseFieldInteger8(&buffer[offset], bufLen - offset, &alertMsg->alertDescription, &offset);
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanAlertMsg(FRAME_AlertMsg *alertMsg)
{
/* This field is used to construct abnormal packets. Data is not written during parsing.
* However, users may apply for memory. Therefore, this field needs to be released. */
BSL_SAL_FREE(alertMsg->extra.data);
return;
}
static int32_t ParseAppMsg(const uint8_t *buffer, uint32_t bufLen, FRAME_AppMsg *appMsg, uint32_t *parseLen)
{
if (bufLen == 0u) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
uint32_t offset = 0;
ParseFieldArray8(buffer, bufLen, &appMsg->appData, bufLen, &offset);
*parseLen += offset;
return HITLS_SUCCESS;
}
static void CleanAppMsg(FRAME_AppMsg *appMsg)
{
BSL_SAL_FREE(appMsg->appData.data);
return;
}
int32_t FRAME_ParseMsgHeader(
FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen, FRAME_Msg *msg, uint32_t *parseLen)
{
if ((frameType == NULL) || (buffer == NULL) || (msg == NULL) || (parseLen == NULL)) {
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t offset = 0;
ParseFieldInteger8(&buffer[0], bufLen, &msg->recType, &offset);
ParseFieldInteger16(&buffer[offset], bufLen - offset, &msg->recVersion, &offset);
if (IS_TRANSTYPE_DATAGRAM(frameType->transportType)) {
ParseFieldInteger16(&buffer[offset], bufLen - offset, &msg->epoch, &offset);
ParseFieldInteger48(&buffer[offset], bufLen - offset, &msg->sequence, &offset);
}
ParseFieldInteger16(&buffer[offset], bufLen - offset, &msg->length, &offset);
if ((msg->length.data + offset) > bufLen) {
return HITLS_PARSE_INVALID_MSG_LEN;
}
*parseLen = offset;
return HITLS_SUCCESS;
}
int32_t FRAME_ParseTLSRecordHeader(const uint8_t *buffer, uint32_t bufferLen, FRAME_Msg *msg, uint32_t *parsedLen)
{
if ((buffer == NULL) || (msg == NULL) || (parsedLen == NULL)) {
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t offset = 0;
// Parse the 0th byte of the buffer. The parsing result is stored in msg->recType, offset = 1.
ParseFieldInteger8(buffer, bufferLen, &msg->recType, &offset);
// Parse the first and second bytes of the buffer. The parsing result is stored in msg->recVersion, offset = 3.
ParseFieldInteger16(buffer + offset, bufferLen - offset, &msg->recVersion, &offset);
// Parse the third to fourth bytes of the buffer. The parsing result is stored in msg->length, and offset = 5.
ParseFieldInteger16(buffer + offset, bufferLen - offset, &msg->length, &offset);
// msg->length.data indicates the length of the parsed record body.
// In this case, the value of offset is the header length.
if ((msg->length.data + offset) > bufferLen) {
// The length of the entire message cannot be greater than bufLen.
return HITLS_PARSE_INVALID_MSG_LEN;
}
*parsedLen = offset;
return HITLS_SUCCESS;
}
// Parse the body of a non-handshake record.
int32_t FRAME_ParseTLSNonHsRecordBody(const uint8_t *buffer, uint32_t bufferLen, FRAME_Msg *msg, uint32_t *parseLen)
{
if ((buffer == NULL) || (msg == NULL) || (parseLen == NULL)) {
return HITLS_INTERNAL_EXCEPTION;
}
switch (msg->recType.data) {
case REC_TYPE_CHANGE_CIPHER_SPEC:
return ParseCcsMsg(buffer, bufferLen, &msg->body.ccsMsg, parseLen);
case REC_TYPE_ALERT:
return ParseAlertMsg(buffer, bufferLen, &msg->body.alertMsg, parseLen);
case REC_TYPE_APP:
return ParseAppMsg(buffer, bufferLen, &msg->body.appMsg, parseLen);
default:
break;
}
return HITLS_INTERNAL_EXCEPTION;
}
int32_t FRAME_ParseMsgBody(
FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen, FRAME_Msg *msg, uint32_t *parseLen)
{
if ((frameType == NULL) || (buffer == NULL) || (msg == NULL) || (parseLen == NULL)) {
return HITLS_INTERNAL_EXCEPTION;
}
/* To ensure that the memory can be normally released after users modify msg->recType.data,
* assign a value to frameType. */
frameType->recordType = msg->recType.data;
switch (msg->recType.data) {
case REC_TYPE_HANDSHAKE:
return ParseHsMsg(frameType, buffer, bufLen, &msg->body.hsMsg, parseLen);
case REC_TYPE_CHANGE_CIPHER_SPEC:
return ParseCcsMsg(buffer, bufLen, &msg->body.ccsMsg, parseLen);
case REC_TYPE_ALERT:
return ParseAlertMsg(buffer, bufLen, &msg->body.alertMsg, parseLen);
case REC_TYPE_APP:
return ParseAppMsg(buffer, bufLen, &msg->body.appMsg, parseLen);
default:
break;
}
return HITLS_INTERNAL_EXCEPTION;
}
int32_t FRAME_ParseMsg(FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufLen,
FRAME_Msg *msg, uint32_t *parseLen)
{
int32_t ret;
ret = FRAME_ParseMsgHeader(frameType, buffer, bufLen, msg, parseLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
return FRAME_ParseMsgBody(frameType, &buffer[*parseLen], msg->length.data, msg, parseLen);
}
int32_t FRAME_ParseTLSNonHsRecord(const uint8_t *buffer, uint32_t bufLen, FRAME_Msg *msg, uint32_t *parseLen)
{
int32_t ret;
uint32_t headerLen;
ret = FRAME_ParseTLSRecordHeader(buffer, bufLen, msg, parseLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
headerLen = *parseLen;
return FRAME_ParseTLSNonHsRecordBody(buffer + headerLen, msg->length.data, msg, parseLen);
}
int32_t FRAME_ParseHsRecord(
FRAME_Type *frameType, const uint8_t *buffer, uint32_t bufferLen, FRAME_Msg *msg, uint32_t *parseLen)
{
int32_t ret;
uint32_t headerLen;
ret = FRAME_ParseMsgHeader(frameType, buffer, bufferLen, msg, parseLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
headerLen = *parseLen;
/* To ensure that the memory can be normally released after users modify msg->recType.data,
* assign a value to frameType. */
frameType->recordType = msg->recType.data;
if (msg->recType.data == REC_TYPE_HANDSHAKE) {
return ParseHsMsg(frameType, buffer + headerLen, msg->length.data, &msg->body.hsMsg, parseLen);
}
return HITLS_PARSE_UNSUPPORT_HANDSHAKE_MSG;
}
static void CleanParsedHsMsg(HS_MsgType handshakeType, HITLS_KeyExchAlgo kexType, FRAME_HsMsg *hsMsg)
{
switch (handshakeType) {
case CLIENT_HELLO:
return CleanClientHelloMsg(&hsMsg->body.clientHello);
case SERVER_HELLO:
return CleanServerHelloMsg(&hsMsg->body.serverHello);
case CERTIFICATE:
return CleanCertificateMsg(&hsMsg->body.certificate);
case SERVER_KEY_EXCHANGE:
return CleanServerKxMsg(kexType, &hsMsg->body.serverKeyExchange);
case CERTIFICATE_REQUEST:
return CleanCertReqMsg(&hsMsg->body.certificateReq);
case CLIENT_KEY_EXCHANGE:
return CleanClientKxMsg(&hsMsg->body.clientKeyExchange);
case CERTIFICATE_VERIFY:
return CleanCertVerifyMsg(&hsMsg->body.certificateVerify);
case FINISHED:
return CleanFinishedMsg(&hsMsg->body.finished);
case SERVER_HELLO_DONE:
return CleanServerHelloDoneMsg(&hsMsg->body.serverHelloDone);
case NEW_SESSION_TICKET:
return CleanNewSessionTicket(&hsMsg->body.newSessionTicket);
default:
break;
}
return;
}
static void CleanHsMsg(FRAME_Type *frameType, FRAME_HsMsg *hsMsg)
{
return CleanParsedHsMsg(frameType->handshakeType, frameType->keyExType, hsMsg);
}
void FRAME_CleanMsg(FRAME_Type *frameType, FRAME_Msg *msg)
{
if ((frameType == NULL) || (msg == NULL)) {
return;
}
switch (frameType->recordType) {
case REC_TYPE_HANDSHAKE:
CleanHsMsg(frameType, &msg->body.hsMsg);
break;
case REC_TYPE_CHANGE_CIPHER_SPEC:
CleanCcsMsg(&msg->body.ccsMsg);
break;
case REC_TYPE_ALERT:
CleanAlertMsg(&msg->body.alertMsg);
break;
case REC_TYPE_APP:
CleanAppMsg(&msg->body.appMsg);
break;
default:
break;
}
memset_s(msg, sizeof(FRAME_Msg), 0, sizeof(FRAME_Msg));
return;
}
void FRAME_CleanNonHsRecord(REC_Type recType, FRAME_Msg *msg)
{
if (msg == NULL) {
return;
}
switch (recType) {
case REC_TYPE_CHANGE_CIPHER_SPEC:
CleanCcsMsg(&msg->body.ccsMsg);
break;
case REC_TYPE_ALERT:
CleanAlertMsg(&msg->body.alertMsg);
break;
case REC_TYPE_APP:
CleanAppMsg(&msg->body.appMsg);
break;
default:
break;
}
memset_s(msg, sizeof(FRAME_Msg), 0, sizeof(FRAME_Msg));
}
|
2301_79861745/bench_create
|
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;
}
|
2301_79861745/bench_create
|
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);
}
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
testcode/framework/tls/process/include/process.h
|
C
|
unknown
| 2,364
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <stdbool.h>
#include <semaphore.h>
#include "hlt_type.h"
#include "securec.h"
#include "logger.h"
#include "rpc_func.h"
#include "channel_res.h"
#include "handle_cmd.h"
#define SUCCESS 0
#define ERROR (-1)
#define ASSERT_RETURN(condition, log) \
do { \
if (!(condition)) { \
LOG_ERROR(log); \
return ERROR; \
} \
} while (0)
int ExpectResult(CmdData *expectCmdData)
{
int ret, id;
char *endPtr = NULL;
CmdData cmdData;
ControlChannelRes *channelRes;
channelRes = GetControlChannelRes();
OsLock(channelRes->rcvBufferLock);
id = (int)strtol(expectCmdData->id, &endPtr, 0) % MAX_RCV_BUFFER_NUM;
// Check whether the corresponding buffer contains content.
if (strlen(channelRes->rcvBuffer[id]) == 0) {
OsUnLock(channelRes->rcvBufferLock);
return ERROR;
}
// Parsing the CMD
ret = ParseCmdFromStr(channelRes->rcvBuffer[id], &cmdData);
if (ret != SUCCESS) {
LOG_ERROR("ParseCmdFromStr ERROR");
OsUnLock(channelRes->rcvBufferLock);
return ERROR;
}
if ((strncmp(expectCmdData->id, cmdData.id, strlen(cmdData.id)) == 0) &&
(strncmp(expectCmdData->funcId, cmdData.funcId, strlen(cmdData.funcId)) == 0)) {
ret = memcpy_s(expectCmdData->paras, sizeof(expectCmdData->paras), cmdData.paras, sizeof(cmdData.paras));
if (ret != EOK) {
LOG_ERROR("memcpy_s ERROR");
OsUnLock(channelRes->rcvBufferLock);
return ERROR;
}
(void)memset_s(channelRes->rcvBuffer[id], CONTROL_CHANNEL_MAX_MSG_LEN, 0, CONTROL_CHANNEL_MAX_MSG_LEN);
OsUnLock(channelRes->rcvBufferLock);
return SUCCESS;
}
OsUnLock(channelRes->rcvBufferLock);
LOG_ERROR("strncmp ERROR [expectCmdData->id=%s, cmdData.id = %s, expectCmdData->funcId = %s, cmdData.funcId = %s]",
expectCmdData->id, cmdData.id, expectCmdData->funcId, cmdData.funcId);
return ERROR;
}
int WaitResultFromPeer(CmdData *expectCmdData)
{
int ret;
int timeout = TIME_OUT_SEC;
if (getenv("SSL_TIMEOUT") != NULL) {
timeout = atoi(getenv("SSL_TIMEOUT"));
}
timeout *= 2;
time_t start = time(NULL);
do {
ret = ExpectResult(expectCmdData);
usleep(1000); // Waiting for 1000 subtleties
} while ((ret != SUCCESS) && (time(NULL) - start < timeout));
ASSERT_RETURN(ret == SUCCESS, "ExpectResult Error");
return SUCCESS;
}
int ParseCmdFromStr(char *str, CmdData *cmdData)
{
int ret, count, strBufLen;
char *token = NULL;
char *rest = NULL;
char *strBuf = NULL;
(void)memset_s(cmdData, sizeof(CmdData), 0, sizeof(CmdData));
strBufLen = strlen(str) + 1;
strBuf = (char*)malloc(strBufLen);
ASSERT_RETURN(strBuf != NULL, "Malloc Error");
(void)memset_s(strBuf, strBufLen, 0, strBufLen);
ret = memcpy_s(strBuf, strBufLen, str, strlen(str));
if (ret != EOK) {
LOG_ERROR("memcpy_s Error");
goto ERR;
}
/*
The command message structure is as follows:
ID | FUNC | PARAS1 | PARAS2 |......
Fields are separated by vertical bars (|).
*/
// Get ID
token = strtok_s(strBuf, "|", &rest);
ret = strcpy_s(cmdData->id, sizeof(cmdData->id), token); // Get Id
if (ret != EOK) {
LOG_ERROR("strcpy_s Error");
goto ERR;
}
// Get FUNC.
token = strtok_s(NULL, "|", &rest);
ret = strcpy_s(cmdData->funcId, sizeof(cmdData->funcId), token); // Get FunId
if (ret != EOK) {
LOG_ERROR("strcpy_s Error");
goto ERR;
}
// Obtaining Parameters
token = strtok_s(NULL, "|", &rest);
count = 0;
for (; token != NULL; token = strtok_s(NULL, "|", &rest)) {
// Maximum length of argument is CONTROL_CHANNEL_MAX_MSG_LEN
ret = strcpy_s(cmdData->paras[count], sizeof(cmdData->paras[0]), token);
int offset = 0;
while (rest[offset] == '|') {
count++;
offset++;
}
count++;
if (ret != EOK) {
break;
}
}
if (ret != EOK) {
LOG_ERROR("strcpy_s error");
goto ERR;
}
cmdData->parasNum = count;
free(strBuf);
return SUCCESS;
ERR:
free(strBuf);
return ERROR;
}
int ParseCmdFromBuf(ControlChannelBuf *dataBuf, CmdData *cmdData)
{
return ParseCmdFromStr(dataBuf->data, cmdData);
}
int ExecuteCmd(CmdData *cmdData)
{
int ret;
RpcFunList *rcpFuncList = GetRpcFuncList();
int funcNum = GetRpcFuncNum();
ret = ERROR;
for (int i = 0; i < funcNum; i++) {
if (strncmp(rcpFuncList[i].funcId, cmdData->funcId, strlen(cmdData->funcId)) == 0) {
ret = rcpFuncList[i].hfunc(cmdData);
return ret;
}
}
LOG_ERROR("Not Find FuncId");
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ERROR);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
return ret;
}
int ParseCtxConfigFromString(char (*string)[CONTROL_CHANNEL_MAX_MSG_LEN], HLT_Ctx_Config *ctxConfig)
{
int ret;
/*
The message structure is as follows:
minVersion | maxVersion |cipherSuites |CA |......
Fields are separated by vertical bars (|).
*/
int index = 1;
// minimum version number
// The first parameter indicates the minimum version number.
ctxConfig->minVersion = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx minVersion is %u", ctxConfig->minVersion);
// Maximum version number
// The second parameter indicates the maximum version number.
ctxConfig->maxVersion = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx maxVersion is %u", ctxConfig->maxVersion);
// Obtaining the Algorithm Suite
// The third parameter indicates the algorithm suite.
ret = strcpy_s(ctxConfig->cipherSuites, sizeof(ctxConfig->cipherSuites), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx cipherSuites is %s", ctxConfig->cipherSuites);
// The fourth parameter indicates the algorithm suite.
ret = strcpy_s(ctxConfig->tls13CipherSuites, sizeof(ctxConfig->tls13CipherSuites), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx tls13cipherSuites is %s", ctxConfig->tls13CipherSuites);
// ECC Point Format Configuration for Asymmetric Algorithms
// The fifth parameter indicates the dot format.
ret = strcpy_s(ctxConfig->pointFormats, sizeof(ctxConfig->pointFormats), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx pointFormats is %s", ctxConfig->pointFormats);
// Obtaining a Group
// The sixth parameter indicates a group.
ret = strcpy_s(ctxConfig->groups, sizeof(ctxConfig->groups), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx groups is %s", ctxConfig->groups);
// Obtaining a Signature
// The seventh parameter indicates the signature.
ret = strcpy_s(ctxConfig->signAlgorithms, sizeof(ctxConfig->signAlgorithms), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx signAlgorithms is %s", ctxConfig->signAlgorithms);
// Whether to support renegotiation
// The eighth parameter indicates whether renegotiation is supported.
ctxConfig->isSupportRenegotiation = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
LOG_DEBUG("Remote Process Set Ctx isSupportRenegotiation is %d", ctxConfig->isSupportRenegotiation);
// Indicates whether to verify the client.
// The tenth parameter indicates whether to verify the client.
ctxConfig->isSupportClientVerify = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
LOG_DEBUG("Remote Process Set Ctx isSupportClientVerify is %d", ctxConfig->isSupportClientVerify);
// Indicates whether the client can send an empty certificate chain.
// The eleventh parameter indicates whether the client can send an empty certificate chain.
ctxConfig->isSupportNoClientCert = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
LOG_DEBUG("Remote Process Set Ctx isSupportNoClientCert is %d", ctxConfig->isSupportNoClientCert);
// Indicates whether extended master keys are supported.
// The twelfth parameter indicates whether the extended master key is supported.
ctxConfig->isSupportExtendMasterSecret = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
LOG_DEBUG("Remote Process Set Ctx isSupportExtendMasterSecret is %d", ctxConfig->isSupportExtendMasterSecret);
// device certificate
// The thirteenth parameter indicates the location of the device certificate.
ret = strcpy_s(ctxConfig->eeCert, sizeof(ctxConfig->eeCert), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx EE is %s", ctxConfig->eeCert);
// private key
// The fourteenth parameter indicates the location of the private key.
ret = strcpy_s(ctxConfig->privKey, sizeof(ctxConfig->privKey), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx privKey is %s", ctxConfig->privKey);
// private key password
// The fifteenth parameter indicates the password of the private key.
ret = strcpy_s(ctxConfig->password, sizeof(ctxConfig->password), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx password is %s", ctxConfig->password);
// CA certificate
// The 16th parameter indicates the CA certificate.
ret = strcpy_s(ctxConfig->caCert, sizeof(ctxConfig->caCert), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx caCert is %s", ctxConfig->caCert);
// Chain certificate
// The 17th parameter indicates the certificate chain.
ret = strcpy_s(ctxConfig->chainCert, sizeof(ctxConfig->chainCert), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx chainCert is %s", ctxConfig->chainCert);
// signature certificate
LOG_DEBUG("Remote Process Set Ctx signCert is %s", string[index]);
// The eighteenth parameter indicates the position of the signature certificate.
ret = strcpy_s(ctxConfig->signCert, sizeof(ctxConfig->signCert), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
// private key for signature
LOG_DEBUG("Remote Process Set Ctx signPrivKey is %s", string[index]);
// The 19th parameter indicates the location of the signature private key.
ret = strcpy_s(ctxConfig->signPrivKey, sizeof(ctxConfig->signPrivKey), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
// psk
ret = strcpy_s(ctxConfig->psk, sizeof(ctxConfig->psk), string[index++]); // 21st parameter psk
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx psk is %s", ctxConfig->psk);
// Indicates whether to support session tickets.
// Indicates whether to enable the sessionTicket function. The value is a decimal number.
ctxConfig->isSupportSessionTicket = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx isSupportSessionTicket is %d", ctxConfig->isSupportSessionTicket);
// Setting the Session Storage Mode
// The 23rd parameter is used to set the session storage mode. The value is a decimal number.
ctxConfig->setSessionCache = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx SessionCache is %d", ctxConfig->setSessionCache);
// Setting the ticket key cb
// 24th parameter ticket key cb
ret = strcpy_s(ctxConfig->ticketKeyCb, sizeof(ctxConfig->ticketKeyCb), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx ticketKeyCb is %s", ctxConfig->ticketKeyCb);
// Indicates whether isFlightTransmitEnable is supported. The 25th parameter indicates whether to send handshake
// messages by flight. The value is converted into a decimal number.
ctxConfig->isFlightTransmitEnable = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
LOG_DEBUG("Remote Process Set Ctx isFlightTransmitEnable is %d", ctxConfig->isFlightTransmitEnable);
// Setting the server name
ret = strcpy_s(ctxConfig->serverName, sizeof(ctxConfig->serverName), string[index++]); // Parameter 26
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx ServerName is %s", ctxConfig->serverName);
// Setting the server name cb
// 27th parameter server name cb
ret = strcpy_s(ctxConfig->sniDealCb, sizeof(ctxConfig->sniDealCb), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx ServerNameCb is %s", ctxConfig->sniDealCb);
// Setting the server name arg
// 28th parameter server name arg cb
ret = strcpy_s(ctxConfig->sniArg, sizeof(ctxConfig->sniArg), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx ServerNameArg is %s", ctxConfig->sniArg);
// Setting the ALPN
ret = strcpy_s(ctxConfig->alpnList, sizeof(ctxConfig->alpnList), string[index++]); // 29th parameter
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx alpnList is %s", ctxConfig->alpnList);
// Setting the ALPN cb
ret = strcpy_s(ctxConfig->alpnSelectCb, sizeof(ctxConfig->alpnSelectCb), string[index++]); // 30th parameter
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx alpnSelectCb is %s", ctxConfig->alpnSelectCb);
// Setting the ALPN data
ret = strcpy_s(ctxConfig->alpnUserData, sizeof(ctxConfig->alpnUserData), string[index++]); // 31th parameter
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx alpnUserData is %s", ctxConfig->alpnUserData);
// Sets the security level. The parameter indicates that the security strength of the key meets the security level
// requirements and is converted into a decimal number.
ctxConfig->securitylevel = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx SecurityLevel is %d", ctxConfig->securitylevel);
// Indicates whether the DH key length follows the certificate. The parameter indicates whether the DH key length
// follows the certificate, which is converted into a decimal number.
ctxConfig->isSupportDhAuto = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx issupportDhauto is %d", ctxConfig->isSupportDhAuto);
// Sets the TLS1.3 key exchange mode. The parameter indicates the TLS1.3 key exchange mode,
// which is converted into a decimal number.
ctxConfig->keyExchMode = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx keyExchMode is %u", ctxConfig->keyExchMode);
// The parameter indicates the SupportType callback type, which converts characters into decimal numbers.
ctxConfig->SupportType = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx SupportType is %d", ctxConfig->SupportType);
ctxConfig->isSupportPostHandshakeAuth = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
ctxConfig->readAhead = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx readAhead is %u", ctxConfig->readAhead);
// Sets whether to verify the keyusage in the certificate. The keyusage is converted into a decimal number.
ctxConfig->needCheckKeyUsage = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
LOG_DEBUG("Remote Process Set Ctx needCheckKeyUsage is %d", ctxConfig->needCheckKeyUsage);
// Set whether to continue the handshake when the verification of peer certificate fails
ctxConfig->isSupportVerifyNone = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
LOG_DEBUG("Remote Process Set Ctx isSupportVerifyNone is %d", ctxConfig->isSupportVerifyNone);
// Whether allow a renegotiation initiated by the client
ctxConfig->allowClientRenegotiate = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
LOG_DEBUG("Remote Process Set Ctx allowClientRenegotiate is %d", ctxConfig->allowClientRenegotiate);
// Set the empty record number.
ctxConfig->emptyRecordsNum = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx emptyRecordsNum is %u", ctxConfig->emptyRecordsNum);
// Whether allow legacy renegotiation
ctxConfig->allowLegacyRenegotiate = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
LOG_DEBUG("Remote Process Set Ctx allowLegacyRenegotiate is %d", ctxConfig->allowLegacyRenegotiate);
// Indicates whether encrypt then mac are supported.
ctxConfig->isEncryptThenMac = (((int)strtol(string[index++], NULL, 10)) > 0) ? true : false;
LOG_DEBUG("Remote Process Set Ctx isEncryptThenMac is %d", ctxConfig->isEncryptThenMac);
// set the features supported by modesupport, The value is a decimal number.
ctxConfig->modeSupport = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx modeSupport is %d", ctxConfig->modeSupport);
ctxConfig->isMiddleBoxCompat = (int)strtol(string[index++], NULL, 10);
LOG_DEBUG("Remote Process Set Ctx MiddleBoxCompat is %d", ctxConfig->isMiddleBoxCompat);
// set the attrName
ret = strcpy_s(ctxConfig->attrName, sizeof(ctxConfig->attrName), string[index++]);
ASSERT_RETURN(ret == EOK, "strcpy_s Error");
LOG_DEBUG("Remote Process Set Ctx attrName is %s", ctxConfig->attrName);
// Setting the info cb
ctxConfig->infoCb = NULL; // The pointer cannot be transferred. Set this parameter to null.
return SUCCESS;
}
|
2301_79861745/bench_create
|
testcode/framework/tls/process/src/handle_cmd.c
|
C
|
unknown
| 18,808
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/syscall.h>
#include <libgen.h>
#include "lock.h"
#include "hlt.h"
#include "logger.h"
#include "tls_res.h"
#include "channel_res.h"
#include "control_channel.h"
#include "rpc_func.h"
#include "hitls.h"
#include "hitls_config.h"
#include "process.h"
#define SUCCESS 0
#define ERROR (-1)
#define CMD_MAX_LEN (512)
#define DOMAIN_PATH_LEN (128)
#define START_PROCESS_CMD "./process %d ./%s_%d ./%s %d > ./%s_%d.log &"
#define ASSERT_RETURN(condition, log) \
do { \
if (!(condition)) { \
LOG_ERROR(log); \
return ERROR; \
} \
} while (0)
typedef struct ProcessRes {
Process *process;
struct ProcessRes *next;
} ProcessRes;
typedef struct ProcessList {
ProcessRes *processRes;
uint8_t num;
} ProcessList;
static ProcessList g_processList;
static Process *g_process = NULL;
static int g_processIndex = 0;
// Initialization process linked list, which is used only in the Local Process process and is used to save the Remote
// Process.
int InitProcessList(void)
{
g_processList.processRes = (ProcessRes*)malloc(sizeof(ProcessRes));
ASSERT_RETURN(g_processList.processRes != NULL, "Malloc ProcessRes Error");
memset_s(g_processList.processRes, sizeof(ProcessRes), 0, sizeof(ProcessRes));
g_processList.num = 0;
return SUCCESS;
}
// Inserts a process to a linked list. Currently, only remote processes are stored.
int InsertProcessToList(Process *tmpProcess)
{
ProcessRes *frontProcessRes = g_processList.processRes;
ProcessRes *nextProcessRes = NULL;
ProcessRes *tmpProcessRes;
ASSERT_RETURN(tmpProcess != NULL, "TmpProcess is NULL");
// Find the last process resource. The obtained frontProcessRes is the last process resource.
nextProcessRes = frontProcessRes->next;
while (nextProcessRes != NULL) {
frontProcessRes = nextProcessRes;
nextProcessRes = frontProcessRes->next;
}
// Applying for Process Resources
tmpProcessRes = (ProcessRes*)malloc(sizeof(ProcessRes));
ASSERT_RETURN(tmpProcessRes != NULL, "Malloc ProcessRes Error");
tmpProcessRes->process = tmpProcess;
tmpProcessRes->next = NULL;
frontProcessRes->next = tmpProcessRes;
g_processList.num++;
return SUCCESS;
}
Process *GetProcessFromList(void)
{
ProcessRes *headProcessRes = g_processList.processRes;
ProcessRes *firstProcessRes, *nextProcessRes;
Process* resultProcess;
if (g_processList.num == 0) {
return NULL;
}
// Find the last element
firstProcessRes = headProcessRes->next;
nextProcessRes = firstProcessRes;
while ((nextProcessRes != NULL) && (nextProcessRes->next != NULL)) {
firstProcessRes = nextProcessRes;
nextProcessRes = firstProcessRes->next;
}
resultProcess = firstProcessRes->process;
firstProcessRes->next = NULL;
g_processList.num--;
return resultProcess;
}
void FreeProcessResList(void)
{
ProcessRes *frontProcessRes = g_processList.processRes;
ProcessRes *nextProcessRes = NULL;
ProcessRes *tmpProcessRes = NULL;
nextProcessRes = frontProcessRes->next;
while (nextProcessRes != NULL) {
tmpProcessRes = nextProcessRes->next;
free(nextProcessRes);
nextProcessRes = tmpProcessRes;
}
free(g_processList.processRes);
memset_s(&g_processList, sizeof(g_processList), 0, sizeof(g_processList));
return;
}
int InitProcess(void)
{
g_process= (Process*)malloc(sizeof(Process));
ASSERT_RETURN(g_process != NULL, "Malloc ProcessRes Error");
(void)memset_s(g_process, sizeof(Process), 0, sizeof(Process));
return SUCCESS;
}
Process *GetProcess(void)
{
return g_process;
}
void FreeProcess(void)
{
if (g_process != NULL) {
free(g_process);
g_process = NULL;
}
return;
}
void MonitorControlChannel(void)
{
fd_set fdSet;
char *endPtr = NULL;
int ret, fdMax, index;
ControlChannelBuf dataBuf;
ControlChannelRes *channelInfo;
channelInfo = GetControlChannelRes();
int32_t fd = channelInfo->sockFd;
fdMax = fd + 1;
struct timeval stTimeOut = {0};
while (!channelInfo->isExit) {
stTimeOut.tv_sec = 1;
stTimeOut.tv_usec = 0;
FD_ZERO(&fdSet);
FD_SET(fd, &fdSet);
ret = select(fdMax, &fdSet, NULL, NULL, &stTimeOut);
if (ret <= 0) {
LOG_ERROR("Select Error");
continue;
}
if (FD_ISSET(fd, &fdSet)) {
ret = ControlChannelRead(fd, &dataBuf);
if (ret != SUCCESS) {
LOG_ERROR("ControlChannelRead Error");
continue;
}
CmdData cmdData = {0};
ret = ParseCmdFromStr(dataBuf.data, &cmdData);
index = (int)strtol(cmdData.id, &endPtr, 0) % MAX_RCV_BUFFER_NUM;
ret = PushResultToChannelIdBuffer(channelInfo, dataBuf.data, index);
if (ret != SUCCESS) {
LOG_ERROR("PushResultToChannelRcvBuffer Error");
return;
}
LOG_DEBUG("Local Process Rcv is %s", dataBuf.data);
} else {
LOG_ERROR("FD_ISSET Error");
}
}
}
HLT_Process *InitSrcProcess(TLS_TYPE tlsType, char *srcDomainPath)
{
int ret, srcPathLen;
ControlChannelRes *channelInfo;
char srcControlDomainPath[DOMAIN_PATH_LEN] = {0};
HLT_Process *process;
// Check whether the call is the first time.
process = GetProcess();
if (process != NULL) {
LOG_ERROR("Repeat Init LocalProcess Is Not Support");
return NULL;
}
// The printf output buffer is not set.
setbuf(stdout, NULL);
// Initializes the command statistics global variable, which is required only by the local process.
InitCmdIndex();
srcPathLen = strlen(srcDomainPath);
if (srcPathLen == 0) {
LOG_ERROR("srcDomainPath is NULL");
return NULL;
}
ret = sprintf_s(srcControlDomainPath, DOMAIN_PATH_LEN, "%s.%u.sock", basename(srcDomainPath), getpid());
ret = InitProcess();
if (ret != SUCCESS) {
LOG_ERROR("InitProcess Error");
return NULL;
}
process = GetProcess();
if (HLT_LibraryInit(tlsType) != SUCCESS) {
LOG_ERROR("HLT_TlsRegCallback ERROR is %d", ret);
goto ERR;
}
// Initialize the process resource linked list, which is used to store remote process resources.
ret = InitProcessList();
if (ret != SUCCESS) {
LOG_ERROR("InitProcessList ERROR");
goto ERR;
}
// Initializes the CTX SSL resource linked list.
ret = InitTlsResList();
if (ret != SUCCESS) {
LOG_ERROR("InitTlsResList ERROR");
goto ERR;
}
// Initialize the control link.
ret = InitControlChannelRes(srcControlDomainPath, strlen(srcControlDomainPath), NULL, 0);
if (ret != SUCCESS) {
LOG_ERROR("InitControlChannelRes ERROR");
goto ERR;
}
channelInfo = GetControlChannelRes();
// Create control link UDP domain socket
ret = ControlChannelInit(channelInfo);
if (ret != SUCCESS) {
LOG_ERROR("ControlChannelInit ERROR");
goto ERR;
}
// Start a thread to listen to the control link. The link is used to receive the results returned by other processes
pthread_t tId;
channelInfo->isExit = false;
if (pthread_create(&tId, NULL, (void*)MonitorControlChannel, NULL) != 0) {
LOG_ERROR("Create MonitorControlChannel Thread Error ...");
goto ERR;
}
channelInfo->tid = tId;
// Populate Process Information
process->tlsType = tlsType;
process->controlChannelFd = channelInfo->sockFd;
process->remoteFlag = 0;
process->tlsResNum = 0;
process->hltTlsResNum = 0;
process->connType = NONE_TYPE;
process->connFd = 0;
ret = memcpy_s(process->srcDomainPath, DOMAIN_PATH_LEN, srcControlDomainPath, strlen(srcControlDomainPath));
if (ret != EOK) {
LOG_ERROR("memcpy_s process->srcDomainPath ERROR");
goto ERR;
}
LOG_DEBUG("Init Local Process Successful");
return (HLT_Process*)process;
ERR:
free(process);
return NULL;
}
HLT_Process *InitPeerProcess(TLS_TYPE tlsType, HILT_TransportType connType, int port, bool isBlock)
{
// peerDomainPath address, which is the IP address of the monitoring process.
// Creating a Process
int ret, peerPathLen, tryNum;
char startCmd[CMD_MAX_LEN] = {0};
HLT_Process *localProcess;
HLT_Process *process = NULL;
localProcess = GetProcess();
if (localProcess == NULL) {
LOG_ERROR("Must Call HLT_InitLocalProcess First");
return NULL;
}
peerPathLen = strlen(localProcess->srcDomainPath);
if (peerPathLen == 0) {
LOG_ERROR("peerDomainPath is NULL");
return NULL;
}
process = (HLT_Process*)malloc(sizeof(HLT_Process));
if (process == NULL) {
LOG_ERROR("Malloc Process is NULL");
return NULL;
}
(void)memset_s(process, sizeof(HLT_Process), 0, sizeof(HLT_Process));
pid_t localpid = getpid();
ret = sprintf_s(startCmd,
CMD_MAX_LEN,
START_PROCESS_CMD,
tlsType,
localProcess->srcDomainPath,
g_processIndex,
localProcess->srcDomainPath,
localpid,
localProcess->srcDomainPath,
g_processIndex);
if (ret == 0) {
LOG_ERROR("sprintf_s Error");
free(process);
return NULL;
}
LOG_DEBUG("Exect Cmd is %s", startCmd);
ret = system(startCmd);
if (ret == ERROR) {
LOG_ERROR("System Error");
free(process);
return NULL;
}
// After the remote process is started successfully, the remote process is stored in the linked list.
InsertProcessToList(process);
// The message is received, indicating that the peer end is in the receiveable state.
CmdData expectCmdData = {0};
(void)sprintf_s(expectCmdData.id, sizeof(expectCmdData.id), "0");
(void)sprintf_s(expectCmdData.funcId, sizeof(expectCmdData.funcId), "HEART");
tryNum = 0;
do {
ret = WaitResultFromPeer(&expectCmdData);
tryNum++;
} while ((ret == ERROR) && (tryNum < 2)); // Retry once
if (ret == ERROR) {
LOG_ERROR("WaitResultFromPeer Error");
goto ERR;
}
// Populate Process Information
process->connType = NONE_TYPE;
process->connFd = 0;
process->tlsType = tlsType;
process->remoteFlag = 1;
ret = sprintf_s(process->srcDomainPath, DOMAIN_PATH_LEN, "%s_%d", localProcess->srcDomainPath, g_processIndex);
if (ret <= 0) {
LOG_ERROR("sprintf_s Error");
goto ERR;
}
// Creating a Data Link
if (connType != NONE_TYPE) {
DataChannelParam channelParam;
HLT_FD sockFd = {0};
channelParam.port = port;
channelParam.type = connType;
channelParam.isBlock = isBlock; // The SCTP link is set to non-block. Otherwise, the SCTP link may be suspended.
sockFd = HLT_CreateDataChannel(process, localProcess, channelParam);
localProcess->connType = connType;
localProcess->connFd = sockFd.peerFd;
localProcess->sockAddr = sockFd.sockAddr;
process->connType = connType;
process->connFd = sockFd.srcFd;
process->connPort = sockFd.connPort;
if ((sockFd.srcFd <= 0) || (sockFd.peerFd <= 0)) {
LOG_ERROR("Create CHANNEL ERROR");
goto ERR;
}
}
g_processIndex++;
return (HLT_Process*)process;
ERR:
// You do not need to release the process. If you can go to this point,
// the process is successfully created and inserted into the table.
// The process resource is released in the HLT_FreeAllProcess function.
// If the remote process is released in advance, the remote process may be successfully started but cannot be exited
g_processIndex++;
return NULL;
}
|
2301_79861745/bench_create
|
testcode/framework/tls/process/src/process.c
|
C
|
unknown
| 12,643
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CHANNEL_RES_H
#define CHANNEL_RES_H
#include <stdio.h>
#include <stdint.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <stdbool.h>
#include <fcntl.h>
#include "lock.h"
#ifdef __cplusplus
extern "C" {
#endif
#define CONTROL_CHANNEL_MAX_MSG_LEN (20 * 1024)
#define DOMAIN_PATH_LEN (128)
#define MAX_SEND_BUFFER_NUM (100)
#define MAX_RCV_BUFFER_NUM (100)
typedef struct {
uint8_t *data;
uint32_t dataLen;
} DataBuf;
typedef struct {
char data[CONTROL_CHANNEL_MAX_MSG_LEN];
uint32_t dataLen;
} ControlChannelBuf;
typedef struct {
char srcDomainPath[DOMAIN_PATH_LEN];
char peerDomainPath[DOMAIN_PATH_LEN];
struct sockaddr_un srcAddr;
struct sockaddr_un peerAddr;
int32_t sockFd;
char sendBuffer[MAX_SEND_BUFFER_NUM][CONTROL_CHANNEL_MAX_MSG_LEN];
char rcvBuffer[MAX_RCV_BUFFER_NUM][CONTROL_CHANNEL_MAX_MSG_LEN];
uint8_t sendBufferNum;
Lock *sendBufferLock;
uint8_t rcvBufferNum;
Lock *rcvBufferLock;
pthread_t tid;
bool isExit;
} ControlChannelRes;
/**
* @brief Control Link Resource Initialization
*/
int InitControlChannelRes(char *srcDomainPath, int srcDomainPathLen, char *peerDomainPath, int peerDomainPathLen);
/**
* @brief Release control link resources.
*/
void FreeControlChannelRes(void);
/**
* @brief Obtaining Control Link Resources
*/
ControlChannelRes* GetControlChannelRes(void);
/**
* @brief Writes data to the control link
*/
int PushResultToChannelSendBuffer(ControlChannelRes *channelInfo, char *result);
/**
* @brief Read data from the control link
*/
int PushResultToChannelRcvBuffer(ControlChannelRes *channelInfo, char *result);
/**
* @brief Writes data to the control link by ID
*/
int PushResultToChannelIdBuffer(ControlChannelRes *channelInfo, char *result, int id);
#ifdef __cplusplus
}
#endif
#endif // CHANNEL_RES_H
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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;
}
|
2301_79861745/bench_create
|
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;
}
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
testcode/framework/tls/rpc/include/rpc_func.h
|
C
|
unknown
| 3,438
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include <stdlib.h>
#include <malloc.h>
#include <stdatomic.h>
#include "securec.h"
#include "hitls_crypt_type.h"
#include "hitls_session.h"
#include "logger.h"
#include "bsl_sal.h"
#include "hitls_error.h"
#include "hitls_sni.h"
#include "sni.h"
#include "hitls_alpn.h"
#include "hitls_type.h"
#include "common_func.h"
#define SUCCESS 0
#define ERROR (-1)
#define MAX_CERT_PATH_LENGTH (128)
#define SINGLE_CERT_LEN (120)
#define KEY_NAME_SIZE 16
#define IV_SIZE 16
#define KEY_SIZE 32
#define RENEGOTIATE_FAIL 1
static uint8_t g_keyName[KEY_NAME_SIZE] = {
0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A
};
static uint8_t g_key[KEY_SIZE] = {
0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A,
0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A
};
static uint8_t g_iv[IV_SIZE] = {
0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A
};
typedef struct {
char *name;
void *cb;
} ExampleCb;
typedef struct {
char *name;
void *(*data)(void);
} ExampleData;
#define ASSERT_RETURN(condition, log) \
do { \
if (!(condition)) { \
LOG_ERROR(log); \
return ERROR; \
} \
} while (0)
static char g_localIdentity[PSK_MAX_LEN] = "Client_identity";
static char g_localPsk[PSK_MAX_LEN] = "1A1A1A1A1A";
int32_t ExampleSetPsk(char *psk)
{
if (psk == NULL) {
LOG_DEBUG("input error.");
return -1;
}
(void)memset_s(g_localPsk, PSK_MAX_LEN, 0, PSK_MAX_LEN);
if (strcpy_s(g_localPsk, PSK_MAX_LEN, psk) != EOK) {
LOG_DEBUG("ExampleSetPsk failed.");
return -1;
}
return 0;
}
int32_t ExampleHexStr2BufHelper(const uint8_t *input, uint32_t inLen, uint8_t *out, uint32_t outLen, uint32_t *usedLen)
{
(void)inLen;
(void)outLen;
char indexH[2] = {0};
char indexL[2] = {0};
const uint8_t *curr = NULL;
uint8_t *outIndex = NULL;
int32_t high, low;
if ((input == NULL) || (out == NULL) || (usedLen == NULL)) {
return -1;
}
for (curr = input, outIndex = out; *curr;) {
indexH[0] = *curr++;
indexL[0] = *curr++;
if (indexL[0] == '\0') {
return -1;
}
high = (int32_t)strtol(indexH, NULL, 16); // Converting char to Hexadecimal numbers
low = (int32_t)strtol(indexL, NULL, 16); // Converting char to Hexadecimal numbers
if (high < 0 || low < 0) {
return -1;
}
*outIndex++ = (uint8_t)((high << 4) | low); // The upper four bits of the are shifted to the left
}
*usedLen = outIndex - out;
return 0;
}
uint32_t ExampleClientCb(HITLS_Ctx *ctx, const uint8_t *hint, uint8_t *identity, uint32_t maxIdentityLen, uint8_t *psk,
uint32_t maxPskLen)
{
(void)ctx;
(void)hint;
int32_t ret;
uint8_t pskTrans[PSK_MAX_LEN] = {0};
uint32_t pskTransUsedLen = 0u;
ret = ExampleHexStr2BufHelper((uint8_t *)g_localPsk, sizeof(g_localPsk), pskTrans, PSK_MAX_LEN, &pskTransUsedLen);
if (ret != 0) {
return 0;
}
/* strlen(g_localIdentity) + 1 copy terminator */
if (memcpy_s(identity, maxIdentityLen, g_localIdentity, strlen(g_localIdentity) + 1) != EOK) {
return 0;
}
if (memcpy_s(psk, maxPskLen, pskTrans, pskTransUsedLen) != EOK) {
return 0;
}
return pskTransUsedLen;
}
uint32_t ExampleServerCb(HITLS_Ctx *ctx, const uint8_t *identity, uint8_t *psk, uint32_t maxPskLen)
{
(void)ctx;
if (identity == NULL || strcmp((const char *)identity, g_localIdentity) != 0) {
return 0;
}
int32_t ret;
uint8_t pskTrans[PSK_MAX_LEN] = {0};
uint32_t pskTransUsedLen = 0u;
ret = ExampleHexStr2BufHelper((uint8_t *)g_localPsk, sizeof(g_localPsk), pskTrans, PSK_MAX_LEN, &pskTransUsedLen);
if (ret != 0) {
return 0;
}
if (memcpy_s(psk, maxPskLen, pskTrans, pskTransUsedLen) != EOK) {
return 0;
}
return pskTransUsedLen;
}
static void SetCipherInfo(void *cipher)
{
HITLS_CipherParameters *cipherPara = cipher;
cipherPara->type = HITLS_CBC_CIPHER;
cipherPara->algo = HITLS_CIPHER_AES_256_CBC;
cipherPara->key = g_key;
cipherPara->keyLen = sizeof(g_key);
cipherPara->hmacKey = g_key;
cipherPara->hmacKeyLen = sizeof(g_key);
cipherPara->iv = g_iv;
cipherPara->ivLen = sizeof(g_iv);
return;
}
int32_t ExampleTicketKeySuccessCb(uint8_t *keyName, uint32_t keyNameSize, void *cipher, uint8_t isEncrypt)
{
if (isEncrypt) {
if (memcpy_s(keyName, keyNameSize, g_keyName, KEY_NAME_SIZE) != EOK) {
return HITLS_TICKET_KEY_RET_FAIL;
}
SetCipherInfo(cipher);
return HITLS_TICKET_KEY_RET_SUCCESS;
}
if (memcmp(keyName, g_keyName, KEY_NAME_SIZE) != 0) {
return HITLS_TICKET_KEY_RET_FAIL;
}
SetCipherInfo(cipher);
return HITLS_TICKET_KEY_RET_SUCCESS;
}
int32_t ExampleTicketKeyRenewCb(uint8_t *keyName, uint32_t keyNameSize, void *cipher, uint8_t isEncrypt)
{
if (isEncrypt) {
if (memcpy_s(keyName, keyNameSize, g_keyName, KEY_NAME_SIZE) != EOK) {
return HITLS_TICKET_KEY_RET_FAIL;
}
SetCipherInfo(cipher);
return HITLS_TICKET_KEY_RET_SUCCESS_RENEW;
}
if (memcmp(keyName, g_keyName, KEY_NAME_SIZE) != 0) {
return HITLS_TICKET_KEY_RET_FAIL;
}
SetCipherInfo(cipher);
return HITLS_TICKET_KEY_RET_SUCCESS_RENEW;
}
int32_t ExampleTicketKeyAlertCb(uint8_t *keyName, uint32_t keyNameSize, HITLS_CipherParameters *cipher,
uint8_t isEncrypt)
{
if (isEncrypt) {
(void)memcpy_s(keyName, keyNameSize, g_keyName, KEY_NAME_SIZE);
SetCipherInfo(cipher);
return HITLS_TICKET_KEY_RET_SUCCESS_RENEW;
} else {
return HITLS_TICKET_KEY_RET_NEED_ALERT;
}
}
int32_t ExampleTicketKeyFailCb(uint8_t *keyName, uint32_t keyNameSize, HITLS_CipherParameters *cipher,
uint8_t isEncrypt)
{
if (isEncrypt) {
(void)memcpy_s(keyName, keyNameSize, g_keyName, KEY_NAME_SIZE);
SetCipherInfo(cipher);
return HITLS_TICKET_KEY_RET_SUCCESS_RENEW;
}
SetCipherInfo(cipher);
return HITLS_TICKET_KEY_RET_FAIL;
}
int32_t ExampleServerNameCb(HITLS_Ctx *ctx, int *alert, void *arg)
{
(void)ctx;
(void)arg;
*alert = HITLS_ACCEPT_SNI_ERR_OK;
return HITLS_ACCEPT_SNI_ERR_OK;
}
int32_t ExampleServerNameCbNOACK(HITLS_Ctx *ctx, int *alert, void *arg)
{
(void)ctx;
(void)alert;
(void)arg;
return HITLS_ACCEPT_SNI_ERR_NOACK;
}
int32_t ExampleServerNameCbALERT(HITLS_Ctx *ctx, int *alert, void *arg)
{
(void)ctx;
(void)alert;
(void)arg;
return HITLS_ACCEPT_SNI_ERR_ALERT_FATAL;
}
SNI_Arg *g_sniArg;
void *ExampleServerNameArg(void)
{
return g_sniArg;
}
static char *g_alpnhttp = "http";
int32_t ExampleAlpnParseProtocolList1(uint8_t *out, uint8_t *outLen, uint8_t *in, uint8_t inLen)
{
if (out == NULL || outLen == NULL || in == NULL) {
return HITLS_NULL_INPUT;
}
if (inLen == 0) {
return HITLS_CONFIG_INVALID_LENGTH;
}
uint8_t i = 0u;
uint8_t commaNum = 0u;
uint8_t startPos = 0u;
for (i = 0u; i <= inLen; ++i) {
if (i == inLen || in[i] == ',') {
if (i == startPos) {
++startPos;
++commaNum;
continue;
}
out[startPos - commaNum] = (uint8_t)(i - startPos);
startPos = i + 1;
} else {
out[i + 1 - commaNum] = in[i];
}
}
*outLen = inLen + 1 - commaNum;
return HITLS_SUCCESS;
}
int32_t ExampleAlpnCb(HITLS_Ctx *ctx, char **selectedProto, uint8_t *selectedProtoSize, char *clientAlpnList,
uint32_t clientAlpnListSize, void *userData)
{
(void)ctx;
(void)userData;
if (clientAlpnListSize >= 5 && memcmp(clientAlpnList + 1, "http", 4) == 0) {
*selectedProto = clientAlpnList + 1;
*selectedProtoSize = 4;
return HITLS_ALPN_ERR_OK;
} else if (clientAlpnListSize >= 4 && memcmp(clientAlpnList + 1, "ftp", 3) == 0) {
*selectedProto = g_alpnhttp;
*selectedProtoSize = 4;
return HITLS_ALPN_ERR_OK;
} else if (clientAlpnListSize >= 4 && memcmp(clientAlpnList + 1, "mml", 3) == 0) {
*selectedProto = g_alpnhttp;
*selectedProtoSize = 4;
return HITLS_ALPN_ERR_ALERT_FATAL;
} else if (clientAlpnListSize >= 4 && memcmp(clientAlpnList + 1, "www", 3) == 0) {
*selectedProto = g_alpnhttp;
*selectedProtoSize = 4;
return HITLS_ALPN_ERR_OK;
} else {
return HITLS_ALPN_ERR_NOACK;
}
}
int32_t AlpnCbWARN1(HITLS_Ctx *ctx, uint8_t **selectedProto, uint8_t *selectedProtoSize, uint8_t *clientAlpnList,
uint32_t clientAlpnListSize, void *userData)
{
(void)ctx;
(void)selectedProto;
(void)selectedProtoSize;
(void)clientAlpnList;
(void)clientAlpnListSize;
(void)userData;
return HITLS_ALPN_ERR_ALERT_WARNING;
}
int32_t AlpnCbALERT1(HITLS_Ctx *ctx, uint8_t **selectedProto, uint8_t *selectedProtoSize, uint8_t *clientAlpnList,
uint32_t clientAlpnListSize, void *userData)
{
(void)ctx;
(void)selectedProto;
(void)selectedProtoSize;
(void)clientAlpnList;
(void)clientAlpnListSize;
(void)userData;
return HITLS_ALPN_ERR_ALERT_FATAL;
}
void *ExampleAlpnData(void)
{
// Return the alpnData address.
return "audata";
}
void *GetTicketKeyCb(char *str)
{
const ExampleCb cbList[] = {
{"ExampleTicketKeySuccessCb", ExampleTicketKeySuccessCb},
{"ExampleTicketKeyRenewCb", ExampleTicketKeyRenewCb},
{"ExampleTicketKeyAlertCb", ExampleTicketKeyAlertCb},
{"ExampleTicketKeyFailCb", ExampleTicketKeyFailCb},
};
int len = sizeof(cbList) / sizeof(cbList[0]);
for (int i = 0; i < len; i++) {
if (strcmp(str, cbList[i].name) == 0) {
return cbList[i].cb;
}
}
return NULL;
}
static void ExampleKeyLogCb(HITLS_Ctx *ctx, const char *out)
{
(void)ctx; // Unused parameter
char *fileName = "FileKeyLog.txt";
char *fileEndStr = "\n";
FILE *fp = fopen(fileName, "a+");
if (fp == NULL) {
return;
}
fwrite(out, sizeof(char), strlen(out), fp);
fwrite((char*)fileEndStr, sizeof(char), strlen(fileEndStr), fp);
fclose(fp);
}
void *GetExtensionCb(const char *str)
{
const ExampleCb cbList[] = {
{"ExampleSNICb", ExampleServerNameCb},
{"ExampleAlpnCb", ExampleAlpnCb},
{"ExampleAlpnWarnCb", AlpnCbWARN1},
{"ExampleAlpAlertCb", AlpnCbALERT1},
{"ExampleSNICbnoack", ExampleServerNameCbNOACK},
{"ExampleSNICbAlert", ExampleServerNameCbALERT},
{"ExampleKeyLogCb", ExampleKeyLogCb},
};
int len = sizeof(cbList) / sizeof(cbList[0]);
for (int i = 0; i < len; i++) {
if (strcmp(str, cbList[i].name) == 0) {
return cbList[i].cb;
}
}
return NULL;
}
void *GetExampleData(const char *str)
{
const ExampleData cbList[] = {
{"ExampleSNIArg", ExampleServerNameArg},
{"ExampleAlpnData", ExampleAlpnData},
};
int len = sizeof(cbList) / sizeof(cbList[0]);
for (int i = 0; i < len; i++) {
if (strcmp(str, cbList[i].name) == 0) {
return cbList[i].data();
}
}
return NULL;
}
|
2301_79861745/bench_create
|
testcode/framework/tls/rpc/src/common_func.c
|
C
|
unknown
| 12,103
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include "uio_base.h"
#include "bsl_sal.h"
#include "sal_net.h"
#include "hitls.h"
#include "hitls_cert_type.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "hitls_psk.h"
#include "hitls_session.h"
#include "hitls_debug.h"
#include "hitls_sni.h"
#include "hitls_alpn.h"
#include "hitls_security.h"
#include "hitls_crypt_init.h"
#include "tls.h"
#include "hlt_type.h"
#include "logger.h"
#include "tls_res.h"
#include "cert_callback.h"
#include "sctp_channel.h"
#include "tcp_channel.h"
#include "udp_channel.h"
#include "common_func.h"
#include "crypt_eal_rand.h"
#include "crypt_algid.h"
#include "channel_res.h"
#include "crypt_eal_provider.h"
#define SUCCESS 0
#define ERROR (-1)
#define FUNC_TIME_OUT_SEC 120
#define ASSERT_RETURN(condition, log) \
do { \
if (!(condition)) { \
LOG_ERROR(log); \
return ERROR; \
} \
} while (0)
typedef struct {
char *name;
uint16_t configValue;
} HitlsConfig;
typedef enum {
CIPHER,
GROUPS,
SIGNATURE,
POINTFORMAT,
} HitlsConfigType;
static const HitlsConfig g_cipherSuiteList[] = {
{"HITLS_RSA_WITH_AES_128_CBC_SHA", HITLS_RSA_WITH_AES_128_CBC_SHA},
{"HITLS_DHE_DSS_WITH_AES_128_CBC_SHA", HITLS_DHE_DSS_WITH_AES_128_CBC_SHA},
{"HITLS_DHE_RSA_WITH_AES_128_CBC_SHA", HITLS_DHE_RSA_WITH_AES_128_CBC_SHA},
{"HITLS_RSA_WITH_AES_256_CBC_SHA", HITLS_RSA_WITH_AES_256_CBC_SHA},
{"HITLS_DHE_DSS_WITH_AES_256_CBC_SHA", HITLS_DHE_DSS_WITH_AES_256_CBC_SHA},
{"HITLS_DHE_RSA_WITH_AES_256_CBC_SHA", HITLS_DHE_RSA_WITH_AES_256_CBC_SHA},
{"HITLS_RSA_WITH_AES_128_CBC_SHA256", HITLS_RSA_WITH_AES_128_CBC_SHA256},
{"HITLS_RSA_WITH_AES_256_CBC_SHA256", HITLS_RSA_WITH_AES_256_CBC_SHA256},
{"HITLS_DHE_DSS_WITH_AES_128_CBC_SHA256", HITLS_DHE_DSS_WITH_AES_128_CBC_SHA256},
{"HITLS_DHE_RSA_WITH_AES_128_CBC_SHA256", HITLS_DHE_RSA_WITH_AES_128_CBC_SHA256},
{"HITLS_DHE_DSS_WITH_AES_256_CBC_SHA256", HITLS_DHE_DSS_WITH_AES_256_CBC_SHA256},
{"HITLS_DHE_RSA_WITH_AES_256_CBC_SHA256", HITLS_DHE_RSA_WITH_AES_256_CBC_SHA256},
{"HITLS_RSA_WITH_AES_128_GCM_SHA256", HITLS_RSA_WITH_AES_128_GCM_SHA256},
{"HITLS_RSA_WITH_AES_256_GCM_SHA384", HITLS_RSA_WITH_AES_256_GCM_SHA384},
{"HITLS_DHE_RSA_WITH_AES_128_GCM_SHA256", HITLS_DHE_RSA_WITH_AES_128_GCM_SHA256},
{"HITLS_DHE_RSA_WITH_AES_256_GCM_SHA384", HITLS_DHE_RSA_WITH_AES_256_GCM_SHA384},
{"HITLS_DHE_DSS_WITH_AES_128_GCM_SHA256", HITLS_DHE_DSS_WITH_AES_128_GCM_SHA256},
{"HITLS_DHE_DSS_WITH_AES_256_GCM_SHA384", HITLS_DHE_DSS_WITH_AES_256_GCM_SHA384},
{"HITLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA", HITLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA},
{"HITLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA", HITLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA},
{"HITLS_ECDHE_RSA_WITH_AES_128_CBC_SHA", HITLS_ECDHE_RSA_WITH_AES_128_CBC_SHA},
{"HITLS_ECDHE_RSA_WITH_AES_256_CBC_SHA", HITLS_ECDHE_RSA_WITH_AES_256_CBC_SHA},
{"HITLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256", HITLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256},
{"HITLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384", HITLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384},
{"HITLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256", HITLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256},
{"HITLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384", HITLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384},
{"HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256", HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256},
{"HITLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384", HITLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384},
{"HITLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256", HITLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256},
{"HITLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384", HITLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384},
{"HITLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256", HITLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256},
{"HITLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256", HITLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256},
{"HITLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256", HITLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256},
{"HITLS_AES_128_GCM_SHA256", HITLS_AES_128_GCM_SHA256},
{"HITLS_AES_256_GCM_SHA384", HITLS_AES_256_GCM_SHA384},
{"HITLS_CHACHA20_POLY1305_SHA256", HITLS_CHACHA20_POLY1305_SHA256},
{"HITLS_AES_128_CCM_SHA256", HITLS_AES_128_CCM_SHA256},
{"HITLS_AES_128_CCM_8_SHA256", HITLS_AES_128_CCM_8_SHA256},
{"HITLS_ECDHE_ECDSA_WITH_AES_128_CCM", HITLS_ECDHE_ECDSA_WITH_AES_128_CCM},
{"HITLS_ECDHE_ECDSA_WITH_AES_256_CCM", HITLS_ECDHE_ECDSA_WITH_AES_256_CCM},
{"HITLS_DHE_RSA_WITH_AES_128_CCM", HITLS_DHE_RSA_WITH_AES_128_CCM},
{"HITLS_DHE_RSA_WITH_AES_256_CCM", HITLS_DHE_RSA_WITH_AES_256_CCM},
{"HITLS_RSA_WITH_AES_256_CCM", HITLS_RSA_WITH_AES_256_CCM},
{"HITLS_RSA_WITH_AES_256_CCM_8", HITLS_RSA_WITH_AES_256_CCM_8},
{"HITLS_RSA_WITH_AES_128_CCM", HITLS_RSA_WITH_AES_128_CCM},
{"HITLS_RSA_WITH_AES_128_CCM_8", HITLS_RSA_WITH_AES_128_CCM_8},
/* psk cipher suite */
{"HITLS_PSK_WITH_AES_128_CBC_SHA", HITLS_PSK_WITH_AES_128_CBC_SHA},
{"HITLS_PSK_WITH_AES_256_CBC_SHA", HITLS_PSK_WITH_AES_256_CBC_SHA},
{"HITLS_DHE_PSK_WITH_AES_128_CBC_SHA", HITLS_DHE_PSK_WITH_AES_128_CBC_SHA},
{"HITLS_DHE_PSK_WITH_AES_256_CBC_SHA", HITLS_DHE_PSK_WITH_AES_256_CBC_SHA},
{"HITLS_RSA_PSK_WITH_AES_128_CBC_SHA", HITLS_RSA_PSK_WITH_AES_128_CBC_SHA},
{"HITLS_RSA_PSK_WITH_AES_256_CBC_SHA", HITLS_RSA_PSK_WITH_AES_256_CBC_SHA},
{"HITLS_PSK_WITH_AES_128_GCM_SHA256", HITLS_PSK_WITH_AES_128_GCM_SHA256},
{"HITLS_PSK_WITH_AES_256_GCM_SHA384", HITLS_PSK_WITH_AES_256_GCM_SHA384},
{"HITLS_DHE_PSK_WITH_AES_128_GCM_SHA256", HITLS_DHE_PSK_WITH_AES_128_GCM_SHA256},
{"HITLS_DHE_PSK_WITH_AES_256_GCM_SHA384", HITLS_DHE_PSK_WITH_AES_256_GCM_SHA384},
{"HITLS_RSA_PSK_WITH_AES_128_GCM_SHA256", HITLS_RSA_PSK_WITH_AES_128_GCM_SHA256},
{"HITLS_RSA_PSK_WITH_AES_256_GCM_SHA384", HITLS_RSA_PSK_WITH_AES_256_GCM_SHA384},
{"HITLS_PSK_WITH_AES_128_CBC_SHA256", HITLS_PSK_WITH_AES_128_CBC_SHA256},
{"HITLS_PSK_WITH_AES_256_CBC_SHA384", HITLS_PSK_WITH_AES_256_CBC_SHA384},
{"HITLS_DHE_PSK_WITH_AES_128_CBC_SHA256", HITLS_DHE_PSK_WITH_AES_128_CBC_SHA256},
{"HITLS_DHE_PSK_WITH_AES_256_CBC_SHA384", HITLS_DHE_PSK_WITH_AES_256_CBC_SHA384},
{"HITLS_RSA_PSK_WITH_AES_128_CBC_SHA256", HITLS_RSA_PSK_WITH_AES_128_CBC_SHA256},
{"HITLS_RSA_PSK_WITH_AES_256_CBC_SHA384", HITLS_RSA_PSK_WITH_AES_256_CBC_SHA384},
{"HITLS_ECDHE_PSK_WITH_AES_128_CBC_SHA", HITLS_ECDHE_PSK_WITH_AES_128_CBC_SHA},
{"HITLS_ECDHE_PSK_WITH_AES_256_CBC_SHA", HITLS_ECDHE_PSK_WITH_AES_256_CBC_SHA},
{"HITLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256", HITLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256},
{"HITLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384", HITLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384},
{"HITLS_PSK_WITH_CHACHA20_POLY1305_SHA256", HITLS_PSK_WITH_CHACHA20_POLY1305_SHA256},
{"HITLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256", HITLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256},
{"HITLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256", HITLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256},
{"HITLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256", HITLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256},
{"HITLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256", HITLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256},
{"HITLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384", HITLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384},
{"HITLS_DHE_PSK_WITH_AES_128_CCM", HITLS_DHE_PSK_WITH_AES_128_CCM},
{"HITLS_DHE_PSK_WITH_AES_256_CCM", HITLS_DHE_PSK_WITH_AES_256_CCM},
{"HITLS_PSK_WITH_AES_256_CCM", HITLS_PSK_WITH_AES_256_CCM},
{"HITLS_ECDHE_PSK_WITH_AES_128_CCM_SHA256", HITLS_ECDHE_PSK_WITH_AES_128_CCM_SHA256},
/* Anonymous ciphersuite */
{"HITLS_DH_ANON_WITH_AES_256_CBC_SHA", HITLS_DH_ANON_WITH_AES_256_CBC_SHA},
{"HITLS_DH_ANON_WITH_AES_128_CBC_SHA", HITLS_DH_ANON_WITH_AES_128_CBC_SHA},
{"HITLS_DH_ANON_WITH_AES_128_CBC_SHA256", HITLS_DH_ANON_WITH_AES_128_CBC_SHA256},
{"HITLS_DH_ANON_WITH_AES_256_CBC_SHA256", HITLS_DH_ANON_WITH_AES_256_CBC_SHA256},
{"HITLS_DH_ANON_WITH_AES_128_GCM_SHA256", HITLS_DH_ANON_WITH_AES_128_GCM_SHA256},
{"HITLS_DH_ANON_WITH_AES_256_GCM_SHA384", HITLS_DH_ANON_WITH_AES_256_GCM_SHA384},
{"HITLS_ECDH_ANON_WITH_AES_128_CBC_SHA", HITLS_ECDH_ANON_WITH_AES_128_CBC_SHA},
{"HITLS_ECDH_ANON_WITH_AES_256_CBC_SHA", HITLS_ECDH_ANON_WITH_AES_256_CBC_SHA},
{"HITLS_ECDHE_SM4_CBC_SM3", HITLS_ECDHE_SM4_CBC_SM3},
{"HITLS_ECC_SM4_CBC_SM3", HITLS_ECC_SM4_CBC_SM3},
{"HITLS_ECDHE_SM4_GCM_SM3", HITLS_ECDHE_SM4_GCM_SM3},
{"HITLS_ECC_SM4_GCM_SM3", HITLS_ECC_SM4_GCM_SM3},
/* error ciphersuite */
{"HITLS_INVALID_CIPHER_TC01", 0xFFFF},
{"HITLS_INVALID_CIPHER_TC02", 0xFFFE},
};
static const HitlsConfig g_groupList[] = {
{"HITLS_EC_GROUP_BRAINPOOLP256R1", HITLS_EC_GROUP_BRAINPOOLP256R1},
{"HITLS_EC_GROUP_BRAINPOOLP384R1", HITLS_EC_GROUP_BRAINPOOLP384R1},
{"HITLS_EC_GROUP_BRAINPOOLP512R1", HITLS_EC_GROUP_BRAINPOOLP512R1},
{"HITLS_EC_GROUP_SECP256R1", HITLS_EC_GROUP_SECP256R1},
{"HITLS_EC_GROUP_SECP384R1", HITLS_EC_GROUP_SECP384R1},
{"HITLS_EC_GROUP_SECP521R1", HITLS_EC_GROUP_SECP521R1},
{"HITLS_EC_GROUP_CURVE25519", HITLS_EC_GROUP_CURVE25519},
{"HITLS_EC_GROUP_SM2", HITLS_EC_GROUP_SM2},
{"HITLS_INVALID_GROUP_TC01", 0xFF},
{"HITLS_INVALID_GROUP_TC02", 0xFE},
{"HITLS_FF_DHE_2048", HITLS_FF_DHE_2048},
{"HITLS_FF_DHE_3072", HITLS_FF_DHE_3072},
{"HITLS_FF_DHE_4096", HITLS_FF_DHE_4096},
{"HITLS_FF_DHE_6144", HITLS_FF_DHE_6144},
{"HITLS_FF_DHE_8192", HITLS_FF_DHE_8192},
{"SecP256r1MLKEM768", 4587}, // for new kem group
{"X25519MLKEM768", 4588}, // for new kem group
{"SecP384r1MLKEM1024", 4589}, // for new kem group
{"test_new_group", 477}, // for new group
{"test_new_group_kem", 478}, // NEW_KEM_ALGID
{"test_new_group_with_new_key_type", 479}, // NEW_PKEY_ALGID
};
static const HitlsConfig g_signatureList[] = {
{"CERT_SIG_SCHEME_RSA_PKCS1_SHA1", CERT_SIG_SCHEME_RSA_PKCS1_SHA1},
{"CERT_SIG_SCHEME_ECDSA_SHA1", CERT_SIG_SCHEME_ECDSA_SHA1},
{"CERT_SIG_SCHEME_ECDSA_SHA224", CERT_SIG_SCHEME_ECDSA_SHA224},
{"CERT_SIG_SCHEME_RSA_PKCS1_SHA224", CERT_SIG_SCHEME_RSA_PKCS1_SHA224},
{"CERT_SIG_SCHEME_RSA_PKCS1_SHA256", CERT_SIG_SCHEME_RSA_PKCS1_SHA256},
{"CERT_SIG_SCHEME_RSA_PKCS1_SHA384", CERT_SIG_SCHEME_RSA_PKCS1_SHA384},
{"CERT_SIG_SCHEME_RSA_PKCS1_SHA512", CERT_SIG_SCHEME_RSA_PKCS1_SHA512},
{"CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256", CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256},
{"CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384", CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384},
{"CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512", CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512},
{"CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA256", CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA256},
{"CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA384", CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA384},
{"CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA512", CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA512},
{"CERT_SIG_SCHEME_ED25519", CERT_SIG_SCHEME_ED25519},
{"CERT_SIG_SCHEME_ED448", CERT_SIG_SCHEME_ED448},
{"CERT_SIG_SCHEME_DSA_SHA1", CERT_SIG_SCHEME_DSA_SHA1},
{"CERT_SIG_SCHEME_DSA_SHA224", CERT_SIG_SCHEME_DSA_SHA224},
{"CERT_SIG_SCHEME_DSA_SHA256", CERT_SIG_SCHEME_DSA_SHA256},
{"CERT_SIG_SCHEME_DSA_SHA384", CERT_SIG_SCHEME_DSA_SHA384},
{"CERT_SIG_SCHEME_DSA_SHA512", CERT_SIG_SCHEME_DSA_SHA512},
{"CERT_SIG_SCHEME_SM2_SM3", CERT_SIG_SCHEME_SM2_SM3},
{"CERT_SIG_SCHEME_RSA_PSS_PSS_SHA256", CERT_SIG_SCHEME_RSA_PSS_PSS_SHA256},
{"CERT_SIG_SCHEME_RSA_PSS_PSS_SHA384", CERT_SIG_SCHEME_RSA_PSS_PSS_SHA384},
{"CERT_SIG_SCHEME_RSA_PSS_PSS_SHA512", CERT_SIG_SCHEME_RSA_PSS_PSS_SHA512},
{"HITLS_INVALID_SIG_TC01", 0xFFFF},
{"HITLS_INVALID_SIG_TC02", 0xFFFE},
{"test_new_sign_alg_name", 23333},
{"test_new_sign_alg_name_with_new_key_type", 24444},
};
static const HitlsConfig g_eccFormatList[] = {
{"HITLS_POINT_FORMAT_UNCOMPRESSED", HITLS_POINT_FORMAT_UNCOMPRESSED},
{"HITLS_INVALID_FORMAT_TC01", 0xFF},
{"HITLS_INVALID_FORMAT_TC02", 0xFE},
};
#ifdef HITLS_TLS_MAINTAIN_KEYLOG
static void KetLogPrint(HITLS_Ctx *ctx, const char *out)
{
(void)ctx;
char *fileName = "FileKeyLog.txt";
char *fileEndStr = "\n";
char *p = getenv("HITLSKEYLOGFILE");
if (p == NULL) {
return;
}
FILE *fp = fopen(fileName, "a+");
if (fp == NULL) {
return;
}
fwrite(out, sizeof(char), strlen(out), fp);
fwrite((char *)fileEndStr, sizeof(char), strlen(fileEndStr), fp);
fclose(fp);
}
#endif
int HitlsInit(void)
{
int ret;
ret = RegMemCallback(MEM_CALLBACK_DEFAULT);
ret |= RegCertCallback(CERT_CALLBACK_DEFAULT);
#ifdef HITLS_TLS_FEATURE_PROVIDER
CRYPT_EAL_ProviderRandInitCtx(NULL, CRYPT_RAND_SHA256, "provider=default", NULL, 0, NULL);
#else
CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0);
HITLS_CryptMethodInit();
#endif
return ret;
}
#ifdef HITLS_TLS_FEATURE_PROVIDER
static HITLS_Lib_Ctx *InitProviderLibCtx(char *providerPath, char (*providerNames)[MAX_PROVIDER_NAME_LEN],
int *providerLibFmts, int providerCnt)
{
int ret;
HITLS_Lib_Ctx *libCtx = CRYPT_EAL_LibCtxNew();
if (libCtx == NULL) {
LOG_ERROR("CRYPT_EAL_LibCtxNew Error");
return NULL;
}
if (providerPath != NULL && strlen(providerPath) > 0) {
ret = CRYPT_EAL_ProviderSetLoadPath(libCtx, providerPath);
if (ret != EOK) {
CRYPT_EAL_LibCtxFree(libCtx);
LOG_ERROR("CRYPT_EAL_ProviderSetLoadPath Error");
return NULL;
}
}
for (int i = 0; i < providerCnt; i++) {
ret = CRYPT_EAL_ProviderLoad(libCtx, (BSL_SAL_LibFmtCmd)providerLibFmts[i], providerNames[i], NULL, NULL);
if (ret != EOK) {
CRYPT_EAL_LibCtxFree(libCtx);
LOG_ERROR("CRYPT_EAL_ProviderLoad Error");
return NULL;
}
char attrName[512] = {0};
memcpy_s(attrName, sizeof(attrName), "provider?", strlen("provider?"));
memcpy_s(attrName + strlen("provider?"), sizeof(attrName) - strlen("provider?"), providerNames[i],
strlen(providerNames[i]));
CRYPT_EAL_ProviderRandInitCtx(libCtx, CRYPT_RAND_SHA256, attrName, NULL, 0, NULL);
}
return libCtx;
}
HITLS_Config *HitlsProviderNewCtx(char *providerPath, char (*providerNames)[MAX_PROVIDER_NAME_LEN], int *providerLibFmts,
int providerCnt, char *attrName, TLS_VERSION tlsVersion)
{
char *tmpAttrName = NULL;
if (attrName != NULL && strlen(attrName) > 0) {
tmpAttrName = attrName;
}
HITLS_Config *hitlsConfig = NULL;
HITLS_Lib_Ctx *libCtx = NULL;
if (providerCnt > 0) {
libCtx = InitProviderLibCtx(providerPath, providerNames, providerLibFmts, providerCnt);
if (libCtx == NULL) {
LOG_ERROR("InitProviderLibCtx Error");
return NULL;
}
}
switch (tlsVersion) {
case DTLS1_2:
LOG_DEBUG("HiTLS New DTLS1_2 Ctx");
hitlsConfig = HITLS_CFG_ProviderNewDTLS12Config(libCtx, tmpAttrName);
break;
case TLS1_2:
LOG_DEBUG("HiTLS New TLS1_2 Ctx");
hitlsConfig = HITLS_CFG_ProviderNewTLS12Config(libCtx, tmpAttrName);
break;
case TLS1_3:
LOG_DEBUG("HiTLS New TLS1_3 Ctx");
hitlsConfig = HITLS_CFG_ProviderNewTLS13Config(libCtx, tmpAttrName);
break;
case TLS_ALL:
LOG_DEBUG("HiTLS New TLS_ALL Ctx");
hitlsConfig = HITLS_CFG_ProviderNewTLSConfig(libCtx, tmpAttrName);
break;
#ifdef HITLS_TLS_PROTO_TLCP11
case TLCP1_1:
LOG_DEBUG("HiTLS New TLCP1_1 Ctx");
hitlsConfig = HITLS_CFG_ProviderNewTLCPConfig(libCtx, tmpAttrName);
break;
#endif
#ifdef HITLS_TLS_PROTO_DTLCP11
case DTLCP1_1:
LOG_DEBUG("HiTLS New DTLCP1_1 Ctx");
hitlsConfig = HITLS_CFG_ProviderNewDTLCPConfig(libCtx, tmpAttrName);
break;
#endif
default:
/* Unknown protocol type */
break;
}
if (hitlsConfig == NULL) {
CRYPT_EAL_LibCtxFree(libCtx);
LOG_ERROR("HITLS Not Support This TlsVersion's ID %d", tlsVersion);
}
#ifdef HITLS_TLS_FEATURE_SECURITY
// Setting the security level
HITLS_CFG_SetSecurityLevel(hitlsConfig, HITLS_SECURITY_LEVEL_ZERO);
#endif /* HITLS_TLS_FEATURE_SECURITY */
return hitlsConfig;
}
#endif
HITLS_Config *HitlsNewCtx(TLS_VERSION tlsVersion)
{
HITLS_Config *hitlsConfig = NULL;
switch (tlsVersion) {
#ifdef HITLS_TLS_PROTO_DTLS12
case DTLS1_2:
LOG_DEBUG("HiTLS New DTLS1_2 Ctx");
hitlsConfig = HITLS_CFG_NewDTLS12Config();
break;
#endif
#ifdef HITLS_TLS_PROTO_TLS12
case TLS1_2:
LOG_DEBUG("HiTLS New TLS1_2 Ctx");
hitlsConfig = HITLS_CFG_NewTLS12Config();
break;
#endif
#ifdef HITLS_TLS_PROTO_TLS13
case TLS1_3:
LOG_DEBUG("HiTLS New TLS1_3 Ctx");
hitlsConfig = HITLS_CFG_NewTLS13Config();
break;
#endif
#ifdef HITLS_TLS_PROTO_ALL
case TLS_ALL:
LOG_DEBUG("HiTLS New TLS_ALL Ctx");
hitlsConfig = HITLS_CFG_NewTLSConfig();
break;
#endif
#ifdef HITLS_TLS_PROTO_TLCP11
case TLCP1_1:
LOG_DEBUG("HiTLS New TLCP1_1 Ctx");
hitlsConfig = HITLS_CFG_NewTLCPConfig();
break;
#endif
#ifdef HITLS_TLS_PROTO_DTLCP11
case DTLCP1_1:
LOG_DEBUG("HiTLS New DTLCP1_1 Ctx");
hitlsConfig = HITLS_CFG_NewDTLCPConfig();
break;
#endif
default:
/* Unknown protocol type */
break;
}
if (hitlsConfig == NULL) {
LOG_ERROR("HITLS Not Support This TlsVersion's ID %d", tlsVersion);
}
#ifdef HITLS_TLS_FEATURE_SECURITY
// Setting the security level
HITLS_CFG_SetSecurityLevel(hitlsConfig, HITLS_SECURITY_LEVEL_ZERO);
#endif /* HITLS_TLS_FEATURE_SECURITY */
return hitlsConfig;
}
void HitlsFreeCtx(void *ctx)
{
if (ctx == NULL) {
return;
}
HITLS_CFG_FreeConfig(ctx);
}
static int32_t GetConfigVauleFromStr(const HitlsConfig *hitlsConfigList, uint32_t configSize, const char *cipherName)
{
for (uint32_t i = 0; i < configSize; i++) {
if (strcmp(cipherName, hitlsConfigList[i].name) != 0) {
continue;
}
return hitlsConfigList[i].configValue;
}
return ERROR; // The cipher suite does not exist.
}
static int8_t HitlsSetConfig(const HitlsConfig *hitlsConfigList, int configListSize, void *ctx,
char *name, HitlsConfigType type)
{
int ret = 0;
char configArray[MAX_CIPHERSUITES_LEN] = {0}; // A maximum of 512 characters are supported.
char *token, *rest;
int32_t configValue;
uint16_t configValueArray[20] = {0}; // Currently, a maximum of 20 cipher suites are supported.
uint32_t configSize = 0;
ret = memcpy_s(configArray, sizeof(configArray), name, strlen(name));
ASSERT_RETURN(ret == EOK, "Memcpy Error");
configSize = 0;
token = strtok_s(configArray, ":", &rest);
do {
// Currently, a maximum of 20 cipher suites are supported.
ASSERT_RETURN(configSize < 20, "Max Support Set 20 Config");
configValue = GetConfigVauleFromStr(hitlsConfigList, configListSize, token);
ASSERT_RETURN(configValue != ERROR, "GetConfigVauleFromStr Error");
configValueArray[configSize] = (uint16_t)configValue;
token = strtok_s(NULL, ":", &rest);
configSize++;
} while (token != NULL);
switch (type) {
case CIPHER:
ret = HITLS_CFG_SetCipherSuites(ctx, configValueArray, configSize);
break;
case GROUPS:
ret = HITLS_CFG_SetGroups(ctx, configValueArray, configSize);
break;
case SIGNATURE:
ret = HITLS_CFG_SetSignature(ctx, configValueArray, configSize);
break;
case POINTFORMAT:
{
uint8_t pointformatArray[20] = {0};
for (uint32_t i = 0; i < configSize; i++) {
pointformatArray[i] = configValueArray[i];
}
ret = HITLS_CFG_SetEcPointFormats(ctx, pointformatArray, configSize);
break;
}
default:
ret = ERROR;
}
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetXXX Error");
return SUCCESS;
}
int HitlsSetCtx(HITLS_Config *outCfg, HLT_Ctx_Config *inCtxCfg)
{
int ret = 0;
#ifdef HITLS_TLS_FEATURE_SESSION
if (inCtxCfg->setSessionCache >= 0) {
LOG_DEBUG("HiTLS Set SessionCache is %d", inCtxCfg->setSessionCache);
HITLS_CFG_SetSessionCacheMode(outCfg, inCtxCfg->setSessionCache);
}
#endif
#ifdef HITLS_TLS_PROTO_ALL
// Set the protocol version.
if ((inCtxCfg->minVersion != 0) && (inCtxCfg->maxVersion != 0)) {
LOG_DEBUG("HiTLS Set minVersion is %u maxVersion is %u", inCtxCfg->minVersion, inCtxCfg->maxVersion);
ret = HITLS_CFG_SetVersion(outCfg, inCtxCfg->minVersion, inCtxCfg->maxVersion);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetVersion Error ERROR");
}
#endif
if (inCtxCfg->SupportType == SERVER_CFG_SET_TRUE) {
HITLS_CFG_SetCipherServerPreference(outCfg, true);
}
if (inCtxCfg->SupportType == SERVER_CFG_SET_FALSE) {
HITLS_CFG_SetCipherServerPreference(outCfg, false);
}
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
// Setting Renegotiation
LOG_DEBUG("HiTLS Set Support Renegotiation is %d", inCtxCfg->isSupportRenegotiation);
ret = HITLS_CFG_SetRenegotiationSupport(outCfg, inCtxCfg->isSupportRenegotiation);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetRenegotiationSupport ERROR");
// Whether allow a renegotiation initiated by the client
LOG_DEBUG("HiTLS Set allow Client Renegotiate is %d", inCtxCfg->allowClientRenegotiate);
ret = HITLS_CFG_SetClientRenegotiateSupport(outCfg, inCtxCfg->allowClientRenegotiate);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetClientRenegotiateSupport ERROR");
#endif
#ifdef HITLS_TLS_FEATURE_CERT_MODE
// Whether to enable dual-ended verification
LOG_DEBUG("HiTLS Set Support Client Verify is %d", inCtxCfg->isSupportClientVerify);
ret = HITLS_CFG_SetClientVerifySupport(outCfg, inCtxCfg->isSupportClientVerify);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetClientVerifySupport ERROR");
LOG_DEBUG("HiTLS Set readAhead is %d", inCtxCfg->readAhead);
ret = HITLS_CFG_SetReadAhead(outCfg, inCtxCfg->readAhead);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetReadAhead ERROR");
// Indicates whether to allow empty certificate list on the client.
LOG_DEBUG("HiTLS Set Support Not Client Cert is %d", inCtxCfg->isSupportNoClientCert);
ret = HITLS_CFG_SetNoClientCertSupport(outCfg, inCtxCfg->isSupportNoClientCert);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetNoClientCertSupport ERROR");
#endif
#ifdef HITLS_TLS_FEATURE_PHA
// Whether to enable pha
LOG_DEBUG("HiTLS Set Support pha is %d", inCtxCfg->isSupportPostHandshakeAuth);
ret = HITLS_CFG_SetPostHandshakeAuthSupport(outCfg, inCtxCfg->isSupportPostHandshakeAuth);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetPostHandshakeAuth ERROR");
#endif
// Indicates whether extended master keys are supported.
LOG_DEBUG("HiTLS Set Support Extend Master Secret is %d", inCtxCfg->isSupportExtendMasterSecret);
ret = HITLS_CFG_SetExtenedMasterSecretSupport(outCfg, inCtxCfg->isSupportExtendMasterSecret);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetExtenedMasterSecretSupport ERROR");
#ifdef HITLS_TLS_CONFIG_KEY_USAGE
// Support CloseCheckKeyUsage
LOG_DEBUG("HiTLS Set CloseCheckKeyUsage is false");
ret = HITLS_CFG_SetCheckKeyUsage(outCfg, inCtxCfg->needCheckKeyUsage);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetCheckKeyUsage ERROR");
#endif
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
// Indicates whether to support sessionTicket.
LOG_DEBUG("HiTLS Set Support SessionTicket is %d", inCtxCfg->isSupportSessionTicket);
ret = HITLS_CFG_SetSessionTicketSupport(outCfg, inCtxCfg->isSupportSessionTicket);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetSessionTicketSupport ERROR");
#endif
#ifdef HITLS_TLS_SUITE_CIPHER_CBC
// Whether encrypt-then-mac is supported
LOG_DEBUG("HiTLS Set Support EncryptThenMac is %d", inCtxCfg->isEncryptThenMac);
ret = HITLS_CFG_SetEncryptThenMac(outCfg, (uint32_t)inCtxCfg->isEncryptThenMac);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetEncryptThenMac ERROR");
#endif
// ECC Point Format Configuration for Asymmetric Algorithms
if (strncmp("NULL", inCtxCfg->pointFormats, strlen(inCtxCfg->pointFormats)) != 0) {
LOG_DEBUG("HiTLS Set PoinFormats is %s", inCtxCfg->pointFormats);
int configListSize = sizeof(g_eccFormatList) / sizeof(g_eccFormatList[0]);
ret = HitlsSetConfig(g_eccFormatList, configListSize, outCfg, inCtxCfg->pointFormats, POINTFORMAT);
ASSERT_RETURN(ret == SUCCESS, "ECC Format ERROR");
}
// Loading cipher suites
if (strncmp("NULL", inCtxCfg->cipherSuites, strlen(inCtxCfg->cipherSuites)) != 0) {
LOG_DEBUG("HiTLS Set CipherSuites is %s", inCtxCfg->cipherSuites);
int configListSize = sizeof(g_cipherSuiteList) / sizeof(g_cipherSuiteList[0]);
ret = HitlsSetConfig(g_cipherSuiteList, configListSize, outCfg, inCtxCfg->cipherSuites, CIPHER);
ASSERT_RETURN(ret == SUCCESS, "Hitls Set Cipher ERROR");
}
// set groups
if (strncmp("NULL", inCtxCfg->groups, strlen(inCtxCfg->groups)) != 0) {
LOG_DEBUG("HiTLS Set Groups is %s", inCtxCfg->groups);
int configListSize = sizeof(g_groupList) / sizeof(g_groupList[0]);
ret = HitlsSetConfig(g_groupList, configListSize, outCfg, inCtxCfg->groups, GROUPS);
ASSERT_RETURN(ret == SUCCESS, "Hitls Set Group ERROR");
}
// signature algorithm
if (strncmp("NULL", inCtxCfg->signAlgorithms, strlen(inCtxCfg->signAlgorithms)) != 0) {
LOG_DEBUG("HiTLS Set SignAlgorithms is %s", inCtxCfg->signAlgorithms);
int configListSize = sizeof(g_signatureList) / sizeof(g_signatureList[0]);
ret = HitlsSetConfig(g_signatureList, configListSize, outCfg, inCtxCfg->signAlgorithms, SIGNATURE);
ASSERT_RETURN(ret == SUCCESS, "Hitls Set Signature ERROR");
}
#ifdef HITLS_TLS_FEATURE_SNI
// sni
if (strncmp("NULL", inCtxCfg->serverName, strlen(inCtxCfg->serverName)) != 0) {
LOG_DEBUG("HiTLS Set ServerName is %s", inCtxCfg->serverName);
ret = HITLS_CFG_SetServerName(outCfg, (uint8_t *)inCtxCfg->serverName, strlen(inCtxCfg->serverName));
ASSERT_RETURN(ret == SUCCESS, "Hitls Set ServerName ERROR");
}
// Register the server_name function callback.
if (strncmp("NULL", inCtxCfg->sniDealCb, strlen(inCtxCfg->sniDealCb)) != 0) {
LOG_DEBUG("HiTLS Set server_name callback is %s", inCtxCfg->sniDealCb);
ret = HITLS_CFG_SetServerNameCb(outCfg, GetExtensionCb(inCtxCfg->sniDealCb));
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetServerNameCb Fail");
}
// Register values related to server_name.
if (strncmp("NULL", inCtxCfg->sniArg, strlen(inCtxCfg->sniArg)) != 0) {
LOG_DEBUG("HiTLS Set sniArg");
ret = HITLS_CFG_SetServerNameArg(outCfg, GetExampleData(inCtxCfg->sniArg));
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetServerNameArg Fail");
}
#endif
#ifdef HITLS_TLS_FEATURE_ALPN
// alpn
if (strncmp("NULL", inCtxCfg->alpnList, strlen(inCtxCfg->alpnList)) != 0) {
LOG_DEBUG("HiTLS Set alpnList is %s", inCtxCfg->alpnList);
ret = HITLS_CFG_SetAlpnProtos(outCfg, (const uint8_t *)inCtxCfg->alpnList, strlen(inCtxCfg->alpnList));
ASSERT_RETURN(ret == SUCCESS, "Hitls Set alpnList ERROR");
}
// Sets the ALPN selection callback on the server.
if (strncmp("NULL", inCtxCfg->alpnSelectCb, strlen(inCtxCfg->alpnSelectCb)) != 0) {
LOG_DEBUG("HiTLS Set ALPN callback is %s", inCtxCfg->alpnSelectCb);
ret = HITLS_CFG_SetAlpnProtosSelectCb(
outCfg, GetExtensionCb(inCtxCfg->alpnSelectCb), GetExampleData(inCtxCfg->alpnUserData));
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetAlpnProtosSelectCb Fail");
}
#endif
// Loading Certificates
ret = HiTLS_X509_LoadCertAndKey(outCfg, inCtxCfg->caCert, inCtxCfg->chainCert,
inCtxCfg->eeCert, inCtxCfg->signCert, inCtxCfg->privKey, inCtxCfg->signPrivKey);
ASSERT_RETURN(ret == SUCCESS, "Load cert Fail");
#ifdef HITLS_TLS_FEATURE_PSK
if (strncmp("NULL", inCtxCfg->psk, strlen(inCtxCfg->psk)) != 0) {
ret = ExampleSetPsk(inCtxCfg->psk);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetPskClientCallback Fail");
ret = HITLS_CFG_SetPskClientCallback(outCfg, ExampleClientCb);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetPskClientCallback Fail");
ret = HITLS_CFG_SetPskServerCallback(outCfg, ExampleServerCb);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetPskServerCallback Fail");
}
#endif
#if defined(HITLS_TLS_FEATURE_SESSION_TICKET)
if (strncmp("NULL", inCtxCfg->ticketKeyCb, strlen(inCtxCfg->ticketKeyCb)) != 0) {
LOG_DEBUG("HiTLS Set Ticker key callback is %s", inCtxCfg->ticketKeyCb);
ret = HITLS_CFG_SetTicketKeyCallback(outCfg, GetTicketKeyCb(inCtxCfg->ticketKeyCb));
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetTicketKeyCallback Fail");
}
#endif
#ifdef HITLS_TLS_FEATURE_INDICATOR
// Load link setup callback
if (inCtxCfg->infoCb != NULL) {
LOG_DEBUG("HiTLS Set info callback");
ret = HITLS_CFG_SetInfoCb(outCfg, inCtxCfg->infoCb);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetInfoCb Fail");
}
if (inCtxCfg->msgCb != NULL) {
LOG_DEBUG("HiTLS Set msg callback");
ret = HITLS_CFG_SetMsgCb(outCfg, inCtxCfg->msgCb);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetMsgCb Fail");
}
if (inCtxCfg->msgArg != NULL) {
LOG_DEBUG("HiTLS Set msgArg");
ret = HITLS_CFG_SetMsgCbArg(outCfg, inCtxCfg->msgArg);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetMsgCbArg Fail");
}
#ifdef HITLS_TLS_FEATURE_CERT_CB
if (inCtxCfg->certCb != NULL && inCtxCfg->certArg != NULL) {
LOG_DEBUG("HiTLS Set cert callback");
ret = HITLS_CFG_SetCertCb(outCfg, inCtxCfg->certCb, inCtxCfg->certArg);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetCertCb Fail");
}
#endif
#ifdef HITLS_TLS_FEATURE_CLIENT_HELLO_CB
if (inCtxCfg->clientHelloCb != NULL && inCtxCfg->clientHelloArg != NULL) {
LOG_DEBUG("HiTLS Set clientHello callback");
ret = HITLS_CFG_SetClientHelloCb(outCfg, inCtxCfg->clientHelloCb, inCtxCfg->clientHelloArg);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetClientHelloCb Fail");
}
#endif
#endif
#ifdef HITLS_TLS_FEATURE_FLIGHT
// Sets whether to enable the function of sending handshake messages by flight.
LOG_DEBUG("HiTLS Set Support isFlightTransmitEnable is %d", inCtxCfg->isFlightTransmitEnable);
ret = HITLS_CFG_SetFlightTransmitSwitch(outCfg, inCtxCfg->isFlightTransmitEnable);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetFlightTransmitSwitch ERROR");
#endif
#ifdef HITLS_TLS_FEATURE_SECURITY
// Setting the security level
LOG_DEBUG("HiTLS Set SecurityLevel is %d", inCtxCfg->securitylevel);
ret = HITLS_CFG_SetSecurityLevel(outCfg, inCtxCfg->securitylevel);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetSecurityLevel ERROR");
#endif
#ifdef HITLS_TLS_CONFIG_MANUAL_DH
// Indicates whether the DH key length can be followed by the certificate.
LOG_DEBUG("HiTLS Set Support DHAuto is %d", inCtxCfg->isSupportDhAuto);
ret = HITLS_CFG_SetDhAutoSupport(outCfg, inCtxCfg->isSupportDhAuto);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetDhAutoSupport ERROR");
#endif
#ifdef HITLS_TLS_PROTO_TLS13
// TLS1.3 key exchange mode
if (outCfg->maxVersion == HITLS_VERSION_TLS13) {
LOG_DEBUG("HiTLS Set keyExchMode is %u", inCtxCfg->keyExchMode);
ret = HITLS_CFG_SetKeyExchMode(outCfg, inCtxCfg->keyExchMode);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetKeyExchMode ERROR");
}
#endif
#ifdef HITLS_TLS_FEATURE_CERT_MODE
// Set whether to enable isSupportVerifyNone;
LOG_DEBUG("HiTLS Set Support pha is %d", inCtxCfg->isSupportVerifyNone);
ret = HITLS_CFG_SetVerifyNoneSupport(outCfg, inCtxCfg->isSupportVerifyNone);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetVerifyNoneSupport ERROR");
#endif
LOG_DEBUG("HiTLS Set Empty Record Number is %u", inCtxCfg->emptyRecordsNum);
ret = HITLS_CFG_SetEmptyRecordsNum(outCfg, inCtxCfg->emptyRecordsNum);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetEmptyRecordsNum ERROR");
#ifdef HITLS_TLS_FEATURE_MODE
// HiTLS Set ModeSupport
LOG_DEBUG("HiTLS Set ModeSupport is %u", inCtxCfg->modeSupport);
ret = HITLS_CFG_SetModeSupport(outCfg, inCtxCfg->modeSupport);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetModeSupport ERROR");
#endif
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
LOG_DEBUG("HiTLS Set allow Legacy Renegotiate is %d", inCtxCfg->allowLegacyRenegotiate);
ret = HITLS_CFG_SetLegacyRenegotiateSupport(outCfg, inCtxCfg->allowLegacyRenegotiate);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetLegacyRenegotiateSupport ERROR");
#endif /* defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12) */
#ifdef HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES
if (inCtxCfg->caList != NULL) {
LOG_DEBUG("HiTLS Set caList");
ret = HITLS_CFG_SetCAList(outCfg, inCtxCfg->caList);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetCAList Fail");
}
#endif /* HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES */
#ifdef HITLS_TLS_PROTO_TLS13
// Whether to support middlebox compatibility.
LOG_DEBUG("HiTLS Set Support middlebox compatibility is %d", inCtxCfg->isMiddleBoxCompat);
ret = HITLS_CFG_SetMiddleBoxCompat(outCfg, (uint32_t)inCtxCfg->isMiddleBoxCompat);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetMiddleBoxCompat ERROR");
#endif
#ifdef HITLS_TLS_MAINTAIN_KEYLOG
// Set the keylogcb callback function on the server.
if (strncmp("NULL", inCtxCfg->keyLogCb, strlen(inCtxCfg->keyLogCb)) != 0) {
LOG_DEBUG("HiTLS Set key log callback is %s", inCtxCfg->keyLogCb);
ret = HITLS_CFG_SetKeyLogCb(outCfg, GetExtensionCb(inCtxCfg->keyLogCb));
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetKeyLogCb Fail");
}
// support exporting keys through environment variables
if (strncmp("NULL", inCtxCfg->keyLogCb, strlen(inCtxCfg->keyLogCb)) == 0) {
ret = HITLS_CFG_SetKeyLogCb(outCfg, KetLogPrint);
ASSERT_RETURN(ret == SUCCESS, "HITLS_CFG_SetKeyLogCb Fail");
}
#endif
return SUCCESS;
}
void *HitlsNewSsl(void *ctx)
{
return HITLS_New(ctx);
}
void HitlsFreeSsl(void *ssl)
{
HITLS_Ctx *ctx = (HITLS_Ctx *)ssl;
#ifdef HITLS_TLS_FEATURE_PROVIDER
HITLS_Lib_Ctx *libCtx = LIBCTX_FROM_CTX(ctx);
HITLS_Free(ctx);
CRYPT_EAL_LibCtxFree(libCtx);
#else
HITLS_Free(ctx);
#endif
}
const BSL_UIO_Method *GetDefaultMethod(HILT_TransportType type)
{
switch (type) {
#ifdef HITLS_BSL_UIO_TCP
case TCP:
return TcpGetDefaultMethod();
#endif
#ifdef HITLS_BSL_UIO_UDP
case UDP:
return UdpGetDefaultMethod();
#endif
default:
break;
}
return NULL;
}
int HitlsSetSsl(void *ssl, HLT_Ssl_Config *sslConfig)
{
int ret;
if (sslConfig->SupportType == SERVER_CTX_SET_TRUE) {
HITLS_SetCipherServerPreference((HITLS_Ctx *)ssl, true);
}
if (sslConfig->SupportType == SERVER_CTX_SET_FALSE) {
HITLS_SetCipherServerPreference((HITLS_Ctx *)ssl, false);
}
HILT_TransportType type = (sslConfig->connType == NONE_TYPE) ? SCTP : sslConfig->connType;
BSL_UIO *uio = BSL_UIO_New(GetDefaultMethod(type));
ASSERT_RETURN(uio != NULL, "HITLS_SetUio Fail");
ret = BSL_UIO_Ctrl(uio, BSL_UIO_SET_FD, (int32_t)sizeof(sslConfig->sockFd), &sslConfig->sockFd);
if (ret != SUCCESS) {
LOG_ERROR("BSL_UIO_SET_FD Fail");
BSL_UIO_Free(uio);
return ERROR;
}
if (BSL_UIO_GetTransportType(uio) == BSL_UIO_UDP) {
BSL_SAL_SockAddr serverAddr = NULL;
ret = SAL_SockAddrNew(&serverAddr);
if (ret != BSL_SUCCESS) {
LOG_ERROR("SAL_SockAddrNew failed\n");
BSL_UIO_Free(uio);
return ret;
}
int32_t addrlen = (int32_t)SAL_SockAddrSize(serverAddr);
if (getpeername(sslConfig->sockFd, (struct sockaddr *)serverAddr, (socklen_t *)&addrlen) == 0) {
ret = BSL_UIO_Ctrl(uio, BSL_UIO_UDP_SET_CONNECTED, addrlen, serverAddr);
if (ret != HITLS_SUCCESS) {
LOG_ERROR("BSL_UIO_SET_PEER_IP_ADDR failed %d\n", addrlen);
SAL_SockAddrFree(serverAddr);
BSL_UIO_Free(uio);
return ERROR;
}
}
SAL_SockAddrFree(serverAddr);
}
BSL_UIO_SetInit(uio, 1);
ret = HITLS_SetUio(ssl, uio);
if (ret != SUCCESS) {
LOG_ERROR("HITLS_SetUio Fail");
BSL_UIO_Free(uio);
return ERROR;
}
// Release the UIO to prevent memory leakage.
BSL_UIO_Free(uio);
return SUCCESS;
}
void *HitlsAccept(void *ssl)
{
static int ret;
int timeout = TIME_OUT_SEC;
if (getenv("SSL_TIMEOUT") != NULL) {
timeout = atoi(getenv("SSL_TIMEOUT"));
}
time_t start = time(NULL);
LOG_DEBUG("HiTLS Tls Accept Ing...");
do {
ret = HITLS_Accept(ssl);
usleep(1000); // stay 1000us
} while ((ret == HITLS_REC_NORMAL_RECV_BUF_EMPTY || ret == HITLS_REC_NORMAL_IO_BUSY ||
ret == HITLS_CALLBACK_CLIENT_HELLO_RETRY || ret == HITLS_CALLBACK_CERT_RETRY) &&
((time(NULL) - start < timeout))); // usleep(1000) after each attemp.
if (ret != SUCCESS) {
LOG_ERROR("HITLS_Accept Error is %d", ret);
} else {
LOG_DEBUG("HiTLS Tls Accept Success");
}
return &ret;
}
int HitlsConnect(void *ssl)
{
int ret;
int timeout = TIME_OUT_SEC;
if (getenv("SSL_TIMEOUT") != NULL) {
timeout = atoi(getenv("SSL_TIMEOUT"));
}
time_t start = time(NULL);
LOG_DEBUG("HiTLS Tls Connect Ing...");
do {
ret = HITLS_Connect(ssl);
usleep(1000); // stay 1000us
} while ((ret == HITLS_REC_NORMAL_RECV_BUF_EMPTY || ret == HITLS_REC_NORMAL_IO_BUSY ||
ret == HITLS_CALLBACK_CERT_RETRY) &&
((time(NULL) - start < timeout))); // usleep(1000) after each attemp.
if (ret != SUCCESS) {
LOG_ERROR("HITLS_Connect Error is %d", ret);
} else {
LOG_DEBUG("HiTLS Tls Connect Success");
}
return ret;
}
int HitlsWrite(void *ssl, uint8_t *data, uint32_t dataLen)
{
int ret;
int timeout = 4;
if (getenv("SSL_TIMEOUT") != NULL) {
timeout = atoi(getenv("SSL_TIMEOUT"));
}
time_t start = time(NULL);
LOG_DEBUG("HiTLS Write Ing...");
uint32_t len = 0;
do {
ret = HITLS_Write(ssl, data, dataLen, &len);
usleep(1000); // stay 1000us
} while ((ret == HITLS_REC_NORMAL_RECV_BUF_EMPTY ||
ret == HITLS_REC_NORMAL_IO_BUSY) &&
(time(NULL) - start < timeout)); // A maximum of 4000 calls
LOG_DEBUG("HiTLS Write Result is %d", ret);
return ret;
}
int HitlsRead(void *ssl, uint8_t *data, uint32_t bufSize, uint32_t *readLen)
{
int ret;
int timeout = 8;
if (getenv("SSL_TIMEOUT") != NULL) {
timeout = atoi(getenv("SSL_TIMEOUT"));
}
time_t start = time(NULL);
LOG_DEBUG("HiTLS Read Ing...");
do {
ret = HITLS_Read(ssl, data, bufSize, readLen);
usleep(1000); // stay 1000us
} while ((ret == HITLS_REC_NORMAL_RECV_BUF_EMPTY || ret == HITLS_REC_NORMAL_IO_BUSY ||
ret == HITLS_CALLBACK_CERT_RETRY) &&
((time(NULL) - start < timeout))); // A maximum of 8000 calls
LOG_DEBUG("HiTLS Read Result is %d", ret);
return ret;
}
int HitlsClose(void *ctx)
{
return HITLS_Close(ctx);
}
int HitlsRenegotiate(void *ssl)
{
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
return HITLS_Renegotiate(ssl);
#else
(void)ssl;
return -1;
#endif
}
int HitlsSetMtu(void *ssl, uint16_t mtu)
{
#ifdef HITLS_TLS_PROTO_DTLS12
return HITLS_SetMtu(ssl, mtu);
#else
(void)ssl;
(void)mtu;
return -1;
#endif
}
int HitlsSetSession(void *ssl, void *session)
{
#ifdef HITLS_TLS_FEATURE_SESSION
return HITLS_SetSession(ssl, session);
#else
(void)ssl;
(void)session;
return -1;
#endif
}
int HitlsSessionReused(void *ssl)
{
uint8_t isReused = 0;
(void)ssl;
#ifdef HITLS_TLS_FEATURE_SESSION
int32_t ret;
ret = HITLS_IsSessionReused(ssl, &isReused);
if (ret != HITLS_SUCCESS) {
return 0;
}
#endif
return (int)isReused;
}
void *HitlsGet1Session(void *ssl)
{
#ifdef HITLS_TLS_FEATURE_SESSION
return HITLS_GetDupSession(ssl);
#else
(void)ssl;
return NULL;
#endif
}
int HitlsSessionHasTicket(void *session)
{
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
return (HITLS_SESS_HasTicket(session) ? 1 : 0);
#else
(void)session;
return 0;
#endif
}
int HitlsSessionIsResumable(void *session)
{
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
return (HITLS_SESS_IsResumable(session) ? 1 : 0);
#else
(void)session;
return 0;
#endif
}
void HitlsFreeSession(void *session)
{
#ifdef HITLS_TLS_FEATURE_SESSION
HITLS_SESS_Free(session);
#else
(void)session;
#endif
}
int HitlsGetErrorCode(void *ssl)
{
return HITLS_GetErrorCode(ssl);
}
|
2301_79861745/bench_create
|
testcode/framework/tls/rpc/src/hitls_func.c
|
C
|
unknown
| 42,340
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
#include "securec.h"
#include "logger.h"
#include "process.h"
#include "handle_cmd.h"
#include "hlt.h"
#include "tls_res.h"
#include "common_func.h"
#include "hitls_func.h"
#include "sctp_channel.h"
#include "tcp_channel.h"
#include "udp_channel.h"
#include "socket_common.h"
#include "cert_callback.h"
#include "sctp_channel.h"
#include "frame_tls.h"
#define DOMAIN_PATH_LEN (128)
#define CMD_MAX_LEN 1024
#define SUCCESS 0
#define ERROR (-1)
int g_acceptFd;
void* HLT_TlsNewCtx(TLS_VERSION tlsVersion)
{
int ret;
void *ctx = NULL;
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
ctx = HitlsNewCtx(tlsVersion);
break;
default:
ctx = NULL;
}
if ((process->remoteFlag == 0) && (ctx != NULL)) {
// If the value is LocalProcess, insert it to the CTX linked list.
ret = InsertCtxToList(ctx);
if (ret == ERROR) {
LOG_ERROR("InsertCtxToList ERROR");
return NULL;
}
}
return ctx;
}
#ifdef HITLS_TLS_FEATURE_PROVIDER
void* HLT_TlsProviderNewCtx(char *providerPath, char (*providerNames)[MAX_PROVIDER_NAME_LEN], int *providerLibFmts,
int providerCnt, char *attrName, TLS_VERSION tlsVersion)
{
int ret;
void *ctx = NULL;
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
ctx = HitlsProviderNewCtx(providerPath, providerNames, providerLibFmts, providerCnt,
attrName, tlsVersion);
break;
default:
ctx = NULL;
}
if ((process->remoteFlag == 0) && (ctx != NULL)) {
// If the value is LocalProcess, insert it to the CTX linked list.
ret = InsertCtxToList(ctx);
if (ret == ERROR) {
LOG_ERROR("InsertCtxToList ERROR");
return NULL;
}
}
return ctx;
}
#endif
void* HLT_TlsNewSsl(void *ctx)
{
int ret;
void *ssl = NULL;
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
LOG_DEBUG("Hitls New Ssl");
ssl = HitlsNewSsl(ctx);
break;
default:
ssl = NULL;
}
if ((process->remoteFlag == 0) && (ssl != NULL)) {
// If the value is LocalProcess, insert it to the SSL linked list.
ret = InsertSslToList(ctx, ssl);
if (ret == ERROR) {
LOG_ERROR("InsertSslToList ERROR");
return NULL;
}
}
return ssl;
}
int HLT_TlsSetCtx(void *ctx, HLT_Ctx_Config *ctxConfig)
{
int ret;
Process *process = GetProcess();
switch (process->tlsType) {
case HITLS:
LOG_DEBUG("HiTLS Set Ctx's Config");
ret = HitlsSetCtx(ctx, ctxConfig);
break;
default:
ret = ERROR;
}
return ret;
}
int HLT_TlsSetSsl(void *ssl, HLT_Ssl_Config *sslConfig)
{
int ret = ERROR;
Process *process = GetProcess();
switch (process->tlsType) {
case HITLS:
LOG_DEBUG("HiTLS Set Ssl's Config");
ret = HitlsSetSsl(ssl, sslConfig);
break;
default:
LOG_DEBUG("Unknown tls type");
break;
}
return ret;
}
// listen non-blocking interface
unsigned long int HLT_TlsListen(void *ssl)
{
(void)ssl;
Process *process = GetProcess();
switch (process->tlsType) {
case HITLS : {
return ERROR; // Hitls does not support the listen function.
}
default:
return ERROR;
}
}
// listen blocking interface
int HLT_TlsListenBlock(void* ssl)
{
(void)ssl;
Process *process = GetProcess();
switch (process->tlsType) {
case HITLS : return ERROR; // Hitls does not support the listen function.
default:
return ERROR;
}
}
// Non-blocking interface
unsigned long int HLT_TlsAccept(void *ssl)
{
(void)ssl;
unsigned long int ret = ERROR;
Process *process = GetProcess();
pthread_t t_id;
switch (process->tlsType) {
case HITLS :
ret = pthread_create(&t_id, NULL, (void*)HitlsAccept, (void*)ssl);
break;
default:
break;
}
if (ret != 0) {
return ret;
}
return t_id;
}
int HLT_TlsAcceptBlock(void *ssl)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
return *(int *)HitlsAccept(ssl);
default:
return ERROR;
}
}
int HLT_GetTlsAcceptResultFromId(unsigned long int threadId)
{
pthread_join(threadId, NULL);
return SUCCESS;
}
int HLT_GetTlsAcceptResult(HLT_Tls_Res* tlsRes)
{
static int ret;
if (tlsRes->acceptId <= 0) {
LOG_ERROR("This Res Has Not acceptId");
return ERROR;
}
if (tlsRes->ctx == NULL) {
// Indicates that the remote process accepts the request.
ret = HLT_RpcGetTlsAcceptResult(tlsRes->acceptId);
} else {
// Indicates that the local process accepts the request.
int *tmp = NULL;
pthread_join(tlsRes->acceptId, (void**)&tmp);
if (tmp == NULL) {
return ERROR;
}
ret = *tmp;
tlsRes->acceptId = 0;
return ret;
}
tlsRes->acceptId = 0;
return ret;
}
int HLT_TlsConnect(void *ssl)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
return HitlsConnect(ssl);
default:
return ERROR;
}
}
int HLT_TlsWrite(void *ssl, uint8_t *data, uint32_t dataLen)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS : {
LOG_DEBUG("Hitls Write Ing...");
return HitlsWrite(ssl, data, dataLen);
}
default:
return ERROR;
}
}
int HLT_TlsRead(void *ssl, uint8_t *data, uint32_t bufSize, uint32_t *readLen)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS: {
LOG_DEBUG("Hitls Read Ing...");
return HitlsRead(ssl, data, bufSize, readLen);
}
default:
return ERROR;
}
}
int HLT_TlsRenegotiate(void *ssl)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
return HitlsRenegotiate(ssl);
default:
return ERROR;
}
}
int HLT_TlsVerifyClientPostHandshake(void *ssl)
{
#ifdef HITLS_TLS_FEATURE_PHA
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS: return HITLS_VerifyClientPostHandshake(ssl);
default:
return ERROR;
}
#else
(void)ssl;
#endif
return ERROR;
}
int HLT_TlsClose(void *ssl)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS: return HitlsClose(ssl);
default:
return ERROR;
}
}
int HLT_TlsSetSession(void *ssl, void *session)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS: return (HitlsSetSession(ssl, session) == 0) ? 1 : 0;
default:
return ERROR;
}
}
int HLT_TlsSessionReused(void *ssl)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
return HitlsSessionReused(ssl);
default:
return ERROR;
}
}
void *HLT_TlsGet1Session(void *ssl)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
return HitlsGet1Session(ssl);
default:
return NULL;
}
}
int32_t HLT_SetSessionCacheMode(HLT_Ctx_Config* config, HITLS_SESS_CACHE_MODE mode)
{
config->setSessionCache = mode;
return SUCCESS;
}
int32_t HLT_SetSessionTicketSupport(HLT_Ctx_Config* config, bool issupport)
{
config->isSupportSessionTicket = issupport;
return SUCCESS;
}
int HLT_TlsSessionHasTicket(void *session)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
return HitlsSessionHasTicket(session);
default:
return ERROR;
}
}
int HLT_TlsSessionIsResumable(void *session)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
return HitlsSessionIsResumable(session);
default:
return ERROR;
}
}
void HLT_TlsFreeSession(void *session)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
HitlsFreeSession(session);
break;
default:
break;
}
}
int RunDataChannelBind(void *param)
{
int sockFd = -1;
LOG_DEBUG("RunDataChannelBind Ing...\n");
DataChannelParam *channelParam = (DataChannelParam*)param;
switch (channelParam->type) {
#ifdef HITLS_BSL_UIO_TCP
case TCP: sockFd = TcpBind(channelParam->port); break;
#endif
#ifdef HITLS_BSL_UIO_UDP
case UDP: sockFd = UdpBind(channelParam->port); break;
#endif
default:
return ERROR;
}
struct sockaddr_in add;
socklen_t len = sizeof(add);
getsockname(sockFd, (struct sockaddr *)&add, &len);
channelParam->port = ntohs(add.sin_port);
channelParam->bindFd = sockFd;
g_acceptFd = sockFd;
return sockFd;
}
int RunDataChannelAccept(void *param)
{
int sockFd = -1;
LOG_DEBUG("RunDataChannelAccept Ing...\n");
DataChannelParam *channelParam = (DataChannelParam *)param;
switch (channelParam->type) {
#ifdef HITLS_BSL_UIO_TCP
case TCP:
sockFd = TcpAccept(channelParam->ip, channelParam->bindFd, channelParam->isBlock, true);
break;
#endif
#ifdef HITLS_BSL_UIO_UDP
case UDP:
sockFd = UdpAccept(channelParam->ip, channelParam->bindFd, channelParam->isBlock, false);
#endif
break;
default:
return ERROR;
}
g_acceptFd = sockFd;
return sockFd;
}
pthread_t HLT_DataChannelAccept(DataChannelParam *channelParam)
{
pthread_t t_id;
if (pthread_create(&t_id, NULL, (void*)RunDataChannelAccept, (void*)channelParam) != 0) {
LOG_ERROR("Create Thread HLT_RpcDataChannelAccept Error ...");
return 0;
}
return t_id;
}
int HLT_DataChannelBind(DataChannelParam *channelParam)
{
return RunDataChannelBind(channelParam);
}
int HLT_DataChannelConnect(DataChannelParam *dstChannelParam)
{
switch (dstChannelParam->type) {
#ifdef HITLS_BSL_UIO_TCP
case TCP: return TcpConnect(dstChannelParam->ip, dstChannelParam->port);
#endif
#ifdef HITLS_BSL_UIO_UDP
case UDP: return UdpConnect(dstChannelParam->ip, dstChannelParam->port);
#endif
default:
return ERROR;
}
return ERROR;
}
int HLT_GetAcceptFd(pthread_t threadId)
{
pthread_join(threadId, NULL);
return g_acceptFd;
}
HLT_FD HLT_CreateDataChannel(HLT_Process *process1, HLT_Process *process2, DataChannelParam channelParam)
{
int acceptId;
int bindFd;
unsigned long int pthreadId;
HLT_FD sockFd;
char *userPort = getenv("FIXED_PORT");
if (userPort == NULL) {
channelParam.port = 0; // The system randomly allocates available ports.
}
if (process2->remoteFlag == 1) {
bindFd = HLT_RpcDataChannelBind(process2, &channelParam);
} else {
bindFd = HLT_DataChannelBind(&channelParam);
}
channelParam.bindFd = bindFd;
// Start Accept again.
if (process2->remoteFlag == 1) {
acceptId = HLT_RpcDataChannelAccept(process2, &channelParam);
} else {
pthreadId = HLT_DataChannelAccept(&channelParam);
}
// In Connect
if (process1->remoteFlag == 1) {
sockFd.srcFd = HLT_RpcDataChannelConnect(process1, &channelParam);
} else {
sockFd.srcFd = HLT_DataChannelConnect(&channelParam);
}
if (process2->remoteFlag == 1) {
if (sockFd.srcFd > 0) {
// Indicates that the CONNECT is successful.
sockFd.peerFd = HLT_RpcGetAcceptFd(acceptId);
} else {
sockFd.peerFd = -1;
}
} else {
if (sockFd.srcFd > 0) {
// Indicates that the CONNECT is successful.
sockFd.peerFd = HLT_GetAcceptFd(pthreadId);
sockFd.sockAddr = channelParam.sockAddr;
sockFd.connPort = channelParam.port;
} else {
// If the SCTP link fails to be established, delete the thread to avoid congestion.
pthread_cancel(pthreadId);
pthread_join(pthreadId, NULL);
}
}
return sockFd;
}
void HLT_CloseFd(int fd, int linkType)
{
switch (linkType) {
#ifdef HITLS_BSL_UIO_TCP
case TCP: TcpClose(fd); break;
#endif
#ifdef HITLS_BSL_UIO_UDP
case UDP: UdpClose(fd); break;
#endif
default:
/* Unknown fd type */
break;
}
}
HLT_Ctx_Config* HLT_NewCtxConfigTLCP(char *setFile, const char *key, bool isClient)
{
(void)setFile;
Process *localProcess;
HLT_Ctx_Config *ctxConfig = (HLT_Ctx_Config*)calloc(sizeof(HLT_Ctx_Config), 1u);
if (ctxConfig == NULL) {
return NULL;
}
ctxConfig->isSupportRenegotiation = false;
ctxConfig->allowClientRenegotiate = false;
ctxConfig->allowLegacyRenegotiate = false;
ctxConfig->isSupportClientVerify = false;
ctxConfig->isSupportNoClientCert = false;
ctxConfig->isSupportExtendMasterSecret = false;
ctxConfig->isClient = isClient;
ctxConfig->setSessionCache = 2;
HLT_SetGroups(ctxConfig, "NULL");
HLT_SetCipherSuites(ctxConfig, "NULL");
HLT_SetTls13CipherSuites(ctxConfig, "NULL");
HLT_SetSignature(ctxConfig, "NULL");
HLT_SetEcPointFormats(ctxConfig, "NULL");
HLT_SetPassword(ctxConfig, "NULL");
HLT_SetPsk(ctxConfig, "NULL");
HLT_SetTicketKeyCb(ctxConfig, "NULL");
if (strncmp("SERVER", key, strlen(key)) == 0) {
HLT_SetCertPath(ctxConfig, SM2_VERIFY_PATH, SM2_CHAIN_PATH, SM2_SERVER_ENC_CERT_PATH, SM2_SERVER_ENC_KEY_PATH,
SM2_SERVER_SIGN_CERT_PATH, SM2_SERVER_SIGN_KEY_PATH);
} else if (strncmp("CLIENT", key, strlen(key)) == 0) {
HLT_SetCertPath(ctxConfig, SM2_VERIFY_PATH, SM2_CHAIN_PATH, SM2_CLIENT_ENC_CERT_PATH, SM2_CLIENT_ENC_KEY_PATH,
SM2_CLIENT_SIGN_CERT_PATH, SM2_CLIENT_SIGN_KEY_PATH);
} else {
free(ctxConfig);
ctxConfig = NULL;
return NULL;
}
// Store CTX configuration resources and release them later.
localProcess = GetProcess();
localProcess->tlsResArray[localProcess->tlsResNum] = ctxConfig;
localProcess->tlsResNum++;
return ctxConfig;
}
HLT_Ctx_Config* HLT_NewCtxConfig(char *setFile, const char *key)
{
(void)setFile;
HLT_Ctx_Config *ctxConfig;
Process *localProcess;
ctxConfig = (HLT_Ctx_Config*)malloc(sizeof(HLT_Ctx_Config));
if (ctxConfig == NULL) {
return NULL;
}
(void)memset_s(ctxConfig, sizeof(HLT_Ctx_Config), 0, sizeof(HLT_Ctx_Config));
ctxConfig->needCheckKeyUsage = false;
ctxConfig->isSupportRenegotiation = false;
ctxConfig->allowClientRenegotiate = false;
ctxConfig->allowLegacyRenegotiate = false;
ctxConfig->isSupportClientVerify = false;
ctxConfig->isSupportNoClientCert = false;
ctxConfig->isSupportVerifyNone = false;
ctxConfig->isSupportPostHandshakeAuth = false;
ctxConfig->isSupportExtendMasterSecret = true;
ctxConfig->isSupportSessionTicket = false;
ctxConfig->isSupportDhAuto = true;
ctxConfig->isEncryptThenMac = true;
ctxConfig->isMiddleBoxCompat = true;
ctxConfig->keyExchMode = TLS13_KE_MODE_PSK_WITH_DHE;
ctxConfig->setSessionCache = HITLS_SESS_CACHE_SERVER;
ctxConfig->mtu = 0;
ctxConfig->infoCb = NULL;
ctxConfig->securitylevel = HITLS_SECURITY_LEVEL_ZERO;
ctxConfig->SupportType = 0;
ctxConfig->readAhead = 1;
ctxConfig->emptyRecordsNum = 32;
HLT_SetGroups(ctxConfig, "NULL");
HLT_SetCipherSuites(ctxConfig, "NULL");
HLT_SetTls13CipherSuites(ctxConfig, "NULL");
HLT_SetSignature(ctxConfig, "NULL");
HLT_SetEcPointFormats(ctxConfig, "HITLS_POINT_FORMAT_UNCOMPRESSED");
HLT_SetPassword(ctxConfig, "NULL");
HLT_SetPsk(ctxConfig, "NULL");
HLT_SetTicketKeyCb(ctxConfig, "NULL");
HLT_SetServerName(ctxConfig, "NULL");
HLT_SetServerNameCb(ctxConfig, "NULL");
HLT_SetServerNameArg(ctxConfig, "NULL");
HLT_SetAlpnProtos(ctxConfig, "NULL");
HLT_SetAlpnProtosSelectCb(ctxConfig, "NULL", "NULL");
if (strncmp("SERVER", key, strlen(key)) == 0) {
HLT_SetCertPath(ctxConfig, ECDSA_SHA256_CA_PATH,
ECDSA_SHA256_CHAIN_PATH, ECDSA_SHA256_EE_PATH1, ECDSA_SHA256_PRIV_PATH1, "NULL", "NULL");
} else if (strncmp("CLIENT", key, strlen(key)) == 0) {
HLT_SetCertPath(ctxConfig, ECDSA_SHA256_CA_PATH,
ECDSA_SHA256_CHAIN_PATH, ECDSA_SHA256_EE_PATH2, ECDSA_SHA256_PRIV_PATH2, "NULL", "NULL");
} else {
free(ctxConfig);
ctxConfig = NULL;
return NULL;
}
// Store CTX configuration resources and release them later.
localProcess = GetProcess();
localProcess->tlsResArray[localProcess->tlsResNum] = ctxConfig;
localProcess->tlsResNum++;
return ctxConfig;
}
HLT_Ssl_Config *HLT_NewSslConfig(char *setFile)
{
(void)setFile;
HLT_Ssl_Config *sslConfig;
Process *localProcess;
sslConfig = (HLT_Ssl_Config*)malloc(sizeof(HLT_Ssl_Config));
if (sslConfig == NULL) {
return NULL;
}
(void)memset_s(sslConfig, sizeof(HLT_Ssl_Config), 0, sizeof(HLT_Ssl_Config));
// Store SSL configuration resources and release them later.
localProcess = GetProcess();
localProcess->tlsResArray[localProcess->tlsResNum] = sslConfig;
localProcess->tlsResNum++;
return sslConfig;
}
int HLT_LibraryInit(TLS_TYPE tlsType)
{
switch (tlsType) {
case HITLS: return HitlsInit(); break;
default:
/* Unknown type */
break;
}
return ERROR;
}
int HLT_TlsRegCallback(TlsCallbackType type)
{
switch (type) {
case HITLS_CALLBACK_DEFAULT:
FRAME_Init();
break;
default:
return SUCCESS;
}
return SUCCESS;
}
void HLT_FreeAllProcess(void)
{
int ret;
HLT_Tls_Res* tlsRes;
Process *remoteProcess;
Process *localProcess = GetProcess();
if (localProcess == NULL) {
return;
}
if (localProcess->remoteFlag != 0) {
LOG_ERROR("Only Local Process Can Call HLT_FreeAllProcess");
return;
}
// Clearing HLT_Tls_Res and Threads
for (int i = 0; i < localProcess->hltTlsResNum; i++) {
tlsRes = localProcess->hltTlsResArray[i];
alarm(60); // Avoid long waits
if ((tlsRes->acceptId > 0) && (tlsRes->ctx != NULL)) {
pthread_join(tlsRes->acceptId, NULL);
}
free(tlsRes);
}
// Sends a signal for the peer process to exit.
remoteProcess = GetProcessFromList();
while (remoteProcess != NULL) {
ret = HLT_RpcProcessExit(remoteProcess);
if (ret != SUCCESS) {
LOG_ERROR("HLT_RpcProcessExit Error");
}
free(remoteProcess);
remoteProcess = GetProcessFromList();
}
// Clearing Local Resources
// Clearing Ports
if (localProcess->connFd > 0) {
close(localProcess->connFd);
}
// Clear the TlsRes linked list.
FreeTlsResList();
// Clear CTX SSL configuration resources.
for (int i = 0; i < localProcess->tlsResNum; i++) {
free(localProcess->tlsResArray[i]);
}
// Clear the linked list of the remote process.
FreeProcessResList();
// Clear local control connection resources
FreeControlChannelRes();
// Clear local processes.
FreeProcess();
return;
}
int HLT_FreeResFromSsl(const void *ssl)
{
return FreeResFromSsl(ssl);
}
static int LocalProcessTlsInit(HLT_Process *process, TLS_VERSION tlsVersion,
HLT_Ctx_Config *ctxConfig, HLT_Ssl_Config *sslConfig, HLT_Tls_Res *tlsRes)
{
void *ctx, *ssl;
#ifdef HITLS_TLS_FEATURE_PROVIDER
ctx = HLT_TlsProviderNewCtx(ctxConfig->providerPath, ctxConfig->providerNames, ctxConfig->providerLibFmts,
ctxConfig->providerCnt, ctxConfig->attrName, tlsVersion);
#else
ctx = HLT_TlsNewCtx(tlsVersion);
#endif
if (ctx == NULL) {
LOG_ERROR("HLT_TlsNewCtx or HLT_TlsProviderNewCtx ERROR");
return ERROR;
}
if (HLT_TlsSetCtx(ctx, ctxConfig) != SUCCESS) {
LOG_ERROR("HLT_TlsSetCtx ERROR");
return ERROR;
}
ssl = HLT_TlsNewSsl(ctx);
if (ssl == NULL) {
LOG_ERROR("HLT_TlsNewSsl ERROR");
return ERROR;
}
// When FD is 0, the default configuration is used.
if (sslConfig->sockFd == 0) {
sslConfig->sockAddr = process->sockAddr;
sslConfig->sockFd = process->connFd;
sslConfig->connType = process->connType;
}
if (HLT_TlsSetSsl(ssl, sslConfig) != SUCCESS) {
LOG_ERROR("HLT_TlsSetSsl ERROR");
return ERROR;
}
if (ctxConfig->mtu > 0) {
if (HLT_TlsSetMtu(ssl, ctxConfig->mtu) != SUCCESS) {
LOG_ERROR("HLT_TlsSetMtu ERROR");
return ERROR;
}
}
tlsRes->ctx = ctx;
tlsRes->ssl = ssl;
tlsRes->ctxId = -1; // -1 indicates that the field is discarded.
tlsRes->sslId = -1; // -1 indicates that the field is discarded.
return SUCCESS;
}
static int RemoteProcessTlsInit(HLT_Process *process, TLS_VERSION tlsVersion,
HLT_Ctx_Config *ctxConfig, HLT_Ssl_Config *sslConfig, HLT_Tls_Res *tlsRes)
{
int ctxId;
int sslId;
#ifdef HITLS_TLS_FEATURE_PROVIDER
ctxId = HLT_RpcProviderTlsNewCtx(process, tlsVersion, ctxConfig->isClient, ctxConfig->providerPath,
ctxConfig->providerNames, ctxConfig->providerLibFmts, ctxConfig->providerCnt, ctxConfig->attrName);
#else
ctxId = HLT_RpcTlsNewCtx(process, tlsVersion, ctxConfig->isClient);
#endif
if (ctxId < 0) {
LOG_ERROR("HLT_RpcTlsNewCtx ERROR");
return ERROR;
}
if (HLT_RpcTlsSetCtx(process, ctxId, ctxConfig) != SUCCESS) {
LOG_ERROR("HLT_RpcTlsSetCtx ERROR");
return ERROR;
}
sslId = HLT_RpcTlsNewSsl(process, ctxId);
if (sslId < 0) {
LOG_ERROR("HLT_RpcTlsNewSsl ERROR");
return ERROR;
}
// When FD is 0, the default configuration is used.
if (sslConfig->sockFd == 0) {
sslConfig->connPort = process->connPort;
sslConfig->sockFd = process->connFd;
sslConfig->connType = process->connType;
}
if (HLT_RpcTlsSetSsl(process, sslId, sslConfig) != SUCCESS) {
LOG_ERROR("HLT_RpcTlsSetSsl ERROR");
return ERROR;
}
if (ctxConfig->mtu > 0) {
if (HLT_RpcTlsSetMtu(process, sslId, ctxConfig->mtu) != SUCCESS) {
LOG_ERROR("HLT_RpcTlsSetMtu ERROR");
return ERROR;
}
}
tlsRes->ctx = NULL;
tlsRes->ssl = NULL;
tlsRes->ctxId = ctxId;
tlsRes->sslId = sslId;
return SUCCESS;
}
HLT_Tls_Res *HLT_ProcessTlsInit(HLT_Process *process, TLS_VERSION tlsVersion,
HLT_Ctx_Config *ctxConfig, HLT_Ssl_Config *sslConfig)
{
int ret;
HLT_Tls_Res *tlsRes = (HLT_Tls_Res*)malloc(sizeof(HLT_Tls_Res));
if (tlsRes == NULL) {
LOG_ERROR("Malloc TlsRes ERROR");
return NULL;
}
// Checking Configuration Parameters
if (ctxConfig == NULL) {
ctxConfig = HLT_NewCtxConfig(NULL, "SERVER");
}
if (sslConfig == NULL) {
sslConfig = HLT_NewSslConfig(NULL);
}
if ((ctxConfig == NULL) || (sslConfig == NULL)) {
LOG_ERROR("ctxConfig or sslConfig is NULL");
goto ERR;
}
sslConfig->SupportType = ctxConfig->SupportType;
// Check whether the call is invoked by the local process or by the RPC.
if (process->remoteFlag == 0) {
ret = LocalProcessTlsInit(process, tlsVersion, ctxConfig, sslConfig, tlsRes);
if (ret == ERROR) {
LOG_ERROR("LocalProcessTlsInit ERROR");
goto ERR;
}
} else {
ret = RemoteProcessTlsInit(process, tlsVersion, ctxConfig, sslConfig, tlsRes);
if (ret == ERROR) {
LOG_ERROR("RemoteProcessTlsInit ERROR");
goto ERR;
}
}
// The configuration resources of the HLT_Tls_Res table are stored and will be released later.
Process *localProcess = GetProcess();
tlsRes->acceptId = 0;
localProcess->hltTlsResArray[localProcess->hltTlsResNum] = tlsRes;
localProcess->hltTlsResNum++;
return tlsRes;
ERR:
free(tlsRes);
return NULL;
}
int HLT_TlsSetMtu(void *ssl, uint16_t mtu)
{
Process *process;
process = GetProcess();
switch (process->tlsType) {
case HITLS:
return HitlsSetMtu(ssl, mtu);
default:
break;
}
return ERROR;
}
int HLT_TlsGetErrorCode(void *ssl)
{
return HitlsGetErrorCode(ssl);
}
HLT_Tls_Res* HLT_ProcessTlsAccept(HLT_Process *process, TLS_VERSION tlsVersion,
HLT_Ctx_Config *ctxConfig, HLT_Ssl_Config *sslConfig)
{
unsigned long int acceptId;
HLT_Tls_Res *tlsRes = NULL;
tlsRes = HLT_ProcessTlsInit(process, tlsVersion, ctxConfig, sslConfig);
if (tlsRes == NULL) {
LOG_ERROR("HLT_ProcessTlsInit ERROR");
return NULL;
}
// Check whether the call is invoked by the local process or by the RPC.
if (process->remoteFlag == 0) {
acceptId = HLT_TlsAccept(tlsRes->ssl);
if (acceptId == (unsigned long int)ERROR) {
LOG_ERROR("HLT_TlsAccept ERROR");
return NULL;
}
} else {
acceptId = HLT_RpcTlsAccept(process, tlsRes->sslId);
if (acceptId == (unsigned long int)ERROR) {
LOG_ERROR("HLT_TlsAccept ERROR");
return NULL;
}
}
tlsRes->acceptId = acceptId;
return tlsRes;
}
HLT_Tls_Res* HLT_ProcessTlsConnect(HLT_Process *process, TLS_VERSION tlsVersion,
HLT_Ctx_Config *ctxConfig, HLT_Ssl_Config *sslConfig)
{
int ret;
HLT_Tls_Res *tlsRes = (HLT_Tls_Res*)malloc(sizeof(HLT_Tls_Res));
if (tlsRes == NULL) {
LOG_ERROR("Malloc TlsRes ERROR");
return NULL;
}
(void)memset_s(tlsRes, sizeof(HLT_Tls_Res), 0, sizeof(HLT_Tls_Res));
// Checking Configuration Parameters
if (ctxConfig == NULL) {
ctxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
}
if (sslConfig == NULL) {
sslConfig = HLT_NewSslConfig(NULL);
}
if ((ctxConfig == NULL) || (sslConfig == NULL)) {
LOG_ERROR("ctxConfig or sslConfig is NULL");
goto ERR;
}
// Check whether the call is invoked by the local process or by the RPC.
if (process->remoteFlag == 0) {
ret = LocalProcessTlsInit(process, tlsVersion, ctxConfig, sslConfig, tlsRes);
if (ret == ERROR) {
LOG_ERROR("LocalProcessTlsInit ERROR");
goto ERR;
}
ret = HLT_TlsConnect(tlsRes->ssl);
if (ret != SUCCESS) {
LOG_ERROR("HLT_TlsConnect ERROR is %d", ret);
goto ERR;
}
} else {
ret = RemoteProcessTlsInit(process, tlsVersion, ctxConfig, sslConfig, tlsRes);
if (ret == ERROR) {
LOG_ERROR("Retmote Process Init Tls ERROR");
goto ERR;
}
ret = HLT_RpcTlsConnect(process, tlsRes->sslId);
if (ret != SUCCESS) {
LOG_ERROR("HLT_RpcTlsConnect ERROR is %d", ret);
goto ERR;
}
}
// The configuration resources of the HLT_Tls_Res table are stored and will be released later.
Process *localProcess = GetProcess();
localProcess->hltTlsResArray[localProcess->hltTlsResNum] = tlsRes;
localProcess->hltTlsResNum++;
return tlsRes;
ERR:
free(tlsRes);
return NULL;
}
int HLT_ProcessTlsWrite(HLT_Process *process, HLT_Tls_Res *tlsRes, uint8_t *data, uint32_t dataLen)
{
if (process == NULL) {
LOG_ERROR("Process is NULL");
return ERROR;
}
if (process->remoteFlag == 0) {
return HLT_TlsWrite(tlsRes->ssl, data, dataLen);
} else {
return HLT_RpcTlsWrite(process, tlsRes->sslId, data, dataLen);
}
}
int HLT_ProcessTlsRead(HLT_Process *process, HLT_Tls_Res *tlsRes, uint8_t *data, uint32_t bufSize, uint32_t *dataLen)
{
if (process == NULL) {
LOG_ERROR("Process is NULL");
return ERROR;
}
if (process->remoteFlag == 0) {
return HLT_TlsRead(tlsRes->ssl, data, bufSize, dataLen);
} else {
return HLT_RpcTlsRead(process, tlsRes->sslId, data, bufSize, dataLen);
}
}
int HLT_SetVersion(HLT_Ctx_Config *ctxConfig, uint16_t minVersion, uint16_t maxVersion)
{
ctxConfig->minVersion = minVersion;
ctxConfig->maxVersion = maxVersion;
return SUCCESS;
}
int HLT_SetSecurityLevel(HLT_Ctx_Config *ctxConfig, int32_t level)
{
ctxConfig->securitylevel = level;
return SUCCESS;
}
int HLT_SetRenegotiationSupport(HLT_Ctx_Config *ctxConfig, bool support)
{
ctxConfig->isSupportRenegotiation = support;
return SUCCESS;
}
int HLT_SetLegacyRenegotiateSupport(HLT_Ctx_Config *ctxConfig, bool support)
{
ctxConfig->allowLegacyRenegotiate = support;
return SUCCESS;
}
int HLT_SetClientRenegotiateSupport(HLT_Ctx_Config *ctxConfig, bool support)
{
ctxConfig->allowClientRenegotiate = support;
return SUCCESS;
}
int HLT_SetEmptyRecordsNum(HLT_Ctx_Config *ctxConfig, uint32_t emptyNum)
{
ctxConfig->emptyRecordsNum = emptyNum;
return SUCCESS;
}
int HLT_SetKeyLogCb(HLT_Ctx_Config *ctxConfig, char *SetKeyLogCb)
{
(void)memset_s(ctxConfig->keyLogCb, KEY_LOG_CB_LEN, 0, KEY_LOG_CB_LEN);
if (strcpy_s(ctxConfig->keyLogCb, KEY_LOG_CB_LEN, SetKeyLogCb) != EOK) {
LOG_ERROR("HLT_SetKeyLogCb failed.");
return -1;
}
return SUCCESS;
}
int HLT_SetEncryptThenMac(HLT_Ctx_Config *ctxConfig, int support)
{
ctxConfig->isEncryptThenMac = support;
return SUCCESS;
}
int HLT_SetMiddleBoxCompat(HLT_Ctx_Config *ctxConfig, int support)
{
ctxConfig->isMiddleBoxCompat = support;
return SUCCESS;
}
int HLT_SetFlightTransmitSwitch(HLT_Ctx_Config *ctxConfig, bool support)
{
ctxConfig->isFlightTransmitEnable = support;
return SUCCESS;
}
int HLT_SetClientVerifySupport(HLT_Ctx_Config *ctxConfig, bool support)
{
ctxConfig->isSupportClientVerify = support;
return SUCCESS;
}
int HLT_SetPostHandshakeAuth(HLT_Ctx_Config *ctxConfig, bool support)
{
ctxConfig->isSupportPostHandshakeAuth = support;
return SUCCESS;
}
int HLT_SetNoClientCertSupport(HLT_Ctx_Config *ctxConfig, bool support)
{
ctxConfig->isSupportNoClientCert = support;
return SUCCESS;
}
int HLT_SetExtenedMasterSecretSupport(HLT_Ctx_Config *ctxConfig, bool support)
{
ctxConfig->isSupportExtendMasterSecret = support;
return SUCCESS;
}
int HLT_SetModeSupport(HLT_Ctx_Config *ctxConfig, uint32_t mode)
{
ctxConfig->modeSupport = mode;
return SUCCESS;
}
int HLT_SetCipherSuites(HLT_Ctx_Config *ctxConfig, const char *cipherSuites)
{
int ret;
(void)memset_s(ctxConfig->cipherSuites, sizeof(ctxConfig->cipherSuites), 0, sizeof(ctxConfig->cipherSuites));
ret = sprintf_s(ctxConfig->cipherSuites, sizeof(ctxConfig->cipherSuites), cipherSuites);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetProviderPath(HLT_Ctx_Config *ctxConfig, char *providerPath)
{
if (strcpy_s(ctxConfig->providerPath, sizeof(ctxConfig->providerPath), providerPath) != EOK) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetProviderAttrName(HLT_Ctx_Config *ctxConfig, char *attrName)
{
if (strcpy_s(ctxConfig->attrName, sizeof(ctxConfig->attrName), attrName) != EOK) {
return ERROR;
}
return SUCCESS;
}
int HLT_AddProviderInfo(HLT_Ctx_Config *ctxConfig, char *providerName, int providerLibFmt)
{
if (providerName != NULL) {
if (strcpy_s(ctxConfig->providerNames[ctxConfig->providerCnt], MAX_PROVIDER_NAME_LEN, providerName) != EOK) {
return ERROR;
}
ctxConfig->providerLibFmts[ctxConfig->providerCnt] = providerLibFmt;
ctxConfig->providerCnt += 1;
}
return SUCCESS;
}
int HLT_SetTls13CipherSuites(HLT_Ctx_Config *ctxConfig, const char *cipherSuites)
{
int ret;
(void)memset_s(ctxConfig->tls13CipherSuites, sizeof(ctxConfig->tls13CipherSuites), 0,
sizeof(ctxConfig->tls13CipherSuites));
ret = sprintf_s(ctxConfig->tls13CipherSuites, sizeof(ctxConfig->tls13CipherSuites), cipherSuites);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetEcPointFormats(HLT_Ctx_Config *ctxConfig, const char *pointFormat)
{
int ret;
(void)memset_s(ctxConfig->pointFormats, sizeof(ctxConfig->pointFormats), 0, sizeof(ctxConfig->pointFormats));
ret = sprintf_s(ctxConfig->pointFormats, sizeof(ctxConfig->pointFormats), pointFormat);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetGroups(HLT_Ctx_Config *ctxConfig, const char *groups)
{
int ret;
(void)memset_s(ctxConfig->groups, sizeof(ctxConfig->groups), 0, sizeof(ctxConfig->groups));
ret = sprintf_s(ctxConfig->groups, sizeof(ctxConfig->groups), groups);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetSignature(HLT_Ctx_Config *ctxConfig, const char *signature)
{
int ret;
(void)memset_s(ctxConfig->signAlgorithms, sizeof(ctxConfig->signAlgorithms), 0, sizeof(ctxConfig->signAlgorithms));
ret = sprintf_s(ctxConfig->signAlgorithms, sizeof(ctxConfig->signAlgorithms), signature);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetPsk(HLT_Ctx_Config *ctxConfig, char *psk)
{
(void)memset_s(ctxConfig->psk, PSK_MAX_LEN, 0, PSK_MAX_LEN);
if (strcpy_s(ctxConfig->psk, PSK_MAX_LEN, psk) != EOK) {
LOG_ERROR("HLT_SetPsk failed.");
return -1;
}
return SUCCESS;
}
int HLT_SetKeyExchMode(HLT_Ctx_Config *config, uint32_t mode)
{
config->keyExchMode = mode;
return SUCCESS;
}
int HLT_SetTicketKeyCb(HLT_Ctx_Config *ctxConfig, char *ticketKeyCbName)
{
(void)memset_s(ctxConfig->ticketKeyCb, TICKET_KEY_CB_NAME_LEN, 0, TICKET_KEY_CB_NAME_LEN);
if (strcpy_s(ctxConfig->ticketKeyCb, TICKET_KEY_CB_NAME_LEN, ticketKeyCbName) != EOK) {
LOG_ERROR("HLT_SetTicketKeyCb failed.");
return -1;
}
return SUCCESS;
}
int HLT_SetCaCertPath(HLT_Ctx_Config *ctxConfig, const char *caCertPath)
{
int ret;
(void)memset_s(ctxConfig->caCert, sizeof(ctxConfig->caCert), 0, sizeof(ctxConfig->caCert));
ret = sprintf_s(ctxConfig->caCert, sizeof(ctxConfig->caCert), caCertPath);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetChainCertPath(HLT_Ctx_Config *ctxConfig, const char *chainCertPath)
{
int ret;
(void)memset_s(ctxConfig->chainCert, sizeof(ctxConfig->chainCert), 0, sizeof(ctxConfig->chainCert));
ret = sprintf_s(ctxConfig->chainCert, sizeof(ctxConfig->chainCert), chainCertPath);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetEeCertPath(HLT_Ctx_Config *ctxConfig, const char *eeCertPath)
{
int ret;
(void)memset_s(ctxConfig->eeCert, sizeof(ctxConfig->eeCert), 0, sizeof(ctxConfig->eeCert));
ret = sprintf_s(ctxConfig->eeCert, sizeof(ctxConfig->eeCert), eeCertPath);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetPrivKeyPath(HLT_Ctx_Config *ctxConfig, const char *privKeyPath)
{
int ret;
(void)memset_s(ctxConfig->privKey, sizeof(ctxConfig->privKey), 0, sizeof(ctxConfig->privKey));
ret = sprintf_s(ctxConfig->privKey, sizeof(ctxConfig->privKey), privKeyPath);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetSignCertPath(HLT_Ctx_Config *ctxConfig, const char *signCertPath)
{
int ret;
(void)memset_s(ctxConfig->signCert, sizeof(ctxConfig->signCert), 0, sizeof(ctxConfig->signCert));
ret = sprintf_s(ctxConfig->signCert, sizeof(ctxConfig->signCert), signCertPath);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetSignPrivKeyPath(HLT_Ctx_Config *ctxConfig, const char *signPrivKeyPath)
{
int ret;
(void)memset_s(ctxConfig->signPrivKey, sizeof(ctxConfig->signPrivKey), 0, sizeof(ctxConfig->signPrivKey));
ret = sprintf_s(ctxConfig->signPrivKey, sizeof(ctxConfig->signPrivKey), signPrivKeyPath);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetPassword(HLT_Ctx_Config* ctxConfig, const char* password)
{
int ret;
(void)memset_s(ctxConfig->password, sizeof(ctxConfig->password), 0, sizeof(ctxConfig->password));
ret = sprintf_s(ctxConfig->password, sizeof(ctxConfig->password), password);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
void HLT_SetCertPath(HLT_Ctx_Config *ctxConfig, const char *caPath, const char *chainPath, const char *EePath,
const char *PrivPath, const char *signCert, const char *signPrivKey)
{
HLT_SetCaCertPath(ctxConfig, caPath);
if (ctxConfig->isNoSetCert) {
return;
}
HLT_SetChainCertPath(ctxConfig, chainPath);
HLT_SetEeCertPath(ctxConfig, EePath);
HLT_SetPrivKeyPath(ctxConfig, PrivPath);
HLT_SetSignCertPath(ctxConfig, signCert);
HLT_SetSignPrivKeyPath(ctxConfig, signPrivKey);
}
int HLT_SetServerName(HLT_Ctx_Config *ctxConfig, const char *serverName)
{
(void)memset_s(ctxConfig->serverName, sizeof(ctxConfig->serverName), 0, sizeof(ctxConfig->serverName));
int ret = sprintf_s(ctxConfig->serverName, sizeof(ctxConfig->serverName), serverName);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetServerNameArg(HLT_Ctx_Config *ctxConfig, char *arg)
{
(void)memset_s(ctxConfig->sniArg, SERVER_NAME_ARG_NAME_LEN, 0, SERVER_NAME_ARG_NAME_LEN);
if (strcpy_s(ctxConfig->sniArg, SERVER_NAME_ARG_NAME_LEN, arg) != EOK) {
LOG_ERROR("HLT_SetServerNameArg failed.");
return ERROR;
}
return SUCCESS;
}
int HLT_SetServerNameCb(HLT_Ctx_Config *ctxConfig, char *sniCbName)
{
(void)memset_s(ctxConfig->sniDealCb, SERVER_NAME_CB_NAME_LEN, 0, SERVER_NAME_CB_NAME_LEN);
if (strcpy_s(ctxConfig->sniDealCb, SERVER_NAME_CB_NAME_LEN, sniCbName) != EOK) {
LOG_ERROR("HLT_SetServerNameCb failed.");
return ERROR;
}
return SUCCESS;
}
int HLT_SetAlpnProtos(HLT_Ctx_Config *ctxConfig, const char *alpnProtos)
{
(void)memset_s(ctxConfig->alpnList, sizeof(ctxConfig->alpnList), 0, sizeof(ctxConfig->alpnList));
int ret = sprintf_s(ctxConfig->alpnList, sizeof(ctxConfig->alpnList), alpnProtos);
if (ret <= 0) {
return ERROR;
}
return SUCCESS;
}
int HLT_SetAlpnProtosSelectCb(HLT_Ctx_Config *ctxConfig, char *callback, char *userData)
{
(void)memset_s(ctxConfig->alpnSelectCb, ALPN_CB_NAME_LEN, 0, ALPN_CB_NAME_LEN);
if (strcpy_s(ctxConfig->alpnSelectCb, ALPN_CB_NAME_LEN, callback) != EOK) {
LOG_ERROR("HLT_SetAlpnCb failed.");
return ERROR;
}
(void)memset_s(ctxConfig->alpnUserData, ALPN_DATA_NAME_LEN, 0, ALPN_DATA_NAME_LEN);
if (strcpy_s(ctxConfig->alpnUserData, ALPN_DATA_NAME_LEN, userData) != EOK) {
LOG_ERROR("HLT_SetAlpnDataCb failed.");
return ERROR;
}
return SUCCESS;
}
int HLT_SetClientHelloCb(HLT_Ctx_Config *ctxConfig, HITLS_ClientHelloCb callback, void *arg)
{
ctxConfig->clientHelloCb = callback;
ctxConfig->clientHelloArg = arg;
return SUCCESS;
}
int HLT_SetCertCb(HLT_Ctx_Config *ctxConfig, HITLS_CertCb certCb, void *arg)
{
ctxConfig->certCb = certCb;
ctxConfig->certArg = arg;
return SUCCESS;
}
int HLT_SetCAList(HLT_Ctx_Config *ctxConfig, HITLS_TrustedCAList *caList)
{
ctxConfig->caList = caList;
return SUCCESS;
}
int HLT_SetFrameHandle(HLT_FrameHandle *frameHandle)
{
return SetFrameHandle(frameHandle);
}
void HLT_CleanFrameHandle(void)
{
CleanFrameHandle();
}
bool IsEnableSctpAuth(void)
{
return false;
}
void HLT_ConfigTimeOut(const char* timeout)
{
setenv("SSL_TIMEOUT", timeout, 1);
}
void HLT_UnsetTimeOut()
{
unsetenv("SSL_TIMEOUT");
}
|
2301_79861745/bench_create
|
testcode/framework/tls/rpc/src/hlt_func.c
|
C
|
unknown
| 41,089
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include "logger.h"
#include "process.h"
#include "hlt_type.h"
#include "control_channel.h"
#include "channel_res.h"
#include "handle_cmd.h"
#include "securec.h"
#define SUCCESS 0
#define ERROR (-1)
uint64_t g_cmdIndex = 0;
pthread_mutex_t g_cmdMutex = PTHREAD_MUTEX_INITIALIZER;
#define ASSERT_RETURN(condition, log) \
do { \
if (!(condition)) { \
LOG_ERROR(log); \
return ERROR; \
} \
} while (0)
void InitCmdIndex(void)
{
g_cmdIndex = 0;
}
static int WaitResult(CmdData *expectCmdData, int cmdIndex, const char *funcName)
{
int ret;
ret = sprintf_s(expectCmdData->id, sizeof(expectCmdData->id), "%d", cmdIndex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = sprintf_s(expectCmdData->funcId, sizeof(expectCmdData->funcId), "%s", funcName);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
// Receive the result.
ret = WaitResultFromPeer(expectCmdData);
ASSERT_RETURN(ret == SUCCESS, "WaitResultFromPeer Error");
return SUCCESS;
}
int HLT_RpcProviderTlsNewCtx(HLT_Process *peerProcess, TLS_VERSION tlsVersion, bool isClient, char *providerPath,
char (*providerNames)[MAX_PROVIDER_NAME_LEN], int32_t *providerLibFmts, int32_t providerCnt, char *attrName)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
uint32_t offset = 0;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsNewCtx");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data),
"%llu|%s|%d|%d|",
g_cmdIndex, __FUNCTION__, tlsVersion, isClient);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
offset += ret;
if (providerCnt == 0 || providerNames == NULL || providerLibFmts == NULL) {
ret = sprintf_s(dataBuf.data + offset, sizeof(dataBuf.data) - offset, "|");
ASSERT_RETURN(ret > 0, "sprintf_s Error");
offset += ret;
}
for (int i = 0; i < providerCnt - 1; i++) {
ret = sprintf_s(dataBuf.data + offset, sizeof(dataBuf.data) - offset, "%s,%d:", providerNames[i],
providerLibFmts[i]);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
offset += ret;
}
if (providerCnt >= 1) {
ret = sprintf_s(dataBuf.data + offset, sizeof(dataBuf.data) - offset, "%s,%d|", providerNames[providerCnt - 1],
providerLibFmts[providerCnt - 1]);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
offset += ret;
}
if (attrName != NULL && strlen(attrName) > 0) {
ret = sprintf_s(dataBuf.data + offset, sizeof(dataBuf.data) - offset, "%s|", attrName);
} else {
ret = sprintf_s(dataBuf.data + offset, sizeof(dataBuf.data) - offset, "|");
}
ASSERT_RETURN(ret > 0, "sprintf_s Error");
offset += ret;
if (providerPath != NULL && strlen(providerPath) > 0) {
ret = sprintf_s(dataBuf.data + offset, sizeof(dataBuf.data) - offset, "%s|", providerPath);
} else {
ret = sprintf_s(dataBuf.data + offset, sizeof(dataBuf.data) - offset, "|");
}
ASSERT_RETURN(ret > 0, "sprintf_s Error");
offset += ret;
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcTlsNewCtx(HLT_Process *peerProcess, TLS_VERSION tlsVersion, bool isClient)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsNewCtx");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%d", g_cmdIndex, __FUNCTION__, tlsVersion, isClient);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcTlsSetCtx(HLT_Process *peerProcess, int ctxId, HLT_Ctx_Config *config)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsSetCtx");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data),
"%llu|%s|%d|"
"%u|%u|%s|%s|"
"%s|%s|%s|%d|"
"%d|%d|%d|%s|"
"%s|%s|%s|%s|"
"%s|%s|%s|%d|"
"%d|%s|%d|%s|"
"%s|%s|%s|%s|"
"%s|%d|%d|"
"%u|%d|%d|"
"%d|%d|%d|"
"%d|%u|%d|%d|"
"%u|%d|%s",
g_cmdIndex, __FUNCTION__, ctxId,
config->minVersion, config->maxVersion, config->cipherSuites, config->tls13CipherSuites,
config->pointFormats, config->groups, config->signAlgorithms, config->isSupportRenegotiation,
config->isSupportClientVerify, config->isSupportNoClientCert, config->isSupportExtendMasterSecret, config->eeCert,
config->privKey, config->password, config->caCert, config->chainCert,
config->signCert, config->signPrivKey, config->psk, config->isSupportSessionTicket,
config->setSessionCache, config->ticketKeyCb, config->isFlightTransmitEnable, config->serverName,
config->sniDealCb, config->sniArg, config->alpnList, config->alpnSelectCb,
config->alpnUserData, config->securitylevel, config->isSupportDhAuto,
config->keyExchMode, config->SupportType, config->isSupportPostHandshakeAuth,
config->readAhead, config->needCheckKeyUsage, config->isSupportVerifyNone,
config->allowClientRenegotiate, config->emptyRecordsNum, config->allowLegacyRenegotiate, config->isEncryptThenMac,
config->modeSupport, config->isMiddleBoxCompat, config->attrName);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Wait to receive the result.
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcTlsNewSsl(HLT_Process *peerProcess, int ctxId)
{
int ret;
uint64_t cmdIndex;
CmdData expectCmdData = {0};
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsNewSsl");
// Constructing Commands
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, ctxId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Wait to receive the result.
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcTlsSetSsl(HLT_Process *peerProcess, int sslId, HLT_Ssl_Config *config)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsSetSsl");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%d|%d|%d",
g_cmdIndex, __FUNCTION__, sslId, config->sockFd, config->connType, config->connPort);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Wait to receive the result.
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcTlsListen(HLT_Process *peerProcess, int sslId)
{
int ret;
uint64_t acceptId;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
srcProcess = GetProcess();
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsListen");
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
acceptId = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
return acceptId;
}
int HLT_RpcTlsAccept(HLT_Process *peerProcess, int sslId)
{
int ret;
uint64_t acceptId;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
srcProcess = GetProcess();
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsAccept");
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
acceptId = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
return acceptId;
}
int HLT_RpcGetTlsListenResult(int acceptId)
{
int ret;
CmdData expectCmdData = {0};
ret = WaitResult(&expectCmdData, acceptId, "HLT_RpcTlsListen");
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], NULL, 10); // Convert to a decimal number
}
int HLT_RpcGetTlsAcceptResult(int acceptId)
{
int ret;
char *endPtr = NULL;
CmdData expectCmdData = {0};
ret = WaitResult(&expectCmdData, acceptId, "HLT_RpcTlsAccept");
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcTlsConnect(HLT_Process *peerProcess, int sslId)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsConnect");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result returned by the peer
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcTlsConnectUnBlock(HLT_Process *peerProcess, int sslId)
{
uint64_t cmdIndex;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsConnect");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
int ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, "HLT_RpcTlsConnect", sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
return cmdIndex;
}
int HLT_RpcGetTlsConnectResult(int cmdIndex)
{
int ret;
CmdData expectCmdData = {0};
// Waiting for the result returned by the peer
ret = WaitResult(&expectCmdData, cmdIndex, "HLT_RpcTlsConnect");
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcTlsRead(HLT_Process *peerProcess, int sslId, uint8_t *data, uint32_t bufSize, uint32_t *readLen)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsRead");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%u", g_cmdIndex, __FUNCTION__, sslId, bufSize);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result returned by the peer
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
// Parsing result
ret = atoi(expectCmdData.paras[0]);
if (ret == SUCCESS) {
*readLen = atoi(expectCmdData.paras[1]); // The first parameter indicates the read length.
memcpy_s(
data, bufSize, expectCmdData.paras[2], *readLen); // The second parameter indicates the content to be read.
}
return ret;
}
int HLT_RpcTlsReadUnBlock(HLT_Process *peerProcess, int sslId, uint8_t *data, uint32_t bufSize, uint32_t *readLen)
{
(void)data;
(void)readLen;
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsRead");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%u", g_cmdIndex, "HLT_RpcTlsRead", sslId, bufSize);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
return cmdIndex;
}
int HLT_RpcGetTlsReadResult(int cmdIndex, uint8_t *data, uint32_t bufSize, uint32_t *readLen)
{
int ret;
char *endPtr = NULL;
CmdData expectCmdData = {0};
ret = WaitResult(&expectCmdData, cmdIndex, "HLT_RpcTlsRead");
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
// Parsing result
ret = (int)strtol(expectCmdData.paras[0], &endPtr, 0);
if (ret == SUCCESS) {
*readLen = (int)strtol(expectCmdData.paras[1], &endPtr, 0); // The first parameter indicates the read length.
// The second parameter indicates the content to be read.
memcpy_s(data, bufSize, expectCmdData.paras[2], *readLen);
}
return ret;
}
int HLT_RpcTlsWrite(HLT_Process *peerProcess, int sslId, uint8_t *data, uint32_t bufSize)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsWrite");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%u|%s",
g_cmdIndex, __FUNCTION__, sslId, bufSize, data);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result returned by the peer
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcTlsWriteUnBlock(HLT_Process *peerProcess, int sslId, uint8_t *data, uint32_t bufSize)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsWrite");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%u|%s",
g_cmdIndex, "HLT_RpcTlsWrite", sslId, bufSize, data);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Do not wait for the result returned by the peer.
return cmdIndex;
}
int HLT_RpcGetTlsWriteResult(int cmdIndex)
{
int ret;
CmdData expectCmdData = {0};
ret = WaitResult(&expectCmdData, cmdIndex, "HLT_RpcTlsWrite");
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], NULL, 10); // Convert to a decimal number
}
int HLT_RpcTlsRenegotiate(HLT_Process *peerProcess, int sslId)
{
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
CmdData expectCmdData = {0};
srcProcess = GetProcess();
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsRenegotiate");
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcTlsVerifyClientPostHandshake(HLT_Process *peerProcess, int sslId)
{
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
CmdData expectCmdData = {0};
srcProcess = GetProcess();
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call RpcTlsVerifyClientPostHandshake");
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcDataChannelConnect(HLT_Process *peerProcess, DataChannelParam *channelParam)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcDataChannelConnect");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%d|%d", g_cmdIndex, __FUNCTION__,
channelParam->type, channelParam->port, channelParam->isBlock);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result returned by the peer
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcDataChannelBind(HLT_Process *peerProcess, DataChannelParam *channelParam)
{
int ret;
uint64_t bindId;
Process *srcProcess = NULL;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcDataChannelBind");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%d|%d|%d", g_cmdIndex, __FUNCTION__,
channelParam->type, channelParam->port, channelParam->isBlock, channelParam->bindFd);
dataBuf.dataLen = strlen(dataBuf.data);
bindId = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result returned by the peer
ret = WaitResult(&expectCmdData, bindId, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
channelParam->port = atoi(expectCmdData.paras[1]);
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcDataChannelAccept(HLT_Process *peerProcess, DataChannelParam *channelParam)
{
int ret;
uint64_t acceptId;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcDataChannelAccept");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%d|%d|%d", g_cmdIndex, __FUNCTION__,
channelParam->type, channelParam->port, channelParam->isBlock, channelParam->bindFd);
dataBuf.dataLen = strlen(dataBuf.data);
acceptId = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
return acceptId;
}
int HLT_RpcGetAcceptFd(int acceptId)
{
int ret;
CmdData expectCmdData = {0};
ret = WaitResult(&expectCmdData, acceptId, "HLT_RpcDataChannelAccept");
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcTlsRegCallback(HLT_Process *peerProcess, TlsCallbackType type)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsRegCallback");
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, type);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return atoi(expectCmdData.paras[0]);
}
int HLT_RpcProcessExit(HLT_Process *peerProcess)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
srcProcess = GetProcess();
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcProcessExit");
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, peerProcess->connFd);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return SUCCESS;
}
int HLT_RpcTlsGetStatus(HLT_Process *peerProcess, int sslId)
{
ASSERT_RETURN(peerProcess != NULL, "HLT_RpcTlsGetStatus Parameter Error");
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsGetStatus");
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcTlsGetAlertFlag(HLT_Process *peerProcess, int sslId)
{
ASSERT_RETURN(peerProcess != NULL, "HLT_RpcTlsGetAlertFlag Parameter Error");
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcProcessExit");
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcTlsGetAlertLevel(HLT_Process *peerProcess, int sslId)
{
ASSERT_RETURN(peerProcess != NULL, "HLT_RpcTlsGetAlertLevel Parameter Error");
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsGetAlertLevel");
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcTlsGetAlertDescription(HLT_Process *peerProcess, int sslId)
{
ASSERT_RETURN(peerProcess != NULL, "HLT_RpcTlsGetAlertDescription Parameter Error");
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsGetAlertDescription");
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcTlsClose(HLT_Process *peerProcess, int sslId)
{
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
CmdData expectCmdData = {0};
srcProcess = GetProcess();
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsClose");
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcFreeResFormSsl(HLT_Process *peerProcess, int sslId)
{
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
CmdData expectCmdData = {0};
srcProcess = GetProcess();
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcFreeResFormSsl");
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcSctpClose(HLT_Process *peerProcess, int fd)
{
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
CmdData expectCmdData = {0};
srcProcess = GetProcess();
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcSctpClose");
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, fd);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol((const char *)expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcCloseFd(HLT_Process *peerProcess, int fd, int linkType)
{
int ret;
uint64_t cmdIndex;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
srcProcess = GetProcess();
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcCloseFd");
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%d", g_cmdIndex, __FUNCTION__, fd, linkType);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// The close fd does not need to wait for the result.
return ret;
}
int HLT_RpcTlsSetMtu(HLT_Process *peerProcess, int sslId, uint16_t mtu)
{
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess = NULL;
ControlChannelBuf dataBuf;
CmdData expectCmdData = {0};
srcProcess = GetProcess();
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsSetMtu");
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d|%d", g_cmdIndex, __FUNCTION__, sslId, mtu);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
int HLT_RpcTlsGetErrorCode(HLT_Process *peerProcess, int sslId)
{
ASSERT_RETURN(peerProcess != NULL, "HLT_RpcTlsGetStatus Parameter Error");
ASSERT_RETURN(peerProcess->remoteFlag == 1, "Only Remote Process Support Call HLT_RpcTlsGetErrorCode");
int ret;
uint64_t cmdIndex;
char *endPtr = NULL;
Process *srcProcess;
CmdData expectCmdData = {0};
ControlChannelBuf dataBuf;
srcProcess = GetProcess();
pthread_mutex_lock(&g_cmdMutex);
ret = sprintf_s(dataBuf.data, sizeof(dataBuf.data), "%llu|%s|%d", g_cmdIndex, __FUNCTION__, sslId);
dataBuf.dataLen = strlen(dataBuf.data);
cmdIndex = g_cmdIndex;
g_cmdIndex++;
pthread_mutex_unlock(&g_cmdMutex);
ASSERT_RETURN(ret > 0, "sprintf_s Error");
ret = ControlChannelWrite(srcProcess->controlChannelFd, peerProcess->srcDomainPath, &dataBuf);
ASSERT_RETURN(ret == SUCCESS, "ControlChannelWrite Error");
// Waiting for the result
ret = WaitResult(&expectCmdData, cmdIndex, __FUNCTION__);
ASSERT_RETURN(ret == SUCCESS, "WaitResult Error");
return (int)strtol(expectCmdData.paras[0], &endPtr, 0);
}
|
2301_79861745/bench_create
|
testcode/framework/tls/rpc/src/hlt_rpc_func.c
|
C
|
unknown
| 38,001
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include "securec.h"
#include "hlt.h"
#include "handle_cmd.h"
#include "tls_res.h"
#include "logger.h"
#include "lock.h"
#include "hitls_error.h"
#include "hitls_type.h"
#include "tls.h"
#include "alert.h"
#include "hitls.h"
#include "common_func.h"
#include "sctp_channel.h"
#include "rpc_func.h"
#define HITLS_READBUF_MAXLEN (20 * 1024) /* 20K */
#define SUCCESS 0
#define ERROR (-1)
#define ASSERT_RETURN(condition) \
do { \
if (!(condition)) { \
LOG_ERROR("sprintf_s Error"); \
return ERROR; \
} \
} while (0)
RpcFunList g_rpcFuncList[] = {
#ifdef HITLS_TLS_FEATURE_PROVIDER
{"HLT_RpcProviderTlsNewCtx", RpcProviderTlsNewCtx},
#else
{"HLT_RpcTlsNewCtx", RpcTlsNewCtx},
#endif
{"HLT_RpcTlsSetCtx", RpcTlsSetCtx},
{"HLT_RpcTlsNewSsl", RpcTlsNewSsl},
{"HLT_RpcTlsSetSsl", RpcTlsSetSsl},
{"HLT_RpcTlsListen", RpcTlsListen},
{"HLT_RpcTlsAccept", RpcTlsAccept},
{"HLT_RpcTlsConnect", RpcTlsConnect},
{"HLT_RpcTlsRead", RpcTlsRead},
{"HLT_RpcTlsWrite", RpcTlsWrite},
{"HLT_RpcTlsRenegotiate", RpcTlsRenegotiate},
{"HLT_RpcDataChannelAccept", RpcDataChannelAccept},
{"HLT_RpcDataChannelConnect", RpcDataChannelConnect},
{"HLT_RpcProcessExit", RpcProcessExit},
{"HLT_RpcTlsRegCallback", RpcTlsRegCallback},
{"HLT_RpcTlsGetStatus", RpcTlsGetStatus},
{"HLT_RpcTlsGetAlertFlag", RpcTlsGetAlertFlag},
{"HLT_RpcTlsGetAlertLevel", RpcTlsGetAlertLevel},
{"HLT_RpcTlsGetAlertDescription", RpcTlsGetAlertDescription},
{"HLT_RpcTlsClose", RpcTlsClose},
{"HLT_RpcFreeResFormSsl", RpcFreeResFormSsl},
{"HLT_RpcCloseFd", RpcCloseFd},
{"HLT_RpcTlsSetMtu", RpcTlsSetMtu},
{"HLT_RpcTlsGetErrorCode", RpcTlsGetErrorCode},
{"HLT_RpcDataChannelBind", RpcDataChannelBind},
{"HLT_RpcTlsVerifyClientPostHandshake", RpcTlsVerifyClientPostHandshake},
};
RpcFunList *GetRpcFuncList(void)
{
return g_rpcFuncList;
}
int GetRpcFuncNum(void)
{
return sizeof(g_rpcFuncList) / sizeof(g_rpcFuncList[0]);
}
#ifdef HITLS_TLS_FEATURE_PROVIDER
/**
* Parse the provider string in format "name1,fmt1:name2,fmt2:...:nameN,fmtN"
*/
static int ParseProviderString(const char *providerStr, char (*providerNames)[MAX_PROVIDER_NAME_LEN],
int32_t *providerLibFmts, int32_t *providerCnt)
{
if (providerStr == NULL) {
LOG_DEBUG("Provider names is NULL");
return SUCCESS;
}
if (providerStr == NULL || providerLibFmts == NULL || providerCnt == NULL) {
LOG_ERROR("Invalid input parameters");
return ERROR;
}
int count = 1;
const char *ptr = providerStr;
while (*ptr) {
if (*ptr == ':') {
count++;
}
ptr++;
}
*providerCnt = count;
if (count == 0) {
LOG_ERROR("Provider string is empty");
return SUCCESS;
}
char *tempStr = strdup(providerStr);
if (tempStr == NULL) {
LOG_ERROR("Failed to duplicate provider string");
return ERROR;
}
char *saveptr1 = NULL;
char *saveptr2 = NULL;
char *token = strtok_r(tempStr, ":", &saveptr1);
int i = 0;
while (token != NULL && i < count) {
char *name = strtok_r(token, ",", &saveptr2);
char *fmt = strtok_r(NULL, ",", &saveptr2);
if (name == NULL || fmt == NULL) {
LOG_ERROR("Invalid provider format");
free(tempStr);
return ERROR;
}
if (strcpy_s(providerNames[i], MAX_PROVIDER_NAME_LEN, name) != EOK) {
LOG_ERROR("Failed to allocate memory for provider name");
free(tempStr);
return ERROR;
}
providerLibFmts[i] = atoi(fmt);
token = strtok_r(NULL, ":", &saveptr1);
i++;
}
free(tempStr);
return SUCCESS;
}
int RpcProviderTlsNewCtx(CmdData *cmdData)
{
int id;
TLS_VERSION tlsVersion;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
tlsVersion = atoi(cmdData->paras[0]);
char *providerNames = strlen(cmdData->paras[2]) > 0 ? cmdData->paras[2] : NULL;
char *attrName = strlen(cmdData->paras[3]) > 0 ? cmdData->paras[3] : NULL;
char *providerPath = strlen(cmdData->paras[4]) > 0 ? cmdData->paras[4] : NULL;
char parsedProviderNames[MAX_PROVIDER_COUNT][MAX_PROVIDER_NAME_LEN] = {0};
int32_t providerLibFmts[MAX_PROVIDER_COUNT] = {0};
int32_t providerCnt = 0;
if (ParseProviderString(providerNames, parsedProviderNames, providerLibFmts, &providerCnt) != SUCCESS) {
LOG_ERROR("Failed to parse provider string");
id = ERROR;
goto EXIT;
}
// Invoke the corresponding function.
void *ctx = HLT_TlsProviderNewCtx(providerPath, parsedProviderNames, providerLibFmts, providerCnt, attrName,
tlsVersion);
if (ctx == NULL) {
LOG_ERROR("HLT_TlsProviderNewCtx Return NULL");
id = ERROR;
goto EXIT;
}
// Insert to CTX linked list
id = InsertCtxToList(ctx);
EXIT:
// Return Result
if (sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, id) <= 0) {
return ERROR;
}
return SUCCESS;
}
#endif
int RpcTlsNewCtx(CmdData *cmdData)
{
int id;
TLS_VERSION tlsVersion;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
tlsVersion = atoi(cmdData->paras[0]);
// Invoke the corresponding function.
void* ctx = HLT_TlsNewCtx(tlsVersion);
if (ctx == NULL) {
LOG_ERROR("HLT_TlsNewCtx Return NULL");
id = ERROR;
goto EXIT;
}
// Insert to CTX linked list
id = InsertCtxToList(ctx);
EXIT:
// Return Result
if (sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, id) <= 0) {
return ERROR;
}
return SUCCESS;
}
int RpcTlsSetCtx(CmdData *cmdData)
{
int ret;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
// Find the corresponding CTX.
ResList *ctxList = GetCtxList();
int ctxId = atoi(cmdData->paras[0]);
void *ctx = GetTlsResFromId(ctxList, ctxId);
if (ctx == NULL) {
LOG_ERROR("GetResFromId Error");
ret = ERROR;
goto EXIT;
}
// Configurations related to parsing
HLT_Ctx_Config ctxConfig = {0};
ret = ParseCtxConfigFromString(cmdData->paras, &ctxConfig);
if (ret != SUCCESS) {
LOG_ERROR("ParseCtxConfigFromString Error");
ret = ERROR;
goto EXIT;
}
// Configure the data
ret = HLT_TlsSetCtx(ctx, &ctxConfig);
EXIT:
// Return the result
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsNewSsl(CmdData *cmdData)
{
int id, ret;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
// Invoke the corresponding function.
ResList *ctxList = GetCtxList();
int ctxId = atoi(cmdData->paras[0]);
void *ctx = GetTlsResFromId(ctxList, ctxId);
if (ctx == NULL) {
LOG_ERROR("Not Find Ctx");
id = ERROR;
goto EXIT;
}
void *ssl = HLT_TlsNewSsl(ctx);
if (ssl == NULL) {
LOG_ERROR("HLT_TlsNewSsl Return NULL");
id = ERROR;
goto EXIT;
}
// Insert to the SSL linked list.
id = InsertSslToList(ctx, ssl);
EXIT:
// Return the result.
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, id);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsSetSsl(CmdData *cmdData)
{
int ret;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
int sslId = atoi(cmdData->paras[0]);
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl == NULL) {
LOG_ERROR("Not Find Ssl");
ret = ERROR;
goto EXIT;
}
HLT_Ssl_Config sslConfig = {0};
sslConfig.sockFd = atoi(cmdData->paras[1]); // The first parameter indicates the FD value.
sslConfig.connType = atoi(cmdData->paras[2]); // The second parameter indicates the link type.
// The third parameter of indicates the Ctrl command that needs to register the hook.
sslConfig.connPort = atoi(cmdData->paras[3]);
ret = HLT_TlsSetSsl(ssl, &sslConfig);
EXIT:
// Return the result.
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsListen(CmdData *cmdData)
{
int ret;
int sslId;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
sslId = strtol(cmdData->paras[0], NULL, 10); // Convert to a decimal number
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl == NULL) {
LOG_ERROR("Not Find Ssl");
ret = ERROR;
goto EXIT;
}
ret = HLT_TlsListenBlock(ssl);
EXIT:
// Return the result
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsAccept(CmdData *cmdData)
{
int ret;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
int sslId = atoi(cmdData->paras[0]);
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl == NULL) {
LOG_ERROR("Not Find Ssl");
ret = ERROR;
goto EXIT;
}
// If there is a problem, the user must use non-blocking, and the remote call must use blocking
ret = HLT_TlsAcceptBlock(ssl);
EXIT:
// Return the result
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsConnect(CmdData *cmdData)
{
int ret;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
int sslId = atoi(cmdData->paras[0]);
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl == NULL) {
LOG_ERROR("Not Find Ssl");
ret = ERROR;
goto EXIT;
}
ret = HLT_TlsConnect(ssl);
EXIT:
// Return the result
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsRead(CmdData *cmdData)
{
int ret = SUCCESS;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
int sslId = atoi(cmdData->paras[0]);
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl == NULL) {
LOG_ERROR("Not Find Ssl");
ret = ERROR;
goto ERR;
}
int dataLen = atoi(cmdData->paras[1]);
uint32_t readLen = 0;
if (dataLen == 0) {
LOG_ERROR("dataLen is 0");
ret = ERROR;
goto ERR;
}
uint8_t *data = (uint8_t *)calloc(1u, dataLen);
if (data == NULL) {
LOG_ERROR("Calloc Error");
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
}
(void)memset_s(data, dataLen, 0, dataLen);
ret = HLT_TlsRead(ssl, data, dataLen, &readLen);
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d|%u|%s",
cmdData->id, cmdData->funcId, ret, readLen, data);
free(data);
return SUCCESS;
ERR:
// Return the result
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d|", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsWrite(CmdData *cmdData)
{
int ret;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
int sslId = atoi(cmdData->paras[0]);
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl == NULL) {
LOG_ERROR("Not Find Ssl");
ret = ERROR;
goto ERR;
}
int dataLen = atoi(cmdData->paras[1]); // The first parameter indicates the data length.
if (dataLen == 0) {
LOG_ERROR("dataLen is 0");
ret = ERROR;
goto ERR;
}
uint8_t *data = (uint8_t *)calloc(1u, dataLen);
if (data == NULL) {
LOG_ERROR("Calloc Error");
ret = ERROR;
goto ERR;
}
if (dataLen >= CONTROL_CHANNEL_MAX_MSG_LEN) {
free(data);
goto ERR;
}
// The second parameter of indicates the content of the write data.
ret = memcpy_s(data, dataLen, cmdData->paras[2], dataLen);
if (ret != EOK) {
LOG_ERROR("memcpy_s Error");
free(data);
goto ERR;
}
ret = HLT_TlsWrite(ssl, data, dataLen);
free(data);
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
ERR:
// Return the result
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsRenegotiate(CmdData *cmdData)
{
int ret = ERROR;
ResList *sslList = GetSslList();
int sslId = (int)strtol(cmdData->paras[0], NULL, 10); // Convert to a decimal number
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl == NULL) {
LOG_ERROR("Not Find Ssl");
goto EXIT;
}
ret = HLT_TlsRenegotiate(ssl);
EXIT:
// Return the result
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsVerifyClientPostHandshake(CmdData *cmdData)
{
int ret = ERROR;
ResList *sslList = GetSslList();
int sslId = (int)strtol(cmdData->paras[0], NULL, 10); // Convert to a decimal number
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl == NULL) {
LOG_ERROR("Not Find Ssl");
goto EXIT;
}
ret = HLT_TlsVerifyClientPostHandshake(ssl);
EXIT:
// Return Result
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcProcessExit(CmdData *cmdData)
{
int ret;
// If 1 is returned, the process needs to exit
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, getpid());
ASSERT_RETURN(ret > 0);
return 1;
}
int RpcDataChannelAccept(CmdData *cmdData)
{
int sockFd, ret;
DataChannelParam channelParam;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
(void)memset_s(&channelParam, sizeof(DataChannelParam), 0, sizeof(DataChannelParam));
channelParam.type = atoi(cmdData->paras[0]);
channelParam.port = atoi(cmdData->paras[1]); // The first parameter of indicates the port number
channelParam.isBlock = atoi(cmdData->paras[2]); // The second parameter of indicates whether to block
channelParam.bindFd = atoi(cmdData->paras[3]); // The third parameter of indicates whether the cis blocked.
// Invoke the blocking interface
sockFd = RunDataChannelAccept(&channelParam);
// Return the result.
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, sockFd);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcDataChannelBind(CmdData *cmdData)
{
int sockFd, ret;
DataChannelParam channelParam;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
(void)memset_s(&channelParam, sizeof(DataChannelParam), 0, sizeof(DataChannelParam));
channelParam.type = atoi(cmdData->paras[0]);
channelParam.port = atoi(cmdData->paras[1]); // The first parameter of indicates the port number
channelParam.isBlock = atoi(cmdData->paras[2]); // The second parameter of indicates whether to block
channelParam.bindFd = atoi(cmdData->paras[3]); // The third parameter of indicates whether the cis blocked.
// Invoke the blocking interface
sockFd = RunDataChannelBind(&channelParam);
// Return the result.
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d|%d", cmdData->id, cmdData->funcId,
sockFd, channelParam.port);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcDataChannelConnect(CmdData *cmdData)
{
int ret, sockFd;
DataChannelParam channelParam;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
(void)memset_s(&channelParam, sizeof(DataChannelParam), 0, sizeof(DataChannelParam));
channelParam.type = atoi(cmdData->paras[0]);
channelParam.port = atoi(cmdData->paras[1]); // The first parameter of indicates the port number.
channelParam.isBlock = atoi(cmdData->paras[2]); // The second parameter of indicates whether the is blocked
sockFd = HLT_DataChannelConnect(&channelParam);
// Return the result.
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, sockFd);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsRegCallback(CmdData *cmdData)
{
int ret;
TlsCallbackType type;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
type = atoi(cmdData->paras[0]);
// Invoke the corresponding function
ret = HLT_TlsRegCallback(type);
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsGetStatus(CmdData *cmdData)
{
int ret, sslId;
uint32_t sslState = 0;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
sslId = atoi(cmdData->paras[0]);
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl != NULL) {
sslState = ((HITLS_Ctx *)ssl)->state;
}
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%u", cmdData->id, cmdData->funcId, sslState);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsGetAlertFlag(CmdData *cmdData)
{
int ret, sslId;
ALERT_Info alertInfo = {0};
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
sslId = atoi(cmdData->paras[0]);
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl != NULL) {
ALERT_GetInfo(ssl, &alertInfo);
}
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d",
cmdData->id, cmdData->funcId, alertInfo.flag);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsGetAlertLevel(CmdData *cmdData)
{
int ret, sslId;
ALERT_Info alertInfo = {0};
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
sslId = atoi(cmdData->paras[0]);
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl != NULL) {
ALERT_GetInfo(ssl, &alertInfo);
}
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d",
cmdData->id, cmdData->funcId, alertInfo.level);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsGetAlertDescription(CmdData *cmdData)
{
int ret, sslId;
ALERT_Info alertInfo = {0};
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
sslId = atoi(cmdData->paras[0]);
void *ssl = GetTlsResFromId(sslList, sslId);
if (ssl != NULL) {
ALERT_GetInfo(ssl, &alertInfo);
}
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d",
cmdData->id, cmdData->funcId, alertInfo.description);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsClose(CmdData *cmdData)
{
int ret, sslId;
void *ssl = NULL;
char *endPtr = NULL;
ASSERT_RETURN(memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result)) == EOK);
ResList *sslList = GetSslList();
sslId = (int)strtol(cmdData->paras[0], &endPtr, 0);
ssl = GetTlsResFromId(sslList, sslId);
ASSERT_RETURN(ssl != NULL);
ret = HLT_TlsClose(ssl);
// Return the result
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcFreeResFormSsl(CmdData *cmdData)
{
int ret, sslId;
void *ssl = NULL;
char *endPtr = NULL;
ASSERT_RETURN(memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result)) == EOK);
ResList *sslList = GetSslList();
sslId = (int)strtol(cmdData->paras[0], &endPtr, 0);
ssl = GetTlsResFromId(sslList, sslId);
ASSERT_RETURN(ssl != NULL);
ret = HLT_FreeResFromSsl(ssl);
// Return the result
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcCloseFd(CmdData *cmdData)
{
int ret, fd, linkType;
char *endPtr = NULL;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
fd = (int)strtol(cmdData->paras[0], &endPtr, 0);
linkType = (int)strtol(cmdData->paras[1], &endPtr, 0);
ret = SUCCESS;
HLT_CloseFd(fd, linkType);
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsSetMtu(CmdData *cmdData)
{
int ret, sslId;
uint16_t mtu;
void *ssl = NULL;
char *endPtr = NULL;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
sslId = (int)strtol(cmdData->paras[0], &endPtr, 0);
mtu = (int)strtol(cmdData->paras[1], &endPtr, 0);
ssl = GetTlsResFromId(sslList, sslId);
ASSERT_RETURN(ssl != NULL);
ret = HLT_TlsSetMtu(ssl, mtu);
ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
int RpcTlsGetErrorCode(CmdData *cmdData)
{
int sslId;
int errorCode;
void *ssl = NULL;
char *endPtr = NULL;
(void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
ResList *sslList = GetSslList();
sslId = (int)strtol(cmdData->paras[0], &endPtr, 0);
ssl = GetTlsResFromId(sslList, sslId);
ASSERT_RETURN(ssl != NULL);
errorCode = HLT_TlsGetErrorCode(ssl);
int ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, errorCode);
ASSERT_RETURN(ret > 0);
return SUCCESS;
}
|
2301_79861745/bench_create
|
testcode/framework/tls/rpc/src/rpc_func.c
|
C
|
unknown
| 23,838
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CONTROL_CHANNEL_H
#define CONTROL_CHANNEL_H
#include "channel_res.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Initialize the control channel
*/
int ControlChannelInit(ControlChannelRes *info);
/**
* @brief Close the control channel
*/
int ControlChannelClose(ControlChannelRes *info);
/**
* @brief Read data from the control channel
*/
int ControlChannelRead(int32_t sockFd, ControlChannelBuf *dataBuf);
/**
* @brief Write data to the control channel
*/
int ControlChannelWrite(int32_t sockFd, char *peerDomainPath, ControlChannelBuf *dataBuf);
/**
* @brief Control channel initiation
*/
int ControlChannelConnect(ControlChannelRes *info);
/**
* @brief The control channel waits for a connection
*/
int ControlChannelAccept(ControlChannelRes *info);
#ifdef __cplusplus
}
#endif
#endif // CONTROL_CHANNEL_H
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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;
}
|
2301_79861745/bench_create
|
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;
}
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
testcode/framework/tls/transfer/src/udp_channel.c
|
C
|
unknown
| 6,669
|
#!/bin/bash
# This file is part of the openHiTLS project.
#
# openHiTLS is licensed under the Mulan PSL v2.
# You can use this software according to the terms and conditions of the Mulan PSL v2.
# You may obtain a copy of Mulan PSL v2 at:
#
# http://license.coscl.org.cn/MulanPSL2
#
# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
# See the Mulan PSL v2 for more details.
# Build different miniaturized targets and perform basic functional testing.
set -eu
PARAM_LIST=$@
COMMON_PARAM=""
TEST=""
ASM_TYPE=""
CUR_DIR=`pwd`
HITLS_ROOT_DIR=`realpath $CUR_DIR/../../`
parse_option()
{
for i in $PARAM_LIST
do
case "${i}" in
"bsl"|"md"|"mac"|"kdf"|"cipher"|"bn"|"ecc"|"pkey"|"pki"|"all"|"tls"|"provider")
TEST=$i
;;
"x8664"|"armv8")
ASM_TYPE=$i
COMMON_PARAM="$COMMON_PARAM $i"
;;
"linux")
COMMON_PARAM="$COMMON_PARAM $i"
;;
"32")
COMMON_PARAM="$COMMON_PARAM $i"
;;
"big")
COMMON_PARAM="$COMMON_PARAM $i"
;;
*)
echo "Wrong parameter: $i"
exit 1
;;
esac
done
}
test_bsl()
{
if [ "$ASM_TYPE" != "" ]; then
echo "bsl does not support assembly."
return
fi
NO_LIB="no-crypto no-tls linux"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=asn1 test=asn1
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=base64 test=base64
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=buffer test=buffer
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=err test=err
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=hash test=hash
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=init test=init
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=list test=list
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=log test=log
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=obj test=obj
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=obj,hash,sal_thread test=obj # depends on thread to init hash
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=params test=params
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=pem test=pem
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=sal test=sal
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=sal_mem test=sal_mem
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=sal_thread test=sal_thread
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=sal_lock test=sal_lock
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=sal_time test=sal_time
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=sal_file test=sal_file
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=sal_net test=sal_net
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=sal_str test=sal_str
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=sal_dl test=sal_dl
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=tlv test=tlv
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=uio test=uio
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=uio_buffer
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=uio_mem
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=uio_sctp
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=uio_tcp
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=uio_udp
}
test_md()
{
NO_LIB="no-tls"
if [ "$ASM_TYPE" = "armv8" ]; then
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm3 test=sm3
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sha1 test=sha1
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sha2 test=sha2
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sha224 test=sha224
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sha256 test=sha256
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha384 test=sha384
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha512 test=sha512
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha3 test=sha3
elif [ "$ASM_TYPE" = "x8664" ]; then
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm3 test=sm3
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,md5 test=md5
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha1 test=sha1
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha2 test=sha2
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha224 test=sha224
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha256 test=sha256
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha384 test=sha384
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha512 test=sha512
else
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,md5 test=md5
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm3 test=sm3
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha1 test=sha1
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha2 test=sha2
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha224 test=sha224
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha256 test=sha256
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha384 test=sha384
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha512 test=sha512
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sha3 test=sha3
fi
}
test_mac()
{
if [ "$ASM_TYPE" != "" ]; then
echo "mac does not support assembly."
return
fi
NO_LIB="no-tls"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hmac,md5 test=hmac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hmac,sha1 test=hmac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hmac,sha2 test=hmac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hmac,sha224 test=hmac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hmac,sha256 test=hmac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hmac,sha384 test=hmac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hmac,sha512 test=hmac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hmac,sha3 test=hmac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hmac,sm3 test=hmac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,gmac test=gmac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,cmac_aes test=cmac_aes
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,cmac_sm4 test=cmac_sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,cbc_mac test=cbc_mac
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,siphash test=siphash
}
test_kdf()
{
if [ "$ASM_TYPE" != "" ]; then
echo "kdf does not support assembly."
return
fi
NO_LIB="no-tls"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,scrypt test=scrypt
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hkdf,md5 test=hkdf
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hkdf,sha1 test=hkdf
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hkdf,sha2 test=hkdf
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,pbkdf2,md5 test=pbkdf2
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,pbkdf2,sha1 test=pbkdf2
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,pbkdf2,sha2 test=pbkdf2
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,pbkdf2,sha3 test=pbkdf2
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,pbkdf2,sm3 test=pbkdf2
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,kdftls12,sha256 test=kdftls12
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,kdftls12,sha384 test=kdftls12
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,kdftls12,sha512 test=kdftls12
}
test_cipher()
{
NO_LIB="no-tls"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,aes,modes test=aes
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,aes,cbc test=aes
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,aes,ctr test=aes
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,aes,ecb test=aes # SDV_CRYPTO_AES_ENCRYPT_FUNC_TC001
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,aes,xts test=aes # SDV_CRYPTO_EAL_AES_FUNC_TC001
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,aes,ccm test=aes
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,aes,gcm test=aes
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,aes,cfb test=aes
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,aes,ofb test=aes
if [ "$ASM_TYPE" = "x8664" ]; then
# depends on ealinit
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sm4,modes test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sm4,xts test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sm4,cbc test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sm4,ecb test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sm4,ctr test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sm4,gcm test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sm4,cfb test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ealinit,sm4,ofb test=sm4
else
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm4,modes test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm4,xts test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm4,cbc test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm4,ecb test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm4,ctr test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm4,gcm test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm4,cfb test=sm4
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,sm4,ofb test=sm4
fi
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,chacha20 test=chacha20
}
test_bn()
{
NO_LIB="no-tls"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=bn
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=bn_basic
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal_bn
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=bn_rand
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=bn_prime
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=bn_str_conv
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=bn_cb
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=bn_prime_rfc3526
}
test_ecc()
{
NO_LIB="no-tls"
if [ "$ASM_TYPE" = "armv8" -o "$ASM_TYPE" = "x8664" ]; then
# The curves that support assembly are: curve_sm2, curve_nistp256
# all curves.
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,ecdh,ecdsa,sm2,drbg_hash,entropy,sha2,ecc,ealinit test=curve_nistp224 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
# sm2, depends on sm3
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,sm2,drbg_hash,entropy,ealinit test=sm2 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,sm2_crypt,drbg_hash,entropy,ealinit test=sm2_crypt add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,sm2_exch,drbg_hash,entropy,ealinit test=sm2_exch add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,sm2_sign,drbg_hash,entropy,ealinit test=sm2_sign add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
# nistp256
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,ecdh,ecdsa,drbg_hash,entropy,sha2,curve_nistp256,ealinit test=curve_nistp256 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
return
fi
# Test all curves.
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,ecdh,ecdsa,sm2,drbg_hash,entropy,sha2,ecc test=curve_nistp224 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
# nist224/256/384/521
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,ecdh,ecdsa,drbg_hash,entropy,sha2,curve_nistp224 test=curve_nistp224 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,ecdh,ecdsa,drbg_hash,entropy,sha2,curve_nistp256 test=curve_nistp256 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,ecdh,ecdsa,drbg_hash,entropy,sha2,curve_nistp384 test=curve_nistp384 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,ecdh,ecdsa,drbg_hash,entropy,sha2,curve_nistp521 test=curve_nistp521 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
# br256/384/512
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,ecdh,ecdsa,drbg_hash,entropy,sha2,curve_bp256r1 test=curve_bp256r1 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,ecdh,ecdsa,drbg_hash,entropy,sha2,curve_bp384r1 test=curve_bp384r1 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,ecdh,ecdsa,drbg_hash,entropy,sha2,curve_bp512r1 test=curve_bp512r1 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
# sm2 depends on sm3 by default.
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,sm2,drbg_hash,entropy test=sm2 add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,sm2_crypt,drbg_hash,entropy test=sm2_crypt add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,sm2_exch,drbg_hash,entropy test=sm2_exch add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,sm2_sign,drbg_hash,entropy test=sm2_sign add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
}
test_pkey()
{
NO_LIB="no-tls"
if [ "$ASM_TYPE" = "x8664" -o "$ASM_TYPE" = "armv8" ]; then
# The pkey that support assembly is: x25519.
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=x25519,sha2,ealinit
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,x25519,drbg_hash,sha2,ealinit test=x25519
return
fi
# rsa
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa,rsa_bssa,drbg_hash,sha1,sha2 test=rsa
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa,drbg_hash,sha1,sha2 test=rsa
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_gen,drbg_hash,sha1,sha2 test=rsa_gen
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_sign,rsa_emsa_pss,sha1,sha2,drbg_hash test=rsa_sign
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_sign,rsa_emsa_pss,drbg_hash,sha1,sha2 test=rsa_sign
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_sign,rsa_emsa_pkcsv15,sha1,sha2 test=rsa_sign # not need drbg
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_verify,rsa_emsa_pss,sha1,sha2 test=rsa_verify # not need drbg
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_verify,rsa_emsa_pkcsv15,sha1,sha2 test=rsa_verify # not need drbg
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_encrypt,rsa_no_pad,sha1,sha2 test=rsa_encrypt # not need drbg
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_encrypt,rsaes_oaep,drbg_hash,sha1,sha2 test=rsa_encrypt
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_encrypt,rsaes_pkcsv15,drbg_hash,sha1,sha2 test=rsa_encrypt
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_encrypt,rsaes_pkcsv15_tls,drbg_hash,sha1,sha2 test=rsa_encrypt
# rsa_decrypt: not need drbg
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_decrypt,rsa_no_pad,sha1,sha2 test=rsa_decrypt
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_decrypt,rsaes_oaep,sha1,sha2 test=rsa_decrypt
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_decrypt,rsaes_pkcsv15,sha1,sha2 test=rsa_decrypt
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_decrypt,rsaes_pkcsv15_tls,sha1,sha2 test=rsa_decrypt
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_sign,rsa_blinding,rsa_emsa_pkcsv15,drbg_hash,sha1,sha2 test=rsa_sign
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_decrypt,rsa_blinding,rsaes_oaep,drbg_hash,sha1,sha2 test=rsa_decrypt
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_sign,rsa_bssa,rsa_blinding,rsa_emsa_pss,drbg_hash,sha1,sha2 test=rsa_sign
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,rsa_sign,rsa_verify,rsa_bssa,rsa_emsa_pss,drbg_hash,sha1,sha2 test=rsa_sign
# dsa
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,eal_bn,dsa,drbg_hash,sha2 test=dsa
# dh
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,dh,drbg_hash,sha2 test=dh
# curve25519: ed25519 depends on sha512 by default.
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,x25519,drbg_hash,sha2 test=x25519
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,ed25519,drbg_hash,sha2 test=ed25519
# mldsa
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,mldsa,drbg_hash,sha2 test=mldsa
# paillier
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,paillier,drbg_hash,sha2 test=paillier
# mlkem
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,mlkem,drbg_hash,sha2 test=mlkem
# hybridkem
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,hybridkem,x25519,ecdh,ecc,drbg_hash,sha2 test=hybridkem
# elgamal
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,elgamal,drbg_hash,sha2 test=elgamal
# slh_dsa
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,slh_dsa,drbg_hash,sha2 test=slh_dsa
# xmss
bash mini_build_test.sh $COMMON_PARAM $NO_LIB enable=eal,xmss,slh_dsa,drbg_hash,sha2 test=xmss
}
test_tls()
{
NO_LIB=""
bash mini_build_test.sh $COMMON_PARAM $NO_LIB feature-config=tlcp_feature test=base,asn1,base64,buffer,err,hash,init,list,log,obj,params,pem,tlv,sal,sal_mem,sal_lock,sal_str,sal_file,sal_thread,sal_net,sal_time,aes,bn,chacha20,cmac_aes,drbg_ctr,drbg_hash,ecc,ecdh,ecdsa,entropy,gcm,hkdf,hpke,mlkem,mldsa,sha256,sha384,sha512,slh_dsa,sm2,sm3,sm4,x25519,curve_nistp256,curve_nistp384,curve_nistp521,x509_crl_gen,x509_crl_parse,x509_csr_gen,x509_csr_parse,x509_crt_gen,x509_crt_parse,x509_vfy,tlcp linux add-options="-DHITLS_SEED_DRBG_INIT_RAND_ALG=CRYPT_RAND_SHA256" add-options="-DHITLS_CRYPTO_ENTROPY_DEVRANDOM"
bash mini_build_test.sh $COMMON_PARAM $NO_LIB feature-config=nokem_feature test=base linux
bash mini_build_test.sh $COMMON_PARAM $NO_LIB feature-config=mtu_feature test=mtu linux
bash mini_build_test.sh $COMMON_PARAM $NO_LIB feature-config=max_send_fragment_feature test=max_send_fragment linux
bash mini_build_test.sh $COMMON_PARAM $NO_LIB feature-config=ca_list_feature test=ca_list linux
}
test_pki()
{
if [ "$ASM_TYPE" != "" ]; then
return
fi
bash mini_build_test.sh no-tls enable=eal,codecskey,rsa,drbg_hash,cipher,modes,sha256,hmac
bash mini_build_test.sh no-tls enable=eal,key_epki,key_encode,rsa,drbg_hash,cipher,modes,sha256,hmac
bash mini_build_test.sh no-tls enable=eal,key_encode,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,key_decode,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509_crt,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509_crt_gen,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509_crt_parse,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509_csr,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509_csr_gen,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509_csr_parse,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509_crl,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509_crl_gen,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509_crl_parse,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,x509_vfy,rsa,sha256,drbg_hash
bash mini_build_test.sh no-tls enable=eal,pkcs12,rsa,sha256,drbg_hash,md,cipher,modes,hmac
bash mini_build_test.sh no-tls enable=eal,pkcs12_gen,rsa,sha256,drbg_hash,md,cipher,modes,hmac
bash mini_build_test.sh no-tls enable=eal,pkcs12_parse,rsa,drbg_hash,md,cipher,modes,hmac
bash mini_build_test.sh no-tls enable=eal,info,x509_crt,rsa,drbg_hash,md,cipher,modes,hmac
### key gen ####
bash mini_build_test.sh no-tls enable=eal,key_encode,sal_file,pem,rsa,sha256,drbg_hash test=key_encode linux
bash mini_build_test.sh no-tls enable=eal,key_encode,pem,ed25519,drbg_hash test=key_encode
bash mini_build_test.sh no-tls enable=eal,key_encode,sal_file,sm2,sha256,drbg_hash test=key_encode linux
bash mini_build_test.sh no-tls enable=eal,key_encode,pem,ecdsa,curve_nistp256,sha256,drbg_hash test=key_encode
#### key parse ####
bash mini_build_test.sh no-tls enable=eal,key_decode,sal_file,pem,rsa,sha256,drbg_hash test=key_decode linux
bash mini_build_test.sh no-tls enable=eal,key_decode,sal_file,pem,ed25519 test=key_decode linux
bash mini_build_test.sh no-tls enable=eal,key_decode,sal_file,sm2,sha256 test=key_decode linux
bash mini_build_test.sh no-tls enable=eal,key_decode,sal_file,pem,ecdsa,curve_nistp256,sha256 test=key_decode linux
#### crl gen ####
bash mini_build_test.sh no-tls enable=eal,x509_crl_gen,rsa,sal_file,pem,sha256,drbg_hash test=x509_crl_gen linux
bash mini_build_test.sh no-tls enable=eal,x509_crl_gen,pem,ed25519,drbg_hash test=x509_crl_gen
bash mini_build_test.sh no-tls enable=eal,x509_crl_gen,sm2,sha256,drbg_hash test=x509_crl_gen
bash mini_build_test.sh no-tls enable=eal,x509_crl_gen,sal_file,ecdsa,curve_nistp256,sha256,drbg_hash test=x509_crl_gen linux
# #### crl parse ####
bash mini_build_test.sh no-tls enable=eal,x509_crl_parse,pem,sal_file,rsa,sha256,drbg_hash test=x509_crl_parse linux
bash mini_build_test.sh no-tls enable=eal,x509_crl_parse,sal_file,ed25519,sha256 test=x509_crl_parse linux
bash mini_build_test.sh no-tls enable=eal,x509_crl_parse,pem,sal_file,sm2,sha256 test=x509_crl_parse linux
bash mini_build_test.sh no-tls enable=eal,x509_crl_parse,sal_file,ecdsa,curve_nistp256,sha256 test=x509_crl_parse linux
#### csr gen ####
bash mini_build_test.sh no-tls enable=eal,x509_csr_gen,pem,rsa,sha256,drbg_hash test=x509_csr_gen
bash mini_build_test.sh no-tls enable=eal,x509_csr_gen,sal_file,ed25519,drbg_hash test=x509_csr_gen linux add-options="-DHITLS_CRYPTO_ED25519_CHECK"
bash mini_build_test.sh no-tls enable=eal,x509_csr_gen,sm2,sha256,drbg_hash test=x509_csr_gen
bash mini_build_test.sh no-tls enable=eal,x509_csr_gen,sal_file,pem,ecdsa,curve_nistp256,sha256,drbg_hash test=x509_csr_gen linux
#### csr parse ####
bash mini_build_test.sh no-tls enable=eal,x509_csr_parse,sal_file,rsa,sha256,drbg_hash test=x509_csr_parse linux
bash mini_build_test.sh no-tls enable=eal,x509_csr_parse,sal_file,pem,ed25519,drbg_hash test=x509_csr_parse linux
bash mini_build_test.sh no-tls enable=eal,x509_csr_parse,sal_file,pem,sm2,sha256,drbg_hash test=x509_csr_parse linux
bash mini_build_test.sh no-tls enable=eal,x509_csr_parse,sal_file,ecdsa,curve_nistp256,sha256,drbg_hash test=x509_csr_parse linux
#### cert gen ####
bash mini_build_test.sh no-tls enable=eal,x509_crt_gen,pem,rsa,sha256,drbg_hash test=x509_crt_gen
bash mini_build_test.sh no-tls enable=eal,x509_crt_gen,sal_file,pem,ed25519,drbg_hash test=x509_crt_gen linux
bash mini_build_test.sh no-tls enable=eal,x509_crt_gen,sal_file,sm2,sha256,drbg_hash test=x509_crt_gen linux
bash mini_build_test.sh no-tls enable=eal,x509_crt_gen,ecdsa,curve_nistp256,sha256,drbg_hash test=x509_crt_gen
### cert parse ####
bash mini_build_test.sh no-tls enable=eal,x509_crt_parse,sal_file,pem,rsa,sha256,drbg_hash test=x509_crt_parse linux
bash mini_build_test.sh no-tls enable=eal,x509_crt_parse,sal_file,ed25519,drbg_hash test=x509_crt_parse linux
bash mini_build_test.sh no-tls enable=eal,x509_crt_parse,sal_file,sm2,sha256,drbg_hash test=x509_crt_parse linux
bash mini_build_test.sh no-tls enable=eal,x509_crt_parse,sal_file,pem,ecdsa,curve_nistp256,curve_nistp384,sha256,drbg_hash test=x509_crt_parse linux
### cert chain ####
bash mini_build_test.sh no-tls enable=eal,x509_vfy,sal_file,pem,rsa,ecdsa,curve_nistp256,curve_nistp384,ed25519,sm2,sha2,drbg_hash test=x509_vfy linux
### pkcs12 gen ####
bash mini_build_test.sh no-tls enable=eal,pkcs12_gen,key_decode,sal_file,pem,rsa,ecdsa,curve_nistp256,ed25519,sm2,drbg_hash,cipher,modes,md,hmac test=pkcs12_gen linux
bash mini_build_test.sh no-tls enable=eal,pkcs12_parse,sal_file,pem,rsa,ecdsa,curve_nistp256,curve_nistp384,curve_nistp521,ed25519,sm2,cipher,modes,md,drbg_hash,hmac test=pkcs12_parse linux debug
}
provider_test_check()
{
set +e
nm $HITLS_ROOT_DIR/build/libhitls_crypto.a | grep CRYPT_SHA2_256_
if [ "$?" != "1" ]; then
echo "Error: CRYPT_SHA2_256_ is found in libhitls_crypto.a"
exit 1
fi
nm $HITLS_ROOT_DIR/build/libhitls_crypto.a | grep CRYPT_EAL_ProviderMdNewCtx
if [ "$?" != "0" ]; then
echo "Error: CRYPT_EAL_ProviderMdNewCtx is not found in libhitls_crypto.a"
exit 1
fi
}
test_provider()
{
include_path="-I${HITLS_ROOT_DIR}/testcode/script/mini_test_config"
NO_LIB="no-tls"
# sha256
bash mini_build_test.sh $COMMON_PARAM $NO_LIB linux enable=eal,provider 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,hmac test=provider add-options="-DHITLS_CONFIG_FILE='<test_config.h>'" include-path="${include_path}" add-options="-DHITLS_NO_CONFIG_CHECK"
provider_test_check
# hkdf
bash mini_build_test.sh $COMMON_PARAM $NO_LIB linux enable=eal,provider,hkdf test=provider add-options="-DHITLS_CONFIG_FILE='<test_config.h>'" include-path="${include_path}" add-options="-DHITLS_NO_CONFIG_CHECK"
provider_test_check
# pbkdf2
bash mini_build_test.sh $COMMON_PARAM $NO_LIB linux enable=eal,provider,pbkdf2 test=provider add-options="-DHITLS_CONFIG_FILE='<test_config.h>'" include-path="${include_path}" add-options="-DHITLS_NO_CONFIG_CHECK"
provider_test_check
# kdftls12
bash mini_build_test.sh $COMMON_PARAM $NO_LIB linux enable=eal,provider,kdftls12 test=provider add-options="-DHITLS_CONFIG_FILE='<test_config.h>'" include-path="${include_path}" add-options="-DHITLS_NO_CONFIG_CHECK"
provider_test_check
# rsa
bash mini_build_test.sh $COMMON_PARAM $NO_LIB linux enable=eal,provider,rsa,sm3,drbg_hash,entropy,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
|
2301_79861745/bench_create
|
testcode/script/all_mini_test.sh
|
Shell
|
unknown
| 30,102
|
#!/bin/bash
# This file is part of the openHiTLS project.
#
# openHiTLS is licensed under the Mulan PSL v2.
# You can use this software according to the terms and conditions of the Mulan PSL v2.
# You may obtain a copy of Mulan PSL v2 at:
#
# http://license.coscl.org.cn/MulanPSL2
#
# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
# See the Mulan PSL v2 for more details.
set -e
cd ../../
HITLS_ROOT_DIR=`pwd`
hitls_compile_option=()
paramList=$@
paramNum=$#
add_options=""
del_options=""
dis_options=""
get_arch=`arch`
executes="OFF"
LIB_TYPE="static shared"
enable_sctp="--enable-sctp"
BITS=64
subdir="CMVP"
libname=""
usage()
{
printf "%-50s %-30s\n" "Build openHiTLS Code" "sh build_hitls.sh"
printf "%-50s %-30s\n" "Build openHiTLS Code With Gcov" "sh build_hitls.sh gcov"
printf "%-50s %-30s\n" "Build openHiTLS Code With Debug" "sh build_hitls.sh debug"
printf "%-50s %-30s\n" "Build openHiTLS Code With Asan" "sh build_hitls.sh asan"
printf "%-50s %-30s\n" "Build openHiTLS Code With Pure C" "sh build_hitls.sh pure_c"
printf "%-50s %-30s\n" "Build openHiTLS Code With X86_64" "sh build_hitls.sh x86_64"
printf "%-50s %-30s\n" "Build openHiTLS Code With Armv8_be" "sh build_hitls.sh armv8_be"
printf "%-50s %-30s\n" "Build openHiTLS Code With Armv8_le" "sh build_hitls.sh armv8_le"
printf "%-50s %-30s\n" "Build openHiTLS Code With Add Options" "sh build_hitls.sh add-options=xxx"
printf "%-50s %-30s\n" "Build openHiTLS Code With No Provider" "sh build_hitls.sh no-provider"
printf "%-50s %-30s\n" "Build openHiTLS Code With No Sctp" "sh build_hitls.sh no_sctp"
printf "%-50s %-30s\n" "Build openHiTLS Code With Bits" "sh build_hitls.sh bits=xxx"
printf "%-50s %-30s\n" "Build openHiTLS Code With Lib Type" "sh build_hitls.sh shared"
printf "%-50s %-30s\n" "Build openHiTLS Code With Lib Fuzzer" "sh build_hitls.sh libfuzzer"
printf "%-50s %-30s\n" "Build openHiTLS Code With command line" "sh build_hitls.sh exe"
printf "%-50s %-30s\n" "Build openHiTLS Code With Iso Provider" "sh build_hitls.sh iso"
printf "%-50s %-30s\n" "Build openHiTLS Code With Help" "sh build_hitls.sh help"
}
clean()
{
rm -rf ${HITLS_ROOT_DIR}/build
mkdir ${HITLS_ROOT_DIR}/build
}
down_depend_code()
{
if [ ! -d "${HITLS_ROOT_DIR}/platform" ]; then
cd ${HITLS_ROOT_DIR}
mkdir platform
fi
if [ ! -d "${HITLS_ROOT_DIR}/platform/Secure_C/src" ]; then
cd ${HITLS_ROOT_DIR}/platform
git clone https://gitee.com/openeuler/libboundscheck.git Secure_C
fi
}
build_depend_code()
{
if [ ! -d "${HITLS_ROOT_DIR}/platform/Secure_C/lib" ]; then
mkdir -p ${HITLS_ROOT_DIR}/platform/Secure_C/lib
cd ${HITLS_ROOT_DIR}/platform/Secure_C
make -j
fi
}
build_hitls_code()
{
# Compile openHiTLS
cd ${HITLS_ROOT_DIR}/build
add_options="${add_options} -DHITLS_CRYPTO_RAND_CB" # HITLS_CRYPTO_RAND_CB: add rand callback
add_options="${add_options} -DHITLS_EAL_INIT_OPTS=9 -DHITLS_CRYPTO_ASM_CHECK" # Get CPU capability
add_options="${add_options} -DHITLS_CRYPTO_ENTROPY -DHITLS_CRYPTO_ENTROPY_DEVRANDOM -DHITLS_CRYPTO_ENTROPY_GETENTROPY -DHITLS_CRYPTO_ENTROPY_SYS -DHITLS_CRYPTO_ENTROPY_HARDWARE" # add default entropy
add_options="${add_options} -DHITLS_CRYPTO_DRBG_GM" # enable GM DRBG
add_options="${add_options} -DHITLS_CRYPTO_ACVP_TESTS" # enable ACVP tests
add_options="${add_options} -DHITLS_CRYPTO_DSA_GEN_PARA" # enable DSA genPara tests
add_options="${add_options} ${test_options}"
if [[ $get_arch = "x86_64" ]]; then
echo "Compile: env=x86_64, c, little endian, 64bits"
add_options="${add_options} -DHITLS_CRYPTO_SP800_STRICT_CHECK" # open the strict check in crypto.
del_options="${del_options} -DHITLS_CRYPTO_SM2_PRECOMPUTE_512K_TBL" # close the sm2 512k pre-table
if [[ $executes = "ON" ]]; then
add_options="${add_options} -DHITLS_CRYPTO_CMVP"
python3 ../configure.py --executes hitls --lib_type ${LIB_TYPE} --enable all --asm_type x8664 --add_options="$add_options" --del_options="$del_options" --add_link_flags="-ldl" ${enable_sctp} ${dis_options}
else
python3 ../configure.py --lib_type ${LIB_TYPE} --enable all --asm_type x8664 --add_options="$add_options" --del_options="$del_options" --add_link_flags="-ldl" ${enable_sctp} ${dis_options}
fi
elif [[ $get_arch = "armv8_be" ]]; then
echo "Compile: env=armv8, asm + c, big endian, 64bits"
python3 ../configure.py --lib_type ${LIB_TYPE} --enable all --endian big --asm_type armv8 --add_options="$add_options" --del_options="$del_options" --add_link_flags="-ldl" ${enable_sctp} ${dis_options}
elif [[ $get_arch = "armv8_le" ]]; then
echo "Compile: env=armv8, asm + c, little endian, 64bits"
python3 ../configure.py --lib_type ${LIB_TYPE} --enable all --asm_type armv8 --add_options="$add_options" --del_options="$del_options" --add_link_flags="-ldl" ${enable_sctp} ${dis_options}
else
echo "Compile: env=$get_arch, c, little endian, 64bits"
python3 ../configure.py --lib_type ${LIB_TYPE} --enable all --add_options="$add_options" --del_options="$del_options" --add_link_flags="-ldl" ${enable_sctp} ${dis_options}
fi
cmake ..
make -j
}
build_hitls_provider()
{
# Compile openHiTLS
cd ${HITLS_ROOT_DIR}/build
if [[ $libname = "libhitls_sm.so" ]] && [[ $get_arch = "armv8_le" ]]; then
config_file="${subdir}_sm_feature_config.json"
compile_file="${subdir}_sm_compile_config.json"
else
config_file="${subdir}_feature_config.json"
compile_file="${subdir}_compile_config.json"
fi
python3 ../configure.py --add_options="$add_options" --del_options="$del_options" \
--feature_config=./config/json/${subdir}/${get_arch}/${config_file} \
--compile=./config/json/${subdir}/${get_arch}/${compile_file} \
--lib_type=shared
cmake .. -DCMAKE_SKIP_RPATH=TRUE -DCMAKE_INSTALL_PREFIX=../output/${subdir}/${get_arch}
make -j
make install
cd ../output/${subdir}/${get_arch}/lib
mv libhitls.so $libname
mv libhitls.so.hmac $libname.hmac
}
parse_option()
{
for i in $paramList
do
key=${i%%=*}
value=${i#*=}
case "${key}" in
"add-options")
add_options="${add_options} ${value}"
;;
"no-provider")
dis_options="--disable feature_provider provider codecs"
;;
"gcov")
add_options="${add_options} -fno-omit-frame-pointer -fprofile-arcs -ftest-coverage -fdump-rtl-expand"
;;
"debug")
add_options="${add_options} -O0 -g3 -gdwarf-2"
del_options="${del_options} -O2 -D_FORTIFY_SOURCE=2"
;;
"asan")
add_options="${add_options} -fsanitize=address -fsanitize-address-use-after-scope -O0 -g3 -fno-stack-protector -fno-omit-frame-pointer -fgnu89-inline"
del_options="${del_options} -fstack-protector-strong -fomit-frame-pointer -O2 -D_FORTIFY_SOURCE=2"
;;
"x86_64")
get_arch="x86_64"
;;
"armv8_be")
get_arch="armv8_be"
;;
"armv8_le")
get_arch="armv8_le"
;;
"pure_c")
get_arch="C"
;;
"no_sctp")
enable_sctp=""
;;
"bits")
BITS="$value"
;;
"static")
LIB_TYPE="static"
;;
"shared")
LIB_TYPE="shared"
;;
"libfuzzer")
add_options="${add_options} -fsanitize=fuzzer-no-link -fsanitize=signed-integer-overflow -fsanitize-coverage=trace-cmp"
del_options="${del_options} -Wtrampolines -O2 -D_FORTIFY_SOURCE=2 -fstack-protector-strong -fomit-frame-pointer -fdump-rtl-expand"
export ASAN_OPTIONS=detect_stack_use_after_return=1:strict_string_checks=1:detect_leaks=1:log_path=asan.log
export CC=clang
;;
"exe")
executes="ON"
add_options="${add_options} -fno-plt"
;;
"iso")
add_options="${add_options} -DHITLS_CRYPTO_CMVP_ISO19790"
libname="libhitls_iso.so"
;;
"fips")
add_options="${add_options} -DHITLS_CRYPTO_CMVP_FIPS"
libname="libhitls_fips.so"
;;
"sm")
add_options="${add_options} -DHITLS_CRYPTO_CMVP_SM"
libname="libhitls_sm.so"
;;
"help")
usage
exit 0
;;
*)
echo "${i} option is not recognized, Please run <sh build_hitls.sh help> get supported options."
usage
exit 0
;;
esac
done
}
clean
parse_option
down_depend_code
build_depend_code
if [[ $libname != "" ]]; then
build_hitls_provider
else
build_hitls_code
fi
|
2301_79861745/bench_create
|
testcode/script/build_hitls.sh
|
Shell
|
unknown
| 9,604
|
#!/bin/bash
# This file is part of the openHiTLS project.
#
# openHiTLS is licensed under the Mulan PSL v2.
# You can use this software according to the terms and conditions of the Mulan PSL v2.
# You may obtain a copy of Mulan PSL v2 at:
#
# http://license.coscl.org.cn/MulanPSL2
#
# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
# See the Mulan PSL v2 for more details.
set -e
usage()
{
printf "\n"
printf "%-05s %-30s\n" "* Script :" "${BASH_SOURCE[0]}"
printf "%-50s %-30s\n" "* Usage Option :" ""
printf "%-50s %-30s\n" "* --help|-h : Help information." ""
printf "%-50s %-30s\n" "* add-options : Add options." "bash ${BASH_SOURCE[0]} add-options=xxx"
printf "%-50s %-30s\n" "* no-provider : Disable provider." "bash ${BASH_SOURCE[0]} no-provider"
printf "%-50s %-30s\n" "* tls-debug : Enable the debug mode." "bash ${BASH_SOURCE[0]} tls-debug"
printf "%-50s %-30s\n" "* no-crypto : Custom crypto testcase." "bash ${BASH_SOURCE[0]} no-crypto"
printf "%-50s %-30s\n" "* no-bsl : Custom bsl testcase." "bash ${BASH_SOURCE[0]} no-bsl"
printf "%-50s %-30s\n" "* no-tls : Custom tls testcase." "bash ${BASH_SOURCE[0]} no-tls"
printf "%-50s %-30s\n" "* no-pki : Custom pki testcase." "bash ${BASH_SOURCE[0]} no-pki"
printf "%-50s %-30s\n" "* no-auth : Custom auth testcase." "bash ${BASH_SOURCE[0]} no-auth"
printf "%-50s %-30s\n" "* no-demos : Not build demos." "bash ${BASH_SOURCE[0]} no-auth"
printf "%-50s %-30s\n" "* verbose : Show detailse." "bash ${BASH_SOURCE[0]} verbose"
printf "%-50s %-30s\n" "* gcov : Enable the coverage capability." "bash ${BASH_SOURCE[0]} gcov"
printf "%-50s %-30s\n" "* asan : Enabling the ASAN capability." "bash ${BASH_SOURCE[0]} asan"
printf "%-50s %-30s\n" "* big-endian : Specify the platform endianness." "bash ${BASH_SOURCE[0]} big-endian"
printf "%-50s %-30s\n" "* include-path : Specify the config file path." "bash ${BASH_SOURCE[0]} include-path=-Ixxx"
printf "%-50s %-30s\n\n" "* run-tests : Creating a custom test suite." "bash ${BASH_SOURCE[0]} run-tests=xxx1|xxx2|xxx3"
printf "%-50s %-30s\n" "* apps : Create apps testcase." "bash ${BASH_SOURCE[0]} apps"
}
export_env()
{
HITLS_ROOT_DIR=${HITLS_ROOT_DIR:=$(cd $(dirname ${BASH_SOURCE[0]})/../..;pwd)}
LOCAL_ARCH=${LOCAL_ARCH:=`arch`}
ENABLE_GCOV=${ENABLE_GCOV:=OFF}
ENABLE_ASAN=${ENABLE_ASAN:=OFF}
ENABLE_PRINT=${ENABLE_PRINT:=ON}
ENABLE_FAIL_REPEAT=${ENABLE_FAIL_REPEAT:=OFF}
CUSTOM_CFLAGS=${CUSTOM_CFLAGS:=''}
ENABLE_APP=${ENABLE_APP:=OFF}
ENABLE_TLS=${ENABLE_TLS:=ON}
BIG_ENDIAN=${BIG_ENDIAN:=OFF}
ENABLE_CRYPTO=${ENABLE_CRYPTO:=ON}
ENABLE_BSL=${ENABLE_BSL:=ON}
ENABLE_PKI=${ENABLE_PKI:=ON}
ENABLE_AUTH=${ENABLE_AUTH:=ON}
ENABLE_CMVP=${ENABLE_CMVP:=OFF}
ENABLE_DEMOS=${ENABLE_DEMOS:=ON}
ENABLE_UIO_SCTP=${ENABLE_UIO_SCTP:=ON}
ENABLE_VERBOSE=${ENABLE_VERBOSE:=''}
RUN_TESTS=${RUN_TESTS:=''}
DEBUG=${DEBUG:=ON}
if [ -f ${HITLS_ROOT_DIR}/build/macro.txt ];then
CUSTOM_CFLAGS=$(cat ${HITLS_ROOT_DIR}/build/macro.txt)
CUSTOM_CFLAGS="$CUSTOM_CFLAGS -D__FILENAME__=__FILE__"
fi
if [[ ! -e "${HITLS_ROOT_DIR}/testcode/output/log" ]]; then
mkdir ${HITLS_ROOT_DIR}/testcode/output/log
fi
}
down_depend_code()
{
if [ ! -d "${HITLS_ROOT_DIR}/platform/Secure_C/lib" ]; then
cd ${HITLS_ROOT_DIR}/platform/Secure_C
make -j
fi
}
find_test_suite()
{
if [[ ${ENABLE_CRYPTO} == "ON" ]]; then
crypto_testsuite=$(find ${HITLS_ROOT_DIR}/testcode/sdv/testcase/crypto -name "*.data" | sed -e "s/.data//" | tr -s "\n" " ")
crypto_testsuite=${crypto_testsuite}$(find ${HITLS_ROOT_DIR}/testcode/sdv/testcase/codecs -name "*.data" | sed -e "s/.data//" | tr -s "\n" " ")
fi
if [[ ${ENABLE_BSL} == "ON" ]]; then
bsl_testsuite=$(find ${HITLS_ROOT_DIR}/testcode/sdv/testcase/bsl -name "*.data" | sed -e "s/.data//" | tr -s "\n" " ")
fi
if [[ ${ENABLE_PKI} == "ON" ]]; then
pki_testsuite=$(find ${HITLS_ROOT_DIR}/testcode/sdv/testcase/pki -name "*.data" | sed -e "s/.data//" | tr -s "\n" " ")
fi
if [[ ${ENABLE_TLS} == "ON" ]]; then
proto_testsuite=$(find ${HITLS_ROOT_DIR}/testcode/sdv/testcase/tls -name "*.data" | sed -e "s/.data//" | tr -s "\n" " ")
fi
if [[ ${ENABLE_AUTH} == "ON" ]]; then
auth_testsuite=$(find ${HITLS_ROOT_DIR}/testcode/sdv/testcase/auth -name "*.data" | sed -e "s/.data//" | tr -s "\n" " ")
fi
if [[ ${ENABLE_CMVP} == "ON" ]]; then
cmvp_testsuite=$(find ${HITLS_ROOT_DIR}/testcode/sdv/testcase/cmvp -name "*.data" | sed -e "s/.data//" | tr -s "\n" " ")
fi
RUN_TEST_SUITES="${crypto_testsuite}${bsl_testsuite}${pki_testsuite}${proto_testsuite}${auth_testsuite}${cmvp_testsuite}"
if [[ ${ENABLE_APP} == "ON" ]]; then
apps_testsuite=$(find ${HITLS_ROOT_DIR}/testcode/sdv/testcase/apps -name "*.data" | sed -e "s/.data//" | tr -s "\n" " ")
RUN_TEST_SUITES="${apps_testsuite}"
fi
}
build_test_suite()
{
build_provider_so
[[ -n ${CASES} ]] && RUN_TEST_SUITES=${CASES}
cd ${HITLS_ROOT_DIR}/testcode && rm -rf ./build && mkdir build && cd build
cmake -DENABLE_GCOV=${ENABLE_GCOV} -DENABLE_ASAN=${ENABLE_ASAN} \
-DCUSTOM_CFLAGS="${CUSTOM_CFLAGS}" -DDEBUG=${DEBUG} -DENABLE_UIO_SCTP=${ENABLE_UIO_SCTP} \
-DGEN_TEST_FILES="${RUN_TEST_SUITES}" -DENABLE_TLS=${ENABLE_TLS} \
-DENABLE_CRYPTO=${ENABLE_CRYPTO} -DENABLE_PKI=${ENABLE_PKI} -DENABLE_AUTH=${ENABLE_AUTH} \
-DTLS_DEBUG=${TLS_DEBUG} -DOS_BIG_ENDIAN=${BIG_ENDIAN} -DPRINT_TO_TERMINAL=${ENABLE_PRINT} \
-DENABLE_FAIL_REPEAT=${ENABLE_FAIL_REPEAT} -DAPPS=${ENABLE_APP} ..
make -j
}
# Function: Compile provider .so file
build_provider_so()
{
cd ${HITLS_ROOT_DIR}/testcode/testdata/provider
mkdir -p build && cd build
cmake ..
make -j
}
process_custom_cases()
{
if [[ -n "${RUN_TESTS}" ]];then
local tmp=($(echo "${RUN_TESTS}" | tr -s "|" " "))
for i in ${!tmp[@]}
do
local suite=$(find ${HITLS_ROOT_DIR}/testcode/sdv -name "${tmp[i]}.data" | sed -e "s/.data//")
[[ -z "${suite}" ]] && echo "not found testsuite:${tmp[i]}"
[[ -n "${suite}" ]] && CASES="${suite} ${CASES}"
done
fi
}
build_demos()
{
if [[ ${ENABLE_DEMOS} == "OFF" ]]; then
return
fi
pushd ${HITLS_ROOT_DIR}/testcode/demo/
rm -rf build && mkdir build
pushd build
cmake -DENABLE_GCOV=${ENABLE_GCOV} -DCUSTOM_CFLAGS="${CUSTOM_CFLAGS}" -DENABLE_ASAN=${ENABLE_ASAN} ../
make -j
popd
popd
}
clean()
{
rm -rf ${HITLS_ROOT_DIR}/testcode/output/log
rm -rf ${HITLS_ROOT_DIR}/testcode/output/test_suite*
rm -rf ${HITLS_ROOT_DIR}/testcode/output/asan.*
rm -rf ${HITLS_ROOT_DIR}/testcode/output/*.log
rm -rf ${HITLS_ROOT_DIR}/testcode/output/*.xml
rm -rf ${HITLS_ROOT_DIR}/testcode/output/gen_testcase
rm -rf ${HITLS_ROOT_DIR}/testcode/output/process
rm -rf ${HITLS_ROOT_DIR}/testcode/framework/tls/build
rm -rf ${HITLS_ROOT_DIR}/testcode/build
rm -rf ${HITLS_ROOT_DIR}/testcode/sdv/build
rm -rf ${HITLS_ROOT_DIR}/testcode/framework/process/build
rm -rf ${HITLS_ROOT_DIR}/testcode/framework/gen_test/build
rm -rf ${HITLS_ROOT_DIR}/testcode/testdata/provider/build
rm -rf ${HITLS_ROOT_DIR}/testcode/testdata/provider/path1
rm -rf ${HITLS_ROOT_DIR}/testcode/testdata/provider/path2
mkdir ${HITLS_ROOT_DIR}/testcode/output/log
}
options()
{
while [[ -n $1 ]]
do
key=${1%%=*}
value=${1#*=}
case ${key} in
add-options)
CUSTOM_CFLAGS="${CUSTOM_CFLAGS} ${value}"
;;
no-provider)
dis_options="--disable feature_provider provider codecs"
;;
tls-debug)
TLS_DEBUG=ON
;;
gcov)
ENABLE_GCOV=ON
;;
asan)
ENABLE_ASAN=ON
;;
no-print)
ENABLE_PRINT=OFF
;;
no-crypto)
ENABLE_CRYPTO=OFF
;;
no-pki)
ENABLE_PKI=OFF
;;
no-auth)
ENABLE_AUTH=OFF
;;
no-bsl)
ENABLE_BSL=OFF
;;
no-tls)
ENABLE_TLS=OFF
;;
no-demos)
ENABLE_DEMOS=OFF
;;
no-sctp)
ENABLE_UIO_SCTP=OFF
;;
no-demos)
ENABLE_DEMOS=OFF
;;
verbose)
ENABLE_VERBOSE='VERBOSE=1'
;;
fail-repeat)
ENABLE_FAIL_REPEAT=ON
;;
run-tests)
RUN_TESTS=${value}
;;
big-endian)
BIG_ENDIAN=ON
;;
include-path)
CUSTOM_CFLAGS="${CUSTOM_CFLAGS} ${value}"
;;
apps)
ENABLE_APP=ON
;;
--help|-h)
usage
exit 0
;;
*)
usage
exit 1
;;
esac
shift
done
}
export_env
options "$@"
clean
down_depend_code
find_test_suite
process_custom_cases
build_test_suite
if [[ ${ENABLE_DEMOS} == "ON" ]]; then
build_demos
fi
|
2301_79861745/bench_create
|
testcode/script/build_sdv.sh
|
Shell
|
unknown
| 10,063
|
#!/bin/bash
# This file is part of the openHiTLS project.
#
# openHiTLS is licensed under the Mulan PSL v2.
# You can use this software according to the terms and conditions of the Mulan PSL v2.
# You may obtain a copy of Mulan PSL v2 at:
#
# http://license.coscl.org.cn/MulanPSL2
#
# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
# See the Mulan PSL v2 for more details.
elapsed=0
cd ../../
HITLS_ROOT_DIR=`pwd`
paramList=$@
paramNum=$#
is_concurrent=1
need_run_all=1
threadsNum=$(grep -c ^processor /proc/cpuinfo)
testsuite_array=()
testcase_array=()
export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:$(realpath ${HITLS_ROOT_DIR}/build):$(realpath ${HITLS_ROOT_DIR}/platform/Secure_C/lib)
# Check whether an ASAN alarm is generated.
generate_asan_log() {
ASAN_LOG=$(find ../output -name "asan.log*")
if [ ! -z "$ASAN_LOG" ]; then
for i in $ASAN_LOG
do
if grep -q "ASan doesn't fully support makecontext/swapcontext" $i
then
line_count=$(wc -l < "$i")
if [ "$line_count" -eq 1 ]; then
echo "The ASAN log contains only ucontext warning content. Ignore it."
else
echo "ASAN ERROR. Exit with ucontext check failure."
cat ${i}
exit 1
fi
continue
else
echo "ASAN ERROR. Exit with failure."
cat ${i}
exit 1
fi
done
fi
}
# Run the specified test suites or test cases in the output directory.
run_test() {
cd ${HITLS_ROOT_DIR}/testcode/output
export ASAN_OPTIONS=detect_stack_use_after_return=1:strict_string_checks=1:detect_leaks=1:halt_on_error=0:detect_odr_violation=0:log_path=asan.log
echo ""
echo "Begin Test"
echo ".................................................."
start_time=$(date +%s)
# Run the specified test suite.
if [ ${#testsuite_array[*]} -ne 0 ] && [ ${#testcase_array[*]} -eq 0 ];then
for i in ${testsuite_array[@]}
do
if [ "${i}" = "test_suite_sdv_eal_provider_load" ]; then
# 针对特定测试套件设置 LD_LIBRARY_PATH
echo "Running ${i} with LD_LIBRARY_PATH set to ../testdata/provider/path1"
env LD_LIBRARY_PATH="../testdata/provider/path1:${LD_LIBRARY_PATH}" ./${i} NO_DETAIL
else
# 其他测试套件正常运行
./${i} NO_DETAIL
fi
done
fi
# Run the specified test case.
if [ ${#testcase_array[*]} -ne 0 ];then
num=0
for i in ${testcase_array[@]}
do
./${testsuite_array[num]} ${i}
let num+=1
done
fi
end_time=$(date +%s)
elapsed=$((end_time - start_time))
generate_asan_log
}
gen_test_report()
{
cd ${HITLS_ROOT_DIR}/testcode/output
./gen_testcase GenReport
testcase_num=0
pass_num=0
skip_num=0
while read line
do
array=(${line})
last_index=$((${#array[@]}-1))
if [ "${array[last_index]}" = "PASS" ]; then
let pass_num+=1
elif [ "${array[last_index]}" = "SKIP" ]; then
let skip_num+=1
fi
let testcase_num+=1
done < result.log
fail_num=`expr $testcase_num - $pass_num - $skip_num`
SumTime=`echo "$elapsed 60" |awk '{printf("%.2f",$1/$2)}'`
echo "SumTime is ${SumTime} mintues TestCase Num is ${testcase_num} Pass is ${pass_num} Skip is ${skip_num} Fail is ${fail_num}"
if [ ${fail_num} -ne 0 ]; then
exit 1
fi
}
# Run all tests in the output directory.
run_all() {
start_time=$(date +%s)
echo "Test: $1" >> ${HITLS_ROOT_DIR}/testcode/output/time.txt
echo "Start: $(date)" >> ${HITLS_ROOT_DIR}/testcode/output/time.txt
cd ${HITLS_ROOT_DIR}/testcode/output
SUITES=$(ls ./ | grep .datax | sed -e "s/.datax//")
export ASAN_OPTIONS=detect_stack_use_after_return=1:strict_string_checks=1:detect_leaks=1:halt_on_error=0:detect_odr_violation=0:log_path=asan.log
echo ""
echo "Begin Test"
echo ".................................................."
if [ $is_concurrent = 1 ]; then
mkfifo tmppipe
exec 5<>tmppipe
rm -f tmppipe
echo "threadsNum = $threadsNum"
# procNum indicates the maximum number of concurrent processes.
for ((i=1;i<=$threadsNum;i++)); do
echo >&5
done
retPipe=$tmpPipe.ret
mkfifo $retPipe
exec 8<>$retPipe
rm -f $retPipe
echo "0" >&8
for i in $SUITES
do
# Run tests in parallel.
read -u5
{
if [ "${i}" = "test_suite_sdv_eal_provider_load" ]; then
echo "Running ${i} with LD_LIBRARY_PATH set to ../testdata/provider/path1"
env LD_LIBRARY_PATH="../testdata/provider/path1:${LD_LIBRARY_PATH}" ./${i} NO_DETAIL || (read -u8 && echo "1 $i" >&8)
else
./${i} NO_DETAIL || (read -u8 && echo "1 $i" >&8)
fi
echo >&5
} &
done
wait
exec 5>&-
exec 5<&-
read -u8 ret
exec 8<&-
if [ "$ret" != "0" ];then
echo "some case failed $ret"
gen_test_report
generate_asan_log
exit 1
fi
else
for i in $SUITES
do
if [ "${i}" = "test_suite_sdv_eal_provider_load" ]; then
echo "Running ${i} with LD_LIBRARY_PATH set to ../testdata/provider/path1"
env LD_LIBRARY_PATH="../testdata/provider/path1:${LD_LIBRARY_PATH}" ./${i} NO_DETAIL
else
./${i} NO_DETAIL
fi
done
fi
end_time=$(date +%s)
echo "End: $(date)" >> time.txt
elapsed=$((end_time - start_time))
eval "echo Elapsed time: $(date -ud "@$elapsed" +'$((%s/3600/24)) days %H hr %M min %S sec') >> time.txt"
generate_asan_log
}
parse_testsuite_testcase()
{
cd ${HITLS_ROOT_DIR}/testcode/output
testsuite_name="test_suite"
if [[ "$1" == *$testsuite_name* ]]; then
if [ -f "$1" ]; then
testsuite_array[${#testsuite_array[*]}]=$i
return 1
fi
return 0
else
testsuite=`grep -l $1 *.c`
if [ "${testsuite}" = "" ]; then
return 0
else
array=(${testsuite//./ })
testsuite_array[${#testcase_array[*]}]="${array[0]}"
testcase_array[${#testcase_array[*]}]="$1"
return 1
fi
fi
}
parse_option()
{
for i in $paramList
do
case "$i" in
"help")
printf "Note: Before Run <sh ${BASH_SOURCE[0]}>, Please Fisrt Run <sh build_hitls.sh && sh build_sdv.sh>"
printf "%-50s %-30s\n" "Run All Testsuites Of The Output" "sh ${BASH_SOURCE[0]}"
printf "%-50s %-30s\n" "Run The Specified Testsuite" "sh ${BASH_SOURCE[0]} test_suites_xxx test_suites_xxx"
printf "%-50s %-30s\n" "Run The Specified Testcase" "sh ${BASH_SOURCE[0]} UT_CRYPTO_xxx SDV_CRYPTO_xxx"
printf "%-50s %-30s\n" "Set Thread Pool Size" "sh ${BASH_SOURCE[0]} threads=N"
printf "%-50s %-30s\n" "Example: Run with 4 threads" "sh ${BASH_SOURCE[0]} threads=4"
exit 0
;;
"threads"*)
threads_num=${i#*=}
threadsNum=$threads_num
;;
*)
parse_testsuite_testcase $i
if [ $? -eq 0 ]; then
echo "Not Find This Testsuite or Testcase : ${i}"
exit 1
fi
need_run_all=0
;;
esac
done
}
run_demos()
{
exit_code=$?
pushd ${HITLS_ROOT_DIR}/testcode/demo/build
executales=$(find ./ -maxdepth 1 -type f -perm -a=x )
for e in $executales
do
if [[ ! "$e" == *"client"* ]] && [[ ! "$e" == *"server"* ]]; then
echo "${e} start"
eval "${e}"
if [ $exit_code -ne 0 ]; then
echo "Demo ${e} failed"
exit 1
fi
fi
done
# run server and client in order.
./server &
if [ $exit_code -ne 0 ]; then
echo "Demo ${e} failed"
exit 1
fi
sleep 1
./client
if [ $exit_code -ne 0 ]; then
echo "Demo ${e} failed"
exit 1
fi
# run tlcp server and client in order.
./tlcp_server &
if [ $exit_code -ne 0 ]; then
echo "Demo ${e} failed"
exit 1
fi
sleep 1
./tlcp_client
if [ $exit_code -ne 0 ]; then
echo "Demo ${e} failed"
exit 1
fi
popd
}
clean()
{
rm -rf ${HITLS_ROOT_DIR}/testcode/output/log/*
rm -rf ${HITLS_ROOT_DIR}/testcode/output/result.log
rm -rf ${HITLS_ROOT_DIR}/testcode/output/*.sock*
rm -rf ${HITLS_ROOT_DIR}/testcode/output/asan*
}
clean
parse_option
if [ ${need_run_all} -eq 1 ]; then
run_all
run_demos
else
run_test
fi
gen_test_report
|
2301_79861745/bench_create
|
testcode/script/execute_sdv.sh
|
Shell
|
unknown
| 9,379
|
#!/bin/bash
# This file is part of the openHiTLS project.
#
# openHiTLS is licensed under the Mulan PSL v2.
# You can use this software according to the terms and conditions of the Mulan PSL v2.
# You may obtain a copy of Mulan PSL v2 at:
#
# http://license.coscl.org.cn/MulanPSL2
#
# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
# See the Mulan PSL v2 for more details.
# Build different miniaturized targets and perform basic functional testing.
set -eu
PARAM_LIST=$@
CUR_DIR=`pwd`
HITLS_ROOT_DIR=`realpath $CUR_DIR/../../`
HITLS_BUILD_DIR=$HITLS_ROOT_DIR/build
FEATURES=()
TEST_FEATURE=""
BUILD_HITLS="on"
EXE_TEST="on"
SHOW_SIZE="on" # size libhitls_*.a
SHOW_MACRO="off"
ASM_TYPE=""
NO_LIB=""
LIB_TYPE="static"
DEBUG="off"
ADD_OPTIONS=""
DEL_OPTIONS=""
SYSTEM=""
BITS=64
ENDIAN="little"
FEATURE_CONFIG_FILE=""
INCLUDE_PATH=""
print_usage() {
printf "Usage: $0\n"
printf " %-25s %s\n" "help" "Print this help."
printf " %-25s %s\n" "macro" "INFO: Obtains the macro of the hitls."
printf " %-25s %s\n" "no-size" "INFO: Do not list the detail of the object files in static libraries."
printf " %-25s %s\n" "no-build" "BUILD: Do not build hitls."
printf " %-25s %s\n" "enable=a;b;c" "BUILD: Specify the features of the build."
printf " %-25s %s\n" "x8664|armv8" "BUILD: Specify the type of assembly to build."
printf " %-25s %s\n" "linux|dopra" "BUILD: Specify the type of system to build."
printf " %-25s %s\n" "32" "BUILD: Specify the number of system bits to 32, default is 64."
printf " %-25s %s\n" "big" "BUILD: Specify the endian mode of the system to big, default is little."
printf " %-25s %s\n" "debug" "BUILD: Build HiTLS with debug flags."
printf " %-25s %s\n" "asan" "BUILD: Build HiTLS with asan flags."
printf " %-25s %s\n" "test=a" "TEST: Specify the feature for which the test is to be performed."
printf " %-25s %s\n" "no-tls" "TEST: Do not link hitls_tls related libraries."
printf " %-25s %s\n" "no-crypto" "TEST: Do not link hitls_crypto related libraries."
printf " %-25s %s\n" "no-mpa" "TEST: Do not link hitls_mpa related libraries."
printf " %-25s %s\n" "no-exe-test" "TEST: Do not exe tests."
printf "\nexample:\n"
printf " %-50s %-30s\n" "bash mini_build_test.sh enable=sha1,sha2,sha3 test=sha1,sha3" "Build sha1, sha2 and sha3, test sha1 and sha2."
printf " %-50s %-30s\n" "bash mini_build_test.sh enable=sha1,sm3 armv8" "Build sha1 and sm3 and enable armv8 assembly."
}
parse_option()
{
for i in $PARAM_LIST
do
key=${i%%=*}
value=${i#*=}
case "${key}" in
"help")
print_usage
exit 0;
;;
"macro")
SHOW_MACRO="on"
ADD_OPTIONS="${ADD_OPTIONS} -E -dM"
LIB_TYPE="static"
;;
"no-size")
SHOW_SIZE="off"
;;
"no-build")
BUILD_HITLS="off"
;;
"x8664"|"armv8")
ASM_TYPE=$key
;;
"linux"|"dopra")
SYSTEM=$key
;;
"32")
BITS=32
;;
"big")
ENDIAN="big"
;;
"enable")
FEATURES=(${value//,/ })
;;
"debug")
ADD_OPTIONS="$ADD_OPTIONS -O0 -g3 -gdwarf-2"
DEL_OPTIONS="$DEL_OPTIONS -O2 -D_FORTIFY_SOURCE=2"
;;
"asan")
ADD_OPTIONS="$ADD_OPTIONS -fsanitize=address -fsanitize-address-use-after-scope -O0 -g3 -fno-stack-protector -fno-omit-frame-pointer -fgnu89-inline"
DEL_OPTIONS="$DEL_OPTIONS -fstack-protector-strong -fomit-frame-pointer -O2 -D_FORTIFY_SOURCE=2"
;;
"feature-config")
# First try to find file with ASM_TYPE suffix
if [ -n "$ASM_TYPE" ]; then
FEATURE_CONFIG_FILE=$(find $HITLS_ROOT_DIR -name "${value}_${ASM_TYPE}.json" -type f | head -n 1)
fi
# If not found with suffix, try the original filename
if [ -z "$FEATURE_CONFIG_FILE" ]; then
FEATURE_CONFIG_FILE=$(find $HITLS_ROOT_DIR -name "${value}.json" -type f | head -n 1)
fi
if [ -z "$FEATURE_CONFIG_FILE" ]; then
echo "Error: Cannot find feature config file '${value}.json' or '${value}.json' under $HITLS_ROOT_DIR"
exit 1
fi
;;
"test")
LIB_TYPE="static shared"
TEST_FEATURE=$value
if [[ $value == *cmvp* ]]; then
ADD_OPTIONS="$ADD_OPTIONS -DHITLS_CRYPTO_DRBG_GM -DHITLS_CRYPTO_CMVP_INTEGRITY"
fi
;;
"no-exe-test")
EXE_TEST="off"
;;
"no-tls")
NO_LIB="$NO_LIB no-tls"
;;
"no-crypto")
NO_LIB="$NO_LIB no-crypto"
;;
"no-mpa")
NO_LIB="$NO_LIB no-mpa"
;;
"add-options")
ADD_OPTIONS="$ADD_OPTIONS $value"
;;
"include-path")
INCLUDE_PATH="$value $INCLUDE_PATH "
ADD_OPTIONS="$ADD_OPTIONS $value"
;;
*)
echo "Wrong parameter: $key"
exit 1
;;
esac
done
}
show_size()
{
cd $HITLS_BUILD_DIR
libs=`find -name '*.a'`
echo "$libs"
array=(${libs//\n/ })
for lib in ${array[@]}
do
ls -lh ${lib}
echo -e ""
size ${lib} | grep -v "0 0 0 0 0"
done
}
show_macro()
{
cd ${HITLS_BUILD_DIR}
grep "#define HITLS_" libhitls_bsl.a | grep -v HITLS_VERSION |awk '{print $2}' > macro_new.txt
sort macro_new.txt | uniq >unique_macro.txt
cat unique_macro.txt
}
process_feature_config()
{
local config_file="$1"
local endian="$2"
local bits="$3"
local asm_type="$4"
local build_dir="$5"
python3 - "$config_file" "$endian" "$bits" "$asm_type" "$build_dir" <<END
#!/usr/bin/env python
import json
import sys
import os
if __name__ == "__main__":
config_file = sys.argv[1]
endian = sys.argv[2]
bits = int(sys.argv[3])
asm_type = sys.argv[4] if len(sys.argv) > 4 and sys.argv[4] else None
build_dir = sys.argv[5]
# Read the current config
with open(config_file, 'r') as f:
config = json.load(f)
# Update the fields
config['endian'] = endian
config['bits'] = bits
if asm_type:
config['asmType'] = asm_type
else:
# If no asm_type is defined, remove the "asm" field from hitls_crypto
config['asmType'] = "no_asm"
if 'libs' in config and 'hitls_crypto' in config['libs'] and 'asm' in config['libs']['hitls_crypto']:
del config['libs']['hitls_crypto']['asm']
# Create build directory if it doesn't exist
os.makedirs(build_dir, exist_ok=True)
# Save to build directory
output_file = os.path.join(build_dir, 'feature_config_modified.json')
with open(output_file, 'w') as f:
json.dump(config, f, indent=4)
# Print the output file path for the shell script to use
print(output_file)
END
}
mini_config()
{
enables="--enable"
for feature in ${FEATURES[@]}
do
enables="$enables $feature"
done
if [ "$FEATURE_CONFIG_FILE" != "" ]; then
MODIFIED_CONFIG_FILE=$(process_feature_config "$FEATURE_CONFIG_FILE" "$ENDIAN" "$BITS" "$ASM_TYPE" "$HITLS_ROOT_DIR/build/")
enables="--feature_config $MODIFIED_CONFIG_FILE"
fi
echo "python3 configure.py --lib_type $LIB_TYPE $enables --endian=$ENDIAN --bits=$BITS"
python3 $HITLS_ROOT_DIR/configure.py --lib_type $LIB_TYPE $enables --endian=$ENDIAN --bits=$BITS
if [ "$ASM_TYPE" != "" ]; then
echo "python3 configure.py --asm_type $ASM_TYPE"
python3 $HITLS_ROOT_DIR/configure.py --asm_type $ASM_TYPE
fi
if [ "$SYSTEM" != "" ]; then
echo "python3 configure.py --system $SYSTEM"
python3 $HITLS_ROOT_DIR/configure.py --system $SYSTEM
fi
if [ "$ADD_OPTIONS" != "" -o "$DEL_OPTIONS" != "" ]; then
echo "python3 configure.py --add_options=\"$ADD_OPTIONS\" --del_options=\"$DEL_OPTIONS\""
python3 $HITLS_ROOT_DIR/configure.py --add_options="$ADD_OPTIONS" --del_options="$DEL_OPTIONS"
fi
}
check_cmd_res()
{
if [ "$?" -ne "0" ]; then
echo "Error: $1"
exit 1
fi
}
build_hitls()
{
# cleanup
cd $HITLS_ROOT_DIR
rm -rf $HITLS_BUILD_DIR
mkdir $HITLS_BUILD_DIR
cd $HITLS_BUILD_DIR
# config
mini_config
check_cmd_res "configure.py"
# cmake ..
cmake .. > cmake.txt
# cmake ..
check_cmd_res "cmake .."
# make
make -j > make.txt
check_cmd_res "make -j"
}
get_testfiles_by_features()
{
cd $HITLS_ROOT_DIR/testcode/test_config
# 参数：被测试的特性列表（以逗号分隔）
python3 - "$1" <<END
#!/usr/bin/env python
import os, sys, json
if __name__ == "__main__":
with open('crypto_test_config.json', 'r') as f:
test_config1 = json.loads(f.read())
with open('tls_test_config.json', 'r') as f:
test_config2 = json.loads(f.read())
files = set()
for fea in sys.argv[1].split(","):
files.update(test_config1['testFeatures'].get(fea, ''))
files.update(test_config2['testFeatures'].get(fea, ''))
sys.stdout.write('%s' % '|'.join(files))
END
}
get_testcases_by_testfile()
{
cd $HITLS_ROOT_DIR/testcode/test_config/
# 参数：测试文件，获取需执行的测试用例
python3 - "$1" <<END
#!/usr/bin/env python
import os, sys, json
if __name__ == "__main__":
with open('crypto_test_config.json', 'r') as f:
test_config1 = json.loads(f.read())
with open('tls_test_config.json', 'r') as f:
test_config2 = json.loads(f.read())
if sys.argv[1] not in test_config1['testSuiteCases'] and sys.argv[1] not in test_config2['testSuiteCases']:
raise ValueError('The test case of file %s is not configured in file crypto_test_config.json or tls_test_config.json.'% sys.argv[1])
cases = set()
if sys.argv[1] in test_config1['testSuiteCases']:
cases.update(test_config1['testSuiteCases'][sys.argv[1]])
if sys.argv[1] in test_config2['testSuiteCases']:
cases.update(test_config2['testSuiteCases'][sys.argv[1]])
sys.stdout.write('%s' % ' '.join(cases))
END
}
exe_file_testcases()
{
test_file=$1
# Get test cases according to test file.
cd $HITLS_ROOT_DIR/testcode/script
test_cases=`get_testcases_by_testfile $test_file`
echo "test cases: $test_cases"
cd $HITLS_ROOT_DIR/testcode/output
./$test_file ${test_cases} NO_DETAIL
check_cmd_res "exe $test_file failed"
}
test_feature()
{
features=$1
cd $HITLS_ROOT_DIR/testcode/script
files=`get_testfiles_by_features $features`
echo "files: $files"
if [ -z $files ]; then
return
fi
params=""
if [ "$INCLUDE_PATH" != "" ]; then
params="${params} include-path=$INCLUDE_PATH"
fi
bash build_sdv.sh run-tests="$files" $NO_LIB no-demos no-sctp $params
if [ $EXE_TEST == "on" ]; then
# exe test
file_array=(${files//|/ })
for file in ${file_array[@]}
do
exe_file_testcases $file
done
fi
}
parse_option
# build securec
if [ ! -d "${HITLS_ROOT_DIR}/platform/Secure_C/lib" ]; then
cd ${HITLS_ROOT_DIR}/platform/Secure_C
make -j
fi
if [ "${BUILD_HITLS}" = "on" ]; then
build_hitls
fi
if [ "${SHOW_SIZE}" = "on" ]; then
show_size
fi
if [ "${SHOW_MACRO}" = "on" ]; then
show_macro
exit 0
fi
if [ "$TEST_FEATURE" != "" ]; then
test_feature $TEST_FEATURE
fi
|
2301_79861745/bench_create
|
testcode/script/mini_build_test.sh
|
Shell
|
unknown
| 12,460
|
#ifndef TEST_CONFIG_H
#define TEST_CONFIG_H
#ifdef HITLS_CRYPTO_SHA256
#undef HITLS_CRYPTO_SHA256
#endif
#ifndef HITLS_CRYPTO_MD
#define HITLS_CRYPTO_MD
#endif
#endif
|
2301_79861745/bench_create
|
testcode/script/mini_test_config/test_config.h
|
C
|
unknown
| 180
|
# This file is part of the openHiTLS project.
#
# openHiTLS is licensed under the Mulan PSL v2.
# You can use this software according to the terms and conditions of the Mulan PSL v2.
# You may obtain a copy of Mulan PSL v2 at:
#
# http://license.coscl.org.cn/MulanPSL2
#
# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
# See the Mulan PSL v2 for more details.
message(STATUS "Enable bsl: ${ENABLE_BSL}")
message(STATUS "Enable fail repeat: ${ENABLE_FAIL_REPEAT}")
message(STATUS "Enable print: ${ENABLE_PRINT}")
set(TEST_SOURCE
${openHiTLS_SRC}/testcode/framework/gen_test/helper.c
${openHiTLS_SRC}/testcode/framework/gen_test/test.c
${openHiTLS_SRC}/testcode/framework/crypto/alg_check.c
${openHiTLS_SRC}/testcode/framework/crypto/crypto_test_util.c
${openHiTLS_SRC}/testcode/framework/stub/stub_replace.c
)
add_library(TEST_INTF INTERFACE)
add_library(TEST_INTF_SHARED INTERFACE)
if(ENABLE_PRINT)
target_compile_options(TEST_INTF INTERFACE -DPRINT_TO_TERMINAL)
target_compile_options(TEST_INTF_SHARED INTERFACE -DPRINT_TO_TERMINAL)
endif()
if(ENABLE_FAIL_REPEAT)
target_compile_options(TEST_INTF INTERFACE -DFAIL_REPEAT_RUN)
target_compile_options(TEST_INTF_SHARED INTERFACE -DFAIL_REPEAT_RUN)
endif()
target_link_directories(TEST_INTF INTERFACE
${openHiTLS_SRC}/build
${openHiTLS_SRC}/testcode/output/lib
${openHiTLS_SRC}/platform/Secure_C/lib
)
target_link_directories(TEST_INTF_SHARED INTERFACE
${openHiTLS_SRC}/build
${openHiTLS_SRC}/testcode/output/lib
${openHiTLS_SRC}/platform/Secure_C/lib
)
# link libs
set(TEST_INTF_LIBS "")
set(TEST_INTF_SHARED_LIBS "")
if(APPS)
list(APPEND TEST_INTF_LIBS hitls_apps)
endif()
if(ENABLE_TLS AND ${BUILD_TLS} GREATER -1)
list(APPEND TEST_INTF_LIBS tls_hlt tls_frame libhitls_tls.a rec_wrapper)
list(APPEND TEST_INTF_SHARED_LIBS tls_hlt tls_frame libhitls_tls.so rec_wrapper)
endif()
if(ENABLE_PKI AND ${BUILD_PKI} GREATER -1)
list(APPEND TEST_INTF_LIBS libhitls_pki.a)
list(APPEND TEST_INTF_SHARED_LIBS libhitls_pki.so)
endif()
if(ENABLE_AUTH AND ${BUILD_AUTH} GREATER -1)
list(APPEND TEST_INTF_LIBS libhitls_auth.a)
list(APPEND TEST_INTF_SHARED_LIBS libhitls_auth.so)
endif()
if(ENABLE_CRYPTO AND ${BUILD_CRYPTO} GREATER -1)
list(APPEND TEST_INTF_LIBS libhitls_crypto.a)
list(APPEND TEST_INTF_SHARED_LIBS libhitls_crypto.so)
endif()
list(APPEND TEST_INTF_LIBS libhitls_bsl.a boundscheck pthread dl)
list(APPEND TEST_INTF_SHARED_LIBS libhitls_bsl.so boundscheck pthread dl)
target_link_libraries(TEST_INTF INTERFACE ${TEST_INTF_LIBS})
target_link_libraries(TEST_INTF_SHARED INTERFACE ${TEST_INTF_SHARED_LIBS})
set(TEST_INTF_INCLUDE_DIRS
${openHiTLS_SRC}/platform/Secure_C/include
${openHiTLS_SRC}/include
${openHiTLS_SRC}/testcode/framework/include
${openHiTLS_SRC}/testcode/framework/crypto
${openHiTLS_SRC}/testcode/framework/stub
${openHiTLS_SRC}/testcode/framework/tls/func_wrapper/include
${openHiTLS_SRC}/testcode/framework/tls/include
${openHiTLS_SRC}/testcode/framework/tls/callback/include
${openHiTLS_SRC}/testcode/framework/tls/base/include
${openHiTLS_SRC}/testcode/framework/tls/resource/include
${openHiTLS_SRC}/testcode/framework/tls/rpc/include
${openHiTLS_SRC}/testcode/framework/tls/process/include
${openHiTLS_SRC}/testcode/framework/tls/crypt/include
${openHiTLS_SRC}/testcode/framework/tls/transfer/include
${openHiTLS_SRC}/testcode/framework/tls/frame/src
${openHiTLS_SRC}/testcode/framework/tls/msg/include
${openHiTLS_SRC}/testcode/framework/tls/io/include
${openHiTLS_SRC}/testcode/framework/tls/io/src
${openHiTLS_SRC}/bsl/sal/include
${openHiTLS_SRC}/bsl/tlv/include
${openHiTLS_SRC}/include/bsl
${openHiTLS_SRC}/include/tls
${openHiTLS_SRC}/include/auth
${openHiTLS_SRC}/bsl/log/include
${openHiTLS_SRC}/bsl/hash/include
${openHiTLS_SRC}/bsl/base64/include
${openHiTLS_SRC}/bsl/pem/include
${openHiTLS_SRC}/bsl/list/include
${openHiTLS_SRC}/bsl/obj/include
${openHiTLS_SRC}/bsl/include
${openHiTLS_SRC}/bsl/sal/src
${openHiTLS_SRC}/bsl/conf/include
${openHiTLS_SRC}/include/crypto/
${openHiTLS_SRC}/crypto/bn/include/
${openHiTLS_SRC}/crypto/bn/src/
${openHiTLS_SRC}/crypto/entropy/include/
${openHiTLS_SRC}/crypto/sm3/include
${openHiTLS_SRC}/crypto/sha3/include
${openHiTLS_SRC}/crypto/sha2/include
${openHiTLS_SRC}/crypto/sha2/src
${openHiTLS_SRC}/crypto/sha1/include
${openHiTLS_SRC}/crypto/md5/include
${openHiTLS_SRC}/crypto/pbkdf2/include
${openHiTLS_SRC}/crypto/provider/include
${openHiTLS_SRC}/crypto/provider/src/mgr
${openHiTLS_SRC}/crypto/hkdf/include
${openHiTLS_SRC}/crypto/kdf/include
${openHiTLS_SRC}/crypto/scrypt/include
${openHiTLS_SRC}/crypto/hmac/include
${openHiTLS_SRC}/crypto/siphash/include
${openHiTLS_SRC}/crypto/aes/include
${openHiTLS_SRC}/crypto/sm4/include
${openHiTLS_SRC}/crypto/drbg/include
${openHiTLS_SRC}/crypto/drbg/src
${openHiTLS_SRC}/crypto/include
${openHiTLS_SRC}/crypto/rsa/include
${openHiTLS_SRC}/crypto/rsa/src
${openHiTLS_SRC}/crypto/eal/src
${openHiTLS_SRC}/crypto/eal/include
${openHiTLS_SRC}/crypto/ealinit/include
${openHiTLS_SRC}/crypto/ealinit/src
${openHiTLS_SRC}/crypto/dsa/src
${openHiTLS_SRC}/crypto/curve25519/src
${openHiTLS_SRC}/crypto/curve25519/include
${openHiTLS_SRC}/crypto/chacha20/include
${openHiTLS_SRC}/crypto/dsa/include
${openHiTLS_SRC}/crypto/dsa/src
${openHiTLS_SRC}/crypto/dh/include
${openHiTLS_SRC}/crypto/dh/src
${openHiTLS_SRC}/crypto/ecc/include
${openHiTLS_SRC}/crypto/ecc/src
${openHiTLS_SRC}/crypto/ecdh/include
${openHiTLS_SRC}/crypto/ecdsa/include
${openHiTLS_SRC}/crypto/modes/include
${openHiTLS_SRC}/crypto/modes/src
${openHiTLS_SRC}/crypto/ecdh/include
${openHiTLS_SRC}/crypto/ecdsa/include
${openHiTLS_SRC}/crypto/sm2/include
${openHiTLS_SRC}/crypto/sm2/src
${openHiTLS_SRC}/crypto/paillier/include
${openHiTLS_SRC}/crypto/paillier/src
${openHiTLS_SRC}/crypto/elgamal/include
${openHiTLS_SRC}/crypto/elgamal/src
${openHiTLS_SRC}/crypto/encode/include
${openHiTLS_SRC}/crypto/codecskey/include
${openHiTLS_SRC}/crypto/codecskey/src
${openHiTLS_SRC}/crypto/entropy/src
${openHiTLS_SRC}/crypto/provider/src/cmvp/cmvp_utils
${openHiTLS_SRC}/bsl/err/include
${openHiTLS_SRC}/bsl/err/src
${openHiTLS_SRC}/include/tls
${openHiTLS_SRC}/tls/include
${openHiTLS_SRC}/tls/cert/include
${openHiTLS_SRC}/tls/cm/include
${openHiTLS_SRC}/tls/config/include
${openHiTLS_SRC}/tls/crypt/include
${openHiTLS_SRC}/tls/app/include
${openHiTLS_SRC}/tls/app/src
${openHiTLS_SRC}/tls/ccs/include
${openHiTLS_SRC}/tls/alert/include
${openHiTLS_SRC}/bsl/uio/include
${openHiTLS_SRC}/tls/record/include
${openHiTLS_SRC}/tls/record/src
${openHiTLS_SRC}/bsl/uio/src
${openHiTLS_SRC}/bsl/asn1/include
${openHiTLS_SRC}/bsl/buffer/include
${openHiTLS_SRC}/include/pki
${openHiTLS_SRC}/pki/x509_cert/include
${openHiTLS_SRC}/pki/x509_csr/include
${openHiTLS_SRC}/pki/x509_common/include
${openHiTLS_SRC}/pki/x509_crl/include
${openHiTLS_SRC}/pki/pkcs12/include
${openHiTLS_SRC}/pki/cms/include
${openHiTLS_SRC}/pki/x509_verify/include
${openHiTLS_SRC}/pki/print/include
${openHiTLS_SRC}/config/macro_config
${openHiTLS_SRC}/tls/handshake/include
${openHiTLS_SRC}/tls/handshake/common/include
${openHiTLS_SRC}/tls/handshake/cookie/include
${openHiTLS_SRC}/tls/handshake/parse/include
${openHiTLS_SRC}/tls/handshake/pack/include
${openHiTLS_SRC}/tls/handshake/pack/src
${openHiTLS_SRC}/tls/handshake/send/src
${openHiTLS_SRC}/tls/handshake/recv/src
${openHiTLS_SRC}/tls/handshake/recv/include
${openHiTLS_SRC}/tls/handshake/common/src
${openHiTLS_SRC}/tls/feature/session/src
${openHiTLS_SRC}/tls/cert/include
${openHiTLS_SRC}/tls/cert/cert_adapt
${openHiTLS_SRC}/tls/cert/hitls_x509_adapt
${openHiTLS_SRC}/tls/crypt/crypt_self
${openHiTLS_SRC}/config/macro_config
${openHiTLS_SRC}/tls/handshake/parse/src
${openHiTLS_SRC}/auth/privpass_token/include
${openHiTLS_SRC}/config/macro_config
${openHiTLS_SRC}/codecs/include
${openHiTLS_SRC}/tls/feature/custom_extensions/include
${openHiTLS_SRC}/crypto/mlkem/include
${openHiTLS_SRC}/crypto/mlkem/src
${openHiTLS_SRC}/crypto/mldsa/include
${openHiTLS_SRC}/crypto/mldsa/src
${openHiTLS_SRC}/apps/include
${openHiTLS_SRC}/apps/src
${openHiTLS_SRC}/bsl/ui/include
${openHiTLS_SRC}/bsl/print/include
)
target_include_directories(TEST_INTF
INTERFACE
${TEST_INTF_INCLUDE_DIRS}
)
target_include_directories(TEST_INTF_SHARED
INTERFACE
${TEST_INTF_INCLUDE_DIRS}
)
add_library(TESTCASE_PRE ${TEST_SOURCE})
add_library(TESTCASE_PRE_SHARED ${TEST_SOURCE})
target_link_libraries(TESTCASE_PRE PRIVATE TEST_INTF)
target_link_libraries(TESTCASE_PRE_SHARED PRIVATE TEST_INTF_SHARED)
if(GEN_TEST_FILES)
# test1 test2 ...
string(REPLACE " " ";" GEN_TEST_FILES ${GEN_TEST_FILES})
foreach(gen_test_suite ${GEN_TEST_FILES})
get_filename_component(suite ${gen_test_suite} NAME)
execute_process(COMMAND touch ${openHiTLS_SRC}/testcode/output/${suite}.c
WORKING_DIRECTORY ${openHiTLS_SRC}/testcode/output
)
add_custom_target(${suite}_phony
COMMAND ./gen_testcase ${gen_test_suite}
DEPENDS gen_testcase
WORKING_DIRECTORY ${openHiTLS_SRC}/testcode/output)
message(STATUS "${suite}: ${gen_test_suite}")
set(TEST_FILES "${TEST_FILES};${gen_test_suite}")
endforeach()
else()
message(STATUS "No file needs to be generated")
endif()
# Set library type for each test case
set(TEST_SHARED_LIBS
test_suite_sdv_hlt_provider
test_suite_sdv_frame_provider
test_suite_sdv_hlt_base_connect
test_suite_sdv_hlt_tlcp_ciphersuite
)
# Create test cases
foreach(test_suite ${TEST_FILES})
get_filename_component(sdv_exe ${test_suite} NAME_WE)
add_executable(${sdv_exe} ${openHiTLS_SRC}/testcode/output/${sdv_exe}.c)
target_link_options(${sdv_exe} PRIVATE "LINKER:-z,noexecstack")
add_dependencies(${sdv_exe} ${sdv_exe}_phony)
set_target_properties(${sdv_exe} PROPERTIES
RUNTIME_OUTPUT_DIRECTORY "${openHiTLS_SRC}/testcode/output"
)
# Choose between static and shared libraries based on test case
if(${sdv_exe} IN_LIST TEST_SHARED_LIBS)
target_link_libraries(${sdv_exe} PRIVATE TEST_INTF_SHARED TESTCASE_PRE_SHARED)
else()
target_link_libraries(${sdv_exe} PRIVATE TEST_INTF TESTCASE_PRE)
endif()
endforeach()
if("${APPS}" STREQUAL "ON")
SET(APPS_LIB "hitls_apps")
aux_source_directory(${openHiTLS_SRC}/apps/src APPS_SRC)
add_library(${APPS_LIB} STATIC ${APPS_SRC})
target_link_libraries(${APPS_LIB} PRIVATE TEST_INTF)
target_compile_options(${APPS_LIB} PRIVATE -O0 -g3 -gdwarf-2)
set_target_properties(${APPS_LIB}
PROPERTIES
ARCHIVE_OUTPUT_DIRECTORY "${openHiTLS_SRC}/testcode/output/lib"
)
endif()
|
2301_79861745/bench_create
|
testcode/sdv/CMakeLists.txt
|
CMake
|
unknown
| 11,505
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdint.h>
#include "hitls_pki_errno.h"
#include "hitls_csr_local.h"
#include "app_errno.h"
#include "app_conf.h"
/* END_HEADER */
#define MAX_STR_CNT (10)
/* BEGIN_CASE */
void UT_HITLS_APP_SplitString_Api_TC001(void)
{
char *res[MAX_STR_CNT] = {0};
uint32_t cnt = 0;
char *in = "Aa,Bb";
char separator = ',';
ASSERT_EQ(HITLS_APP_SplitString(NULL, separator, 1, res, MAX_STR_CNT, &cnt), HITLS_APP_INVALID_ARG);
ASSERT_EQ(HITLS_APP_SplitString("", separator, 1, res, MAX_STR_CNT, &cnt), HITLS_APP_INVALID_ARG);
ASSERT_EQ(HITLS_APP_SplitString(in, ' ', 1, res, MAX_STR_CNT, &cnt), HITLS_APP_INVALID_ARG);
ASSERT_EQ(HITLS_APP_SplitString(in, separator, 1, NULL, MAX_STR_CNT, &cnt), HITLS_APP_INVALID_ARG);
ASSERT_EQ(HITLS_APP_SplitString(in, separator, 1, res, 0, &cnt), HITLS_APP_INVALID_ARG);
ASSERT_EQ(HITLS_APP_SplitString(in, separator, 1, res, MAX_STR_CNT, NULL), HITLS_APP_INVALID_ARG);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_SplitString_Func_TC001(
char *in, int allowEmpty, int expectCnt, char *expect1, char *expect2, char *expect3)
{
char *res[MAX_STR_CNT] = {0};
uint32_t cnt = 0;
char separator = ',';
char *expect[MAX_STR_CNT] = {expect1, expect2, expect3};
ASSERT_EQ(HITLS_APP_SplitString(in, separator, allowEmpty, res, MAX_STR_CNT, &cnt), HITLS_APP_SUCCESS);
ASSERT_EQ(cnt, expectCnt);
for (uint32_t i = 0; i < cnt; i++) {
ASSERT_EQ(strcmp(expect[i], res[i]), 0);
}
EXIT:
BSL_SAL_Free(res[0]);
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_SplitString_Error_TC001(char *in, int allowEmpty)
{
char *res[MAX_STR_CNT] = {0};
uint32_t cnt = 0;
char separator = ',';
ASSERT_EQ(HITLS_APP_SplitString(in, separator, allowEmpty, res, MAX_STR_CNT, &cnt), HITLS_APP_CONF_FAIL);
EXIT:
BSL_SAL_FREE(res[0]);
}
/* END_CASE */
#define HITLS_X509_CSR_GEN_FLAG 0x02
/* BEGIN_CASE */
void UT_HITLS_APP_conf_subj_TC001(char *subjectName, int expectRet, int expectCnt, Hex *expectEncode)
{
HITLS_X509_Csr *csr = HITLS_X509_CsrNew();
ASSERT_NE(csr, NULL);
BslList *csrSubject = NULL;
BSL_ASN1_Buffer name = {0};
BSL_Buffer nameEncoded = {0};
ASSERT_EQ(HITLS_APP_CFG_ProcDnName(subjectName, HiTLS_AddSubjDnNameToCsr, csr), expectRet);
if (expectRet == HITLS_APP_SUCCESS) {
ASSERT_EQ(HITLS_X509_CsrCtrl(csr, HITLS_X509_GET_SUBJECT_DN, &csrSubject, sizeof(BslList *)), 0);
ASSERT_EQ(BSL_LIST_COUNT(csrSubject), expectCnt);
if (expectCnt != 0) {
ASSERT_EQ(HITLS_X509_EncodeNameList(csrSubject, &name), 0);
BSL_ASN1_TemplateItem item = {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0};
BSL_ASN1_Template templ = {&item, 1};
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &name, 1, &nameEncoded.data, &nameEncoded.dataLen), 0);
ASSERT_EQ(expectEncode->len, nameEncoded.dataLen);
ASSERT_EQ(memcmp(expectEncode->x, nameEncoded.data, expectEncode->len), 0);
}
}
EXIT:
BSL_SAL_FREE(nameEncoded.data);
BSL_SAL_FREE(name.buff);
HITLS_X509_CsrFree(csr);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_conf_subj_TC002(void)
{
HITLS_X509_Csr *csr = HITLS_X509_CsrNew();
ASSERT_NE(csr, NULL);
ASSERT_EQ(HITLS_APP_CFG_ProcDnName(NULL, HiTLS_AddSubjDnNameToCsr, csr), HITLS_APP_INVALID_ARG);
ASSERT_EQ(HITLS_APP_CFG_ProcDnName("/ABC=1", NULL, NULL), HITLS_APP_INVALID_ARG);
ASSERT_EQ(HITLS_APP_CFG_ProcDnName("/ABC=1", HiTLS_AddSubjDnNameToCsr, NULL), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_APP_CFG_ProcDnName("/pseudonym=testabc#", HiTLS_AddSubjDnNameToCsr, NULL), HITLS_APP_INVALID_ARG);
ASSERT_EQ(HITLS_APP_CFG_ProcDnName("ABC", HiTLS_AddSubjDnNameToCsr, csr), HITLS_APP_INVALID_ARG);
ASSERT_EQ(HITLS_APP_CFG_ProcDnName("/", HiTLS_AddSubjDnNameToCsr, csr), HITLS_APP_INVALID_ARG);
EXIT:
HITLS_X509_CsrFree(csr);
return;
}
/* END_CASE */
static int32_t ProcExt(BslCid cid, void *val, void *ctx)
{
HITLS_X509_Ext *ext = ctx;
switch (cid) {
case BSL_CID_CE_SUBJECTALTNAME:
return HITLS_X509_ExtCtrl(ext, HITLS_X509_EXT_SET_SAN, val, sizeof(HITLS_X509_ExtSan));
case BSL_CID_CE_BASICCONSTRAINTS:
return HITLS_X509_ExtCtrl(ext, HITLS_X509_EXT_SET_BCONS, val, sizeof(HITLS_X509_ExtBCons));
case BSL_CID_CE_KEYUSAGE:
return HITLS_X509_ExtCtrl(ext, HITLS_X509_EXT_SET_KUSAGE, val, sizeof(HITLS_X509_ExtKeyUsage));
case BSL_CID_CE_EXTKEYUSAGE:
return HITLS_X509_ExtCtrl(ext, HITLS_X509_EXT_SET_EXKUSAGE, val, sizeof(HITLS_X509_ExtExKeyUsage));
default:
return HITLS_APP_CONF_FAIL;
}
}
/* BEGIN_CASE */
void UT_HITLS_APP_conf_X509Ext_TC001(char *confPath, int expectLoadRet, int expectResult, Hex *expectAsn)
{
BSL_CONF *conf = NULL;
BSL_ASN1_Buffer asnExt = {0};
HITLS_X509_Ext *ext = HITLS_X509_ExtNew(HITLS_X509_EXT_TYPE_CSR);
ASSERT_NE(ext, NULL);
conf = BSL_CONF_New(BSL_CONF_DefaultMethod());
ASSERT_NE(conf, NULL);
ASSERT_EQ(BSL_CONF_Load(conf, confPath), expectLoadRet);
if (expectLoadRet == HITLS_APP_SUCCESS) {
ASSERT_EQ(HITLS_APP_CONF_ProcExt(conf, "SAN", ProcExt, ext), expectResult);
if (expectResult == HITLS_APP_SUCCESS) {
ASSERT_EQ(HITLS_X509_EncodeExt(BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SET, ext->extList, &asnExt),
HITLS_PKI_SUCCESS);
ASSERT_EQ(asnExt.len, expectAsn->len);
ASSERT_EQ(memcmp(asnExt.buff, expectAsn->x, expectAsn->len), 0);
}
}
EXIT:
BSL_SAL_FREE(asnExt.buff);
HITLS_X509_ExtFree(ext);
BSL_CONF_Free(conf);
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_conf_X509Ext_TC002(void)
{
HITLS_X509_Ext *ext = HITLS_X509_ExtNew(HITLS_X509_EXT_TYPE_CSR);
BSL_CONF conf = {};
ASSERT_NE(ext, NULL);
ASSERT_EQ(HITLS_APP_CONF_ProcExt(NULL, "SAN", ProcExt, ext), HITLS_APP_CONF_FAIL);
ASSERT_EQ(HITLS_APP_CONF_ProcExt(&conf, NULL, ProcExt, ext), HITLS_APP_CONF_FAIL);
ASSERT_EQ(HITLS_APP_CONF_ProcExt(&conf, "SAN", NULL, ext), HITLS_APP_CONF_FAIL);
ASSERT_EQ(HITLS_APP_CONF_ProcExt(&conf, "SAN", ProcExt, NULL), HITLS_APP_CONF_FAIL);
conf.data = NULL;
ASSERT_EQ(HITLS_APP_CONF_ProcExt(&conf, "SAN", ProcExt, ext), HITLS_APP_CONF_FAIL);
EXIT:
HITLS_X509_ExtFree(ext);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_app_conf.c
|
C
|
unknown
| 7,007
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "app_crl.h"
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_types.h"
#include "hitls_pki_errno.h"
#include "hitls_x509_local.h"
#include "hitls_crl_local.h"
#include "bsl_errno.h"
#include "crypt_eal_pkey.h"
#include "app_opt.h"
#include "app_function.h"
#include "app_errno.h"
#include "app_help.h"
#include "app_print.h"
#include "app_utils.h"
#include "stub_replace.h"
#define MAX_CRLFILE_SIZE (256 * 1024)
#define DEFAULT_CERT_SIZE 1024U
/* END_HEADER */
#define CRL_PATH "../testdata/certificate/crlAndCert/crl.crt"
#define CRL_ASN1_PATH "../testdata/cert/asn1/sm2_crl/crl_v2.v1.der"
#define CERT_PATH "../testdata/certificate/crlAndCert/CA.crt"
#define ERR_CRL_PATH "../testdata/certificate/crlAndCert/emptyCRL.crt"
#define ERR_CERT_PATH "../testdata/certificate/crlAndCert/errCA.crt"
#define CRL_PEM_PATH "./crl.pem"
#define CRL_DER_PATH "./crl.der"
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_crl.c
${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c */
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
/**
* @test UT_HITLS_APP_crl_TC001
* @spec -
* @title Test the UT_HITLS_APP_crl_TC001 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_crl_TC001(void)
{
char *argv[][10] = {
{"crl", "-in", CRL_PATH, "-noout", "-CAfile", CERT_PATH},
{"crl", "-in", CRL_PATH, "-noout"},
{"crl", "-in", CRL_PATH, "-noout", "-nextupdate"},
{"crl", "-in", CRL_PATH, "-noout", "-out", "tmp.txt", "-nextupdate"},
{"crl", "-in", CRL_PATH, "-noout", "-CAfile", ERR_CRL_PATH},
{"crl", "-in", ERR_CRL_PATH, "-noout", "-CAfile", CERT_PATH},
{"crl", "-in", CRL_ASN1_PATH, "-inform", "DER", "-out", CRL_PEM_PATH, "-outform", "PEM"},
{"crl", "-in", CRL_PATH, "-inform", "PEM", "-out", CRL_DER_PATH, "-outform", "DER"},
};
OptTestData testData[] = {
{6, argv[0], HITLS_APP_SUCCESS},
{4, argv[1], HITLS_APP_SUCCESS},
{5, argv[2], HITLS_APP_SUCCESS},
{7, argv[3], HITLS_APP_SUCCESS},
{6, argv[4], HITLS_APP_UIO_FAIL},
{6, argv[5], HITLS_APP_UIO_FAIL},
{9, argv[6], HITLS_APP_SUCCESS},
{9, argv[7], HITLS_APP_SUCCESS}
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_CrlMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_crl_TC002
* @spec -
* @title Test the UT_HITLS_APP_crl_TC002 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_crl_TC002(void)
{
char *argv[][10] = {
{"crl", "-in"},
{"crl", "-in", ERR_CRL_PATH},
{"crl", "-in", CRL_PATH, "-in", ERR_CRL_PATH},
{"crl", "-in", ERR_CRL_PATH, "-noout", "-CAfile"},
{"crl", "-in", CRL_PATH, "-noout", "-CAfile", ERR_CRL_PATH},
{"crl", "-in", CRL_PATH, "-noout", "-CAfile", CERT_PATH, "-CAfile", ERR_CRL_PATH},
};
OptTestData testData[] = {{2, argv[0], HITLS_APP_OPT_UNKOWN},
{3, argv[1], HITLS_APP_UIO_FAIL},
{5, argv[2], HITLS_APP_UIO_FAIL},
{5, argv[3], HITLS_APP_OPT_UNKOWN},
{6, argv[4], HITLS_APP_UIO_FAIL},
{8, argv[5], HITLS_APP_UIO_FAIL}};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_CrlMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_crl_TC003
* @spec -
* @title Test the UT_HITLS_APP_crl_TC003 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_crl_TC003(void)
{
char *argv[][2] = {
{"crl", "-help"},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_HELP},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_CrlMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
int32_t STUB_HITLS_APP_OptBegin(int32_t argc, char **argv, const HITLS_CmdOption *opts)
{
(void)argc;
(void)argv;
(void)opts;
return HITLS_APP_OPT_UNKOWN;
}
/**
* @test UT_HITLS_APP_crl_TC004
* @spec -
* @title Test the UT_HITLS_APP_crl_TC004 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_crl_TC004(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptBegin, STUB_HITLS_APP_OptBegin);
char *argv[][10] = {
{"crl", "-in", CRL_PATH, "-noout", "-CAfile", CERT_PATH},
};
OptTestData testData[] = {
{6, argv[0], HITLS_APP_OPT_UNKOWN},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_CrlMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_BSL_UIO_Ctrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *parg)
{
(void)uio;
(void)cmd;
(void)larg;
(void)parg;
return BSL_UIO_FAIL;
}
/**
* @test UT_HITLS_APP_crl_TC005
* @spec -
* @title Test the UT_HITLS_APP_crl_TC005 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_crl_TC005(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UIO_Ctrl, STUB_BSL_UIO_Ctrl);
char *argv[][50] = {{"crl", "-in", CRL_PATH, "-noout", "-CAfile", CERT_PATH}};
OptTestData testData[] = {
{6, argv[0], HITLS_APP_UIO_FAIL},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_CrlMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
char *STUB_HITLS_APP_OptGetValueStr(void)
{
return NULL;
}
/**
* @test UT_HITLS_APP_crl_TC006
* @spec -
* @title Test the UT_HITLS_APP_crl_TC006 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_crl_TC006(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptGetValueStr, STUB_HITLS_APP_OptGetValueStr);
char *argv[][50] = {{"crl", "-in", CRL_PATH, "-noout", "-CAfile", CERT_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_OPT_VALUE_INVALID},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_CrlMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_HITLS_APP_OptWriteUio(BSL_UIO *uio, uint8_t *buf, uint32_t outLen, int32_t format)
{
(void)uio;
(void)buf;
(void)outLen;
(void)format;
return HITLS_APP_UIO_FAIL;
}
/**
* @test UT_HITLS_APP_crl_TC007
* @spec -
* @title Test the UT_HITLS_APP_crl_TC007 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_crl_TC007(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptWriteUio, STUB_HITLS_APP_OptWriteUio);
char *argv[][50] = {{"crl", "-in", CRL_PATH, "-CAfile", CERT_PATH}};
OptTestData testData[] = {
{5, argv[0], HITLS_APP_UIO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_CrlMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
bool IsFileExist(const char *fileName)
{
FILE *f = fopen(fileName, "r");
if (f == NULL) {
return false;
}
fclose(f);
return true;
}
/**
* @test UT_HITLS_APP_crl_TC008
* @spec -
* @title Test the UT_HITLS_APP_crl_TC008 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_crl_TC008(void)
{
char *filename = "_APP_crl_T008.txt";
char *argv[][10] = {{"crl", "-in", CRL_PATH, "-out", filename, "-CAfile", CERT_PATH}};
OptTestData testData[] = {{7, argv[0], HITLS_APP_SUCCESS}};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
ASSERT_TRUE(IsFileExist(filename) == false);
int ret = HITLS_CrlMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
ASSERT_TRUE(IsFileExist(filename));
remove(filename);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
int32_t STUB_X509_extractPublicKey(HITLS_X509_Cert *cert, int32_t cmd, void *val, uint32_t valLen)
{
(void)cert;
(void)cmd;
(void)val;
(void)valLen;
return HITLS_X509_ERR_INVALID_PARAM;
}
/**
* @test UT_HITLS_APP_crl_TC0010
* @spec -
* @titleTest UT_HITLS_APP_crl_TC0010 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_crl_TC0010(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_X509_CertCtrl, STUB_X509_extractPublicKey);
char *argv[][50] = {{"crl", "-in", CRL_PATH, "-noout", "-CAfile", CERT_PATH}};
OptTestData testData[] = {
{6, argv[0], HITLS_APP_DECODE_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_CrlMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_PEM_encode(HITLS_X509_Crl *crl, uint8_t **encode, uint32_t *encodeLen)
{
(void)crl;
(void)encode;
(void)encodeLen;
return HITLS_APP_ENCODE_FAIL;
}
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_app_crl.c
|
C
|
unknown
| 10,819
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "app_opt.h"
#include "app_print.h"
#include "bsl_uio.h"
#include "uio_abstraction.h"
#include "app_errno.h"
#include "crypt_errno.h"
#include "app_genpkey.h"
#include "app_function.h"
#include "securec.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "stub_replace.h"
/* END_HEADER */
#define GENPKEY_TEST_FILE_PATH "out_test.pem"
#define GENPKEY_TEST_DIR_PATH "./genpkey_dir"
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_genpkey.c
${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c */
/**
* @test UT_HITLS_APP_GENPKEY_TC001
* @spec -
* @title 测试UT_HITLS_APP_GENPKEY_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_GENPKEY_TC001()
{
char *argv[][20] = {
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:P-224"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:P-256"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:P-384"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:P-521"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:brainpoolp256r1"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:brainpoolp384r1"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:brainpoolp512r1"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:sm2"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:sm2", "-out", GENPKEY_TEST_FILE_PATH},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:sm2", "-aes256-cbc", "-pass", "pass:123456"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:sm2", "-aes256-cbc", "-pass", "pass:123456", "-out", GENPKEY_TEST_FILE_PATH},
{"genpkey", "-algorithm", "RSA"},
{"genpkey", "-algorithm", "RSA", "-pkeyopt", "rsa_keygen_bits:1024"},
{"genpkey", "-algorithm", "RSA", "-pkeyopt", "rsa_keygen_bits:2048"},
{"genpkey", "-algorithm", "RSA", "-pkeyopt", "rsa_keygen_bits:3072"},
{"genpkey", "-algorithm", "RSA", "-pkeyopt", "rsa_keygen_bits:4096"},
{"genpkey", "-algorithm", "RSA", "-pkeyopt", "rsa_keygen_bits:4096", "-out", "out_test.pem"},
{"genpkey", "-algorithm", "RSA", "-pkeyopt", "rsa_keygen_bits:4096", "-aes256-cbc", "-pass", "pass:123456"},
{"genpkey", "-algorithm", "RSA", "-pkeyopt", "rsa_keygen_bits:4096", "-aes256-cbc", "-pass", "pass:123456", "-out", GENPKEY_TEST_FILE_PATH},
};
OptTestData testData[] = {
{5, argv[0], HITLS_APP_SUCCESS},
{5, argv[1], HITLS_APP_SUCCESS},
{5, argv[2], HITLS_APP_SUCCESS},
{5, argv[3], HITLS_APP_SUCCESS},
{5, argv[4], HITLS_APP_SUCCESS},
{5, argv[5], HITLS_APP_SUCCESS},
{5, argv[6], HITLS_APP_SUCCESS},
{5, argv[7], HITLS_APP_SUCCESS},
{7, argv[8], HITLS_APP_SUCCESS},
{8, argv[9], HITLS_APP_SUCCESS},
{10, argv[10], HITLS_APP_SUCCESS},
{3, argv[11], HITLS_APP_SUCCESS},
{5, argv[12], HITLS_APP_SUCCESS},
{5, argv[13], HITLS_APP_SUCCESS},
{5, argv[14], HITLS_APP_SUCCESS},
{5, argv[15], HITLS_APP_SUCCESS},
{7, argv[16], HITLS_APP_SUCCESS},
{8, argv[17], HITLS_APP_SUCCESS},
{10, argv[18], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_GenPkeyMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
remove(GENPKEY_TEST_FILE_PATH);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_GENPKEY_TC002
* @spec -
* @title 测试UT_HITLS_APP_GENPKEY_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_GENPKEY_TC002()
{
mkdir(GENPKEY_TEST_DIR_PATH, 0775);
char *argv[][20] = {
{"genpkey", "-ttt"},
{"genpkey", "-algorithm", "ttt"},
{"genpkey", "-algorithm", "RSA", "-pass", "err:12"},
{"genpkey", "-algorithm", "RSA", "-pkeyopt", "ec_paramgen_curve:sm2"},
{"genpkey", "-algorithm", "RSA", "-pkeyopt", "ttt"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "rsa_keygen_bits:1024"},
{"genpkey", "-algorithm", "EC", "-pkeyopt", "ttt"},
{"genpkey", "-algorithm", "RSA", "-aes256-cbc", "-pass", "pass:"},
{"genpkey", "-algorithm", "RSA", "-out", GENPKEY_TEST_DIR_PATH},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_OPT_UNKOWN},
{3, argv[1], HITLS_APP_INVALID_ARG},
{5, argv[2], HITLS_APP_PASSWD_FAIL},
{5, argv[3], HITLS_APP_INVALID_ARG},
{5, argv[4], HITLS_APP_INVALID_ARG},
{5, argv[5], HITLS_APP_INVALID_ARG},
{5, argv[6], HITLS_APP_INVALID_ARG},
{6, argv[7], HITLS_APP_PASSWD_FAIL},
{5, argv[8], HITLS_APP_UIO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_GenPkeyMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
rmdir(GENPKEY_TEST_DIR_PATH);
remove(GENPKEY_TEST_FILE_PATH);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_GENPKEY_TC003
* @spec -
* @title 测试UT_HITLS_APP_GENPKEY_TC003函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_GENPKEY_TC003(char *cipherOpt)
{
mkdir(GENPKEY_TEST_DIR_PATH, 0775);
char *argv[][20] = {
{"genpkey", "-algorithm", "RSA", cipherOpt, "-pass", "pass:123456"},
};
OptTestData testData[] = {
{6, argv[0], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_GenPkeyMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
rmdir(GENPKEY_TEST_DIR_PATH);
remove(GENPKEY_TEST_FILE_PATH);
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_app_genpkey.c
|
C
|
unknown
| 7,101
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "securec.h"
#include <stddef.h>
#include "app_genrsa.h"
#include "app_rsa.h"
#include "app_errno.h"
#include "app_help.h"
#include "app_print.h"
#include "app_opt.h"
#include "app_utils.h"
#include "bsl_uio.h"
#include "stub_replace.h"
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_genrsa.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c */
/* END_HEADER */
#define BSL_SUCCESS 0
typedef struct {
int argc;
char **argv;
int expect;
} GenrsaTestData;
int32_t STUB_HITLS_APP_Passwd(char *buf, int32_t bufMaxLen, int32_t flag, void *userdata)
{
(void)flag;
(void)userdata;
(void)memcpy_s(buf, bufMaxLen, "12345678", 8);
return 8;
}
/**
* @test UT_HITLS_APP_genrsa_TC001
* @spec -
* @title test UT_HITLS_APP_genrsa_TC001 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_genrsa_TC001(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_Passwd, STUB_HITLS_APP_Passwd);
char *argv[][10] = {
{"genrsa", "-help"},
{"genrsa", "-cipher", "aes128-cbc", "1024"},
{"genrsa", "-cipher", "aes128-ctr", "-out", "GenrsaOutFile_1", "2048"},
{"genrsa", "-cipher", "aes128-xts", "-out", "GenrsaOutFile_2", "3072"},
{"genrsa", "-cipher", "sm4-cfb", "-out", "GenrsaOutFile_3", "4096"},
{"genrsa", "-cipher", "rc2-ofb", "-out", "GenrsaOutFile_4", "1024"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_5", "1024"},
{"genrsa", "-cipher", "aes666-cbc", "3072"},
{"genrsa", "-cipher", "aes128-cbc", "1234"}
};
GenrsaTestData testData[] = {
{2, argv[0], HITLS_APP_HELP},
{4, argv[1], HITLS_APP_SUCCESS},
{6, argv[2], HITLS_APP_OPT_VALUE_INVALID},
{6, argv[3], HITLS_APP_SUCCESS},
{6, argv[4], HITLS_APP_SUCCESS},
{6, argv[5], HITLS_APP_OPT_VALUE_INVALID},
{6, argv[6], HITLS_APP_SUCCESS},
{4, argv[7], HITLS_APP_OPT_VALUE_INVALID},
{4, argv[8], HITLS_APP_OPT_VALUE_INVALID}
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(GenrsaTestData)); ++i) {
int ret = HITLS_GenRSAMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_genrsa_TC002(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_Passwd, STUB_HITLS_APP_Passwd);
char *argv[][10] = {
{"", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "2048"},
{"genrsa", "", "aes128-cbc", "-out", "GenrsaOutFile_1", "2048"},
{"genrsa", "-cipher", "", "-out", "GenrsaOutFile_1", "2048"},
{"genrsa", "-cipher", "aes128-cbc", "", "GenrsaOutFile_1", "2048"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "", "2048"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", ""},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[0]), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[1]), HITLS_APP_OPT_UNKOWN);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[2]), HITLS_APP_OPT_VALUE_INVALID);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[3]), HITLS_APP_OPT_UNKOWN);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[4]), HITLS_APP_OPT_VALUE_INVALID);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[5]), HITLS_APP_OPT_VALUE_INVALID);
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_genrsa_TC003(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_Passwd, STUB_HITLS_APP_Passwd);
char *argv[][10] = {
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "2048"},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_GenRSAMain(5, argv[0]), HITLS_APP_OPT_UNKOWN);
ASSERT_EQ(HITLS_GenRSAMain(7, argv[0]), HITLS_APP_OPT_UNKOWN);
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_genrsa_TC004(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_Passwd, STUB_HITLS_APP_Passwd);
char *argv[][10] = {
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "1023"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "1025"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "2047"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "2049"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "3071"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "3073"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "4095"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "4097"},
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile_1", "abcdefgh"},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[0]), HITLS_APP_OPT_VALUE_INVALID);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[1]), HITLS_APP_OPT_VALUE_INVALID);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[2]), HITLS_APP_OPT_VALUE_INVALID);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[3]), HITLS_APP_OPT_VALUE_INVALID);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[4]), HITLS_APP_OPT_VALUE_INVALID);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[5]), HITLS_APP_OPT_VALUE_INVALID);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[6]), HITLS_APP_OPT_VALUE_INVALID);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[7]), HITLS_APP_OPT_VALUE_INVALID);
ASSERT_EQ(HITLS_GenRSAMain(6, argv[8]), HITLS_APP_OPT_VALUE_INVALID);
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_genrsa_TC005(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_Passwd, STUB_HITLS_APP_Passwd);
char *argv[][10] = {
{"genrsa", "-cipher", "aes128-cbc", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "aes192-cbc", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "aes256-cbc", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "aes128-xts", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "aes256-xts", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "sm4-xts", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "sm4-cbc", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "sm4-ctr", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "sm4-cfb", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "sm4-ofb", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "aes128-cfb", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "aes192-cfb", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "aes256-cfb", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "aes128-ofb", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "aes192-ofb", "-out", "GenrsaOutFile", "1024"},
{"genrsa", "-cipher", "aes256-ofb", "-out", "GenrsaOutFile", "1024"},
};
char *rsaArg[][10] = {
{"rsa", "-in", "GenrsaOutFile", "-noout"},
};
int32_t ret;
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (uint32_t i = 0; i < sizeof(argv) / sizeof(argv[0]); i++) {
ret = HITLS_GenRSAMain(6, argv[i]);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
ret = HITLS_RsaMain(4, rsaArg[0]);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, HITLS_APP_SUCCESS);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_app_genrsa.c
|
C
|
unknown
| 8,682
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <linux/limits.h>
#include "securec.h"
#include "stub_replace.h"
#include "test.h"
#include "bsl_uio.h"
#include "bsl_types.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "sal_file.h"
#include "string.h"
#include "uio_abstraction.h"
#include "crypt_errno.h"
#include "app_opt.h"
#include "app_print.h"
#include "app_errno.h"
#include "app_function.h"
#include "app_provider.h"
#include "app_kdf.h"
#include "app_sm.h"
#include "bsl_ui.h"
/* END_HEADER */
#define KDF_MAX_ARGC 22
#define MAX_BUFSIZE (1024 * 8)
#define WORK_PATH "./kdf_workpath"
#define PASSWORD "12345678"
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
#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(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(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_KdfMain(argc, argv), expectRet);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(tmp);
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KDF_NormalOpt_TC001
* @title Test the normal parameters of the kdf command.
* @brief Enter parameters and return HITLS_APP_SUCCESS.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KDF_NormalOpt_TC001(char *opts, char *outFile, Hex *expectData)
{
int argc = 0;
char *argv[KDF_MAX_ARGC] = {0};
char *tmp = strdup(opts);
ASSERT_NE(tmp, NULL);
PreProcArgs(tmp, &argc, argv);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_KdfMain(argc, argv), HITLS_APP_SUCCESS);
ASSERT_EQ(CompareOutByData(outFile, expectData), HITLS_APP_SUCCESS);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(tmp);
remove(outFile);
}
/* END_CASE */
/**
* @test UT_HITLS_APP_kdf_TC002
* @spec -
* @title 测试UT_HITLS_APP_kdf_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_kdf_TC002(void)
{
char *argv[][2] = {
{"kdf", "-help"},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_HELP},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_KdfMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @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 *opts, char *outFile, Hex *expectData)
{
#ifndef HITLS_APP_SM_MODE
(void)opts;
(void)outFile;
(void)expectData;
SKIP_TEST();
#else
system("rm -rf " WORK_PATH);
system("mkdir -p " WORK_PATH);
STUB_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
int argc = 0;
char *argv[KDF_MAX_ARGC] = {0};
char *tmp = strdup(opts);
ASSERT_NE(tmp, NULL);
PreProcArgs(tmp, &argc, argv);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_KdfMain(argc, argv), HITLS_APP_SUCCESS);
ASSERT_EQ(CompareOutByData(outFile, expectData), HITLS_APP_SUCCESS);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(tmp);
STUB_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
system("rm -rf " WORK_PATH);
remove(outFile);
#endif
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_app_kdf.c
|
C
|
unknown
| 5,858
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <string.h>
#include "app_opt.h"
#include "app_print.h"
#include "bsl_uio.h"
#include "bsl_types.h"
#include "uio_abstraction.h"
#include "app_errno.h"
#include "crypt_errno.h"
#include "crypt_eal_codecs.h"
#include "crypt_util_rand.h"
#include "crypt_eal_pkey.h"
#include "app_genpkey.h"
#include "app_pkey.h"
#include "app_function.h"
#include "securec.h"
#include "bsl_err.h"
#include "bsl_sal.h"
#include "stub_replace.h"
#include "bsl_params.h"
#include "crypt_params_key.h"
/* END_HEADER */
#define TMP_BUFF_LEN 2048
#define GENPKEY_PRV_FILE_PATH "genpkey_prv.pem"
#define GENPKEY_ENC_PRV_FILE_PATH "genpkey_enc_prv.pem"
#define PKEY_PRV_FILE_PATH "pkey_prv.pem"
#define PKEY_ENC_PRV_FILE_PATH "pkey_enc_prv.pem"
#define PKEY_PUB_FILE_PATH "pkey_pub.pem"
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_genpkey.c
* ${HITLS_ROOT_PATH}/apps/src/app_pkey.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c
*/
static void SetRsaKeyInfo(CRYPT_EAL_PkeyCtx *pkey)
{
uint32_t keyLen = CRYPT_EAL_PkeyGetKeyLen(pkey);
ASSERT_NE(keyLen, 0);
uint8_t *prv = (uint8_t *)BSL_SAL_Malloc(keyLen * 8);
ASSERT_NE(prv, NULL);
CRYPT_EAL_PkeyPrv rsaPrv = { 0 };
rsaPrv.id = CRYPT_PKEY_RSA;
rsaPrv.key.rsaPrv.d = prv;
rsaPrv.key.rsaPrv.n = prv + keyLen;
rsaPrv.key.rsaPrv.p = prv + keyLen * 2; // 2nd buffer
rsaPrv.key.rsaPrv.q = prv + keyLen * 3; // 3rd buffer
rsaPrv.key.rsaPrv.dP = prv + keyLen * 4; // 4th buffer
rsaPrv.key.rsaPrv.dQ = prv + keyLen * 5; // 5th buffer
rsaPrv.key.rsaPrv.qInv = prv + keyLen * 6; // 6th buffer
rsaPrv.key.rsaPrv.e = prv + keyLen * 7; // 7th buffer
rsaPrv.key.rsaPrv.dLen = keyLen;
rsaPrv.key.rsaPrv.nLen = keyLen;
rsaPrv.key.rsaPrv.pLen = keyLen;
rsaPrv.key.rsaPrv.qLen = keyLen;
rsaPrv.key.rsaPrv.dPLen = keyLen;
rsaPrv.key.rsaPrv.dQLen = keyLen;
rsaPrv.key.rsaPrv.qInvLen = keyLen;
rsaPrv.key.rsaPrv.eLen = keyLen;
ASSERT_EQ(CRYPT_EAL_PkeyGetPrv(pkey, &rsaPrv), CRYPT_SUCCESS);
CRYPT_EAL_PkeyPub rsaPub;
rsaPub.id = CRYPT_PKEY_RSA;
rsaPub.key.rsaPub.n = rsaPrv.key.rsaPrv.n;
rsaPub.key.rsaPub.nLen = rsaPrv.key.rsaPrv.nLen;
rsaPub.key.rsaPub.e = rsaPrv.key.rsaPrv.e;
rsaPub.key.rsaPub.eLen = rsaPrv.key.rsaPrv.eLen;
ASSERT_EQ(CRYPT_EAL_PkeySetPub(pkey, &rsaPub), CRYPT_SUCCESS);
EXIT:
BSL_SAL_ClearFree(prv, keyLen * 8); // 8 items
}
/**
* @test UT_HITLS_APP_KEY_TC001
* @spec -
* @title 测试UT_HITLS_APP_KEY_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEY_TC001(char *algorithm, char *pkeyopt, int hashId)
{
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
char *genpkeyPrv[20] = {"genpkey", "-algorithm", algorithm, "-pkeyopt", pkeyopt, "-out", GENPKEY_PRV_FILE_PATH};
char *pkeyPrv[20] = {"pkey", "-in", GENPKEY_PRV_FILE_PATH, "-out", PKEY_PRV_FILE_PATH};
char *pkeyPub[20] = {"pkey", "-in", PKEY_PRV_FILE_PATH, "-pubout", "-out", PKEY_PUB_FILE_PATH};
ASSERT_EQ(HITLS_GenPkeyMain(7, genpkeyPrv), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_PkeyMain(5, pkeyPrv), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_PkeyMain(6, pkeyPub), HITLS_APP_SUCCESS);
CRYPT_RandRegist(TestSimpleRand);
CRYPT_RandRegistEx(TestSimpleRandEx);
CRYPT_EAL_PkeyCtx *pkeyPrvCtx = NULL;
CRYPT_EAL_PkeyCtx *pkeyPubCtx = NULL;
ASSERT_EQ(CRYPT_EAL_DecodeFileKey(BSL_FORMAT_PEM, CRYPT_PRIKEY_PKCS8_UNENCRYPT, PKEY_PRV_FILE_PATH, NULL, 0,
&pkeyPrvCtx),
CRYPT_SUCCESS);
ASSERT_EQ(
CRYPT_EAL_DecodeFileKey(BSL_FORMAT_PEM, CRYPT_PUBKEY_SUBKEY, PKEY_PUB_FILE_PATH, NULL, 0, &pkeyPubCtx),
CRYPT_SUCCESS);
if (strcasecmp(algorithm, "RSA") == 0) {
SetRsaKeyInfo(pkeyPrvCtx);
CRYPT_RSA_PkcsV15Para pkcsv15 = { CRYPT_MD_SHA256 };
ASSERT_EQ(
CRYPT_EAL_PkeyCtrl(pkeyPrvCtx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(CRYPT_RSA_PkcsV15Para)),
0);
ASSERT_EQ(
CRYPT_EAL_PkeyCtrl(pkeyPubCtx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(CRYPT_RSA_PkcsV15Para)),
0);
}
uint32_t signLen = CRYPT_EAL_PkeyGetSignLen(pkeyPrvCtx);
uint8_t *signdata = (uint8_t *)BSL_SAL_Malloc(signLen);
ASSERT_TRUE(signdata != NULL);
uint8_t data[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09};
uint32_t dataLen = sizeof(data);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyPrvCtx, hashId, data, dataLen, signdata, &signLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkeyPubCtx, hashId, data, dataLen, signdata, signLen), CRYPT_SUCCESS);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(signdata);
CRYPT_EAL_PkeyFreeCtx(pkeyPrvCtx);
CRYPT_EAL_PkeyFreeCtx(pkeyPubCtx);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
remove(GENPKEY_PRV_FILE_PATH);
remove(PKEY_PRV_FILE_PATH);
remove(PKEY_PUB_FILE_PATH);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_KEY_TC002
* @spec -
* @title 测试UT_HITLS_APP_KEY_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_KEY_TC002(char *algorithm, char *pkeyopt)
{
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
char *genpkeyPrv[20] = {"genpkey", "-algorithm", algorithm, "-pkeyopt", pkeyopt, "-out", GENPKEY_PRV_FILE_PATH};
char *pkeyPrv[20] = {"pkey", "-in", GENPKEY_PRV_FILE_PATH, "-out", PKEY_PRV_FILE_PATH};
ASSERT_EQ(HITLS_GenPkeyMain(7, genpkeyPrv), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_PkeyMain(5, pkeyPrv), HITLS_APP_SUCCESS);
CRYPT_EAL_ProviderRandInitCtx(NULL, CRYPT_RAND_AES128_CTR, "provider=default", NULL, 0, NULL);
CRYPT_EAL_PkeyCtx *pkeyPrvCtx = NULL;
ASSERT_EQ(CRYPT_EAL_DecodeFileKey(BSL_FORMAT_PEM, CRYPT_PRIKEY_PKCS8_UNENCRYPT, PKEY_PRV_FILE_PATH, NULL, 0,
&pkeyPrvCtx),
CRYPT_SUCCESS);
if (strcasecmp(algorithm, "RSA") == 0) {
SetRsaKeyInfo(pkeyPrvCtx);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyPrvCtx, CRYPT_CTRL_SET_RSA_OAEP_LABEL, NULL, 0), CRYPT_SUCCESS);
int32_t hashId = CRYPT_MD_SHA1;
BSL_Param oaepParam[3] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &hashId, sizeof(hashId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &hashId, sizeof(hashId), 0},
BSL_PARAM_END};
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyPrvCtx, CRYPT_CTRL_SET_RSA_RSAES_OAEP, oaepParam, 0),
CRYPT_SUCCESS);
} else if (strcasecmp(algorithm, "EC") == 0) {
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyPrvCtx, CRYPT_CTRL_GEN_ECC_PUBLICKEY, NULL, 0), CRYPT_SUCCESS);
}
uint8_t data[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09};
uint32_t dataLen = sizeof(data);
uint8_t encrypt[TMP_BUFF_LEN];
uint32_t encryptLen = TMP_BUFF_LEN;
ASSERT_EQ(CRYPT_EAL_PkeyEncrypt(pkeyPrvCtx, data, dataLen, encrypt, &encryptLen), CRYPT_SUCCESS);
uint8_t decrypt[TMP_BUFF_LEN];
uint32_t decryptLen = TMP_BUFF_LEN;
ASSERT_EQ(CRYPT_EAL_PkeyDecrypt(pkeyPrvCtx, encrypt, encryptLen, decrypt, &decryptLen), CRYPT_SUCCESS);
ASSERT_TRUE(dataLen == decryptLen);
ASSERT_TRUE(memcmp(data, decrypt, dataLen) == 0);
EXIT:
AppPrintErrorUioUnInit();
CRYPT_EAL_PkeyFreeCtx(pkeyPrvCtx);
CRYPT_EAL_RandDeinitEx(NULL);
remove(GENPKEY_PRV_FILE_PATH);
remove(PKEY_PRV_FILE_PATH);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_ENCKEY_TC001
* @spec -
* @title 测试UT_HITLS_APP_ENCKEY_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_ENCKEY_TC001(char *algorithm, char *pkeyopt, char *cipherAlg, int hashId)
{
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
char *genpkeyEncPrv[20] = {"genpkey", "-algorithm", algorithm, "-pkeyopt", pkeyopt, cipherAlg, "-pass", "pass:123456", "-out", GENPKEY_ENC_PRV_FILE_PATH};
char *pkeyEncPrv[20] = {"pkey", "-in", GENPKEY_ENC_PRV_FILE_PATH, "-passin", "pass:123456", cipherAlg, "-passout", "pass:123456", "-out", PKEY_ENC_PRV_FILE_PATH};
char *pkeyPub[20] = {"pkey", "-in", PKEY_ENC_PRV_FILE_PATH, "-passin", "pass:123456", "-pubout", "-out", PKEY_PUB_FILE_PATH};
ASSERT_EQ(HITLS_GenPkeyMain(10, genpkeyEncPrv), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_PkeyMain(10, pkeyEncPrv), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_PkeyMain(8, pkeyPub), HITLS_APP_SUCCESS);
CRYPT_RandRegist(TestSimpleRand);
CRYPT_RandRegistEx(TestSimpleRandEx);
CRYPT_EAL_PkeyCtx *pkeyEncPrvCtx = NULL;
CRYPT_EAL_PkeyCtx *pkeyPubCtx = NULL;
uint8_t pwd[] = { '1', '2', '3', '4', '5', '6' };
ASSERT_EQ(CRYPT_EAL_DecodeFileKey(BSL_FORMAT_PEM, CRYPT_PRIKEY_PKCS8_ENCRYPT, PKEY_ENC_PRV_FILE_PATH,
pwd, 6, &pkeyEncPrvCtx),
CRYPT_SUCCESS);
ASSERT_EQ(
CRYPT_EAL_DecodeFileKey(BSL_FORMAT_PEM, CRYPT_PUBKEY_SUBKEY, PKEY_PUB_FILE_PATH, NULL, 0, &pkeyPubCtx),
CRYPT_SUCCESS);
if (strcasecmp(algorithm, "RSA") == 0) {
CRYPT_RSA_PkcsV15Para pkcsv15 = { CRYPT_MD_SHA256 };
ASSERT_EQ(
CRYPT_EAL_PkeyCtrl(pkeyEncPrvCtx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(CRYPT_RSA_PkcsV15Para)),
0);
ASSERT_EQ(
CRYPT_EAL_PkeyCtrl(pkeyPubCtx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pkcsv15, sizeof(CRYPT_RSA_PkcsV15Para)),
0);
}
uint32_t signLen = CRYPT_EAL_PkeyGetSignLen(pkeyEncPrvCtx);
uint8_t *signdata = (uint8_t *)BSL_SAL_Malloc(signLen);
ASSERT_TRUE(signdata != NULL);
uint8_t data[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09};
uint32_t dataLen = sizeof(data);
ASSERT_EQ(CRYPT_EAL_PkeySign(pkeyEncPrvCtx, hashId, data, dataLen, signdata, &signLen), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyVerify(pkeyPubCtx, hashId, data, dataLen, signdata, signLen), CRYPT_SUCCESS);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(signdata);
CRYPT_EAL_PkeyFreeCtx(pkeyEncPrvCtx);
CRYPT_EAL_PkeyFreeCtx(pkeyPubCtx);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
remove(GENPKEY_ENC_PRV_FILE_PATH);
remove(PKEY_ENC_PRV_FILE_PATH);
remove(PKEY_PUB_FILE_PATH);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_ENCKEY_TC002
* @spec -
* @title 测试UT_HITLS_APP_ENCKEY_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_ENCKEY_TC002(char *algorithm, char *pkeyopt, char *cipherAlg)
{
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
char *genpkeyEncPrv[20] = {"genpkey", "-algorithm", algorithm, "-pkeyopt", pkeyopt, cipherAlg, "-pass", "pass:123456", "-out", GENPKEY_ENC_PRV_FILE_PATH};
char *pkeyEncPrv[20] = {"pkey", "-in", GENPKEY_ENC_PRV_FILE_PATH, "-passin", "pass:123456", cipherAlg, "-passout", "pass:123456", "-out", PKEY_ENC_PRV_FILE_PATH};
ASSERT_EQ(HITLS_GenPkeyMain(10, genpkeyEncPrv), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_PkeyMain(10, pkeyEncPrv), HITLS_APP_SUCCESS);
CRYPT_RandRegist(TestSimpleRand);
CRYPT_RandRegistEx(TestSimpleRandEx);
CRYPT_EAL_PkeyCtx *pkeyEncPrvCtx = NULL;
uint8_t pwd[] = { '1', '2', '3', '4', '5', '6' };
ASSERT_EQ(CRYPT_EAL_DecodeFileKey(BSL_FORMAT_PEM, CRYPT_PRIKEY_PKCS8_ENCRYPT, PKEY_ENC_PRV_FILE_PATH,
pwd, 6, &pkeyEncPrvCtx),
CRYPT_SUCCESS);
if (strcasecmp(algorithm, "RSA") == 0) {
SetRsaKeyInfo(pkeyEncPrvCtx);
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyEncPrvCtx, CRYPT_CTRL_SET_RSA_OAEP_LABEL, NULL, 0), CRYPT_SUCCESS);
int32_t hashId = CRYPT_MD_SHA1;
BSL_Param oaepParam[3] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &hashId, sizeof(hashId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &hashId, sizeof(hashId), 0},
BSL_PARAM_END};
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyEncPrvCtx, CRYPT_CTRL_SET_RSA_RSAES_OAEP, oaepParam, 0),
CRYPT_SUCCESS);
} else if (strcasecmp(algorithm, "EC") == 0) {
ASSERT_EQ(CRYPT_EAL_PkeyCtrl(pkeyEncPrvCtx, CRYPT_CTRL_GEN_ECC_PUBLICKEY, NULL, 0), CRYPT_SUCCESS);
}
uint8_t data[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09};
uint32_t dataLen = sizeof(data);
uint8_t encrypt[TMP_BUFF_LEN];
uint32_t encryptLen = TMP_BUFF_LEN;
ASSERT_EQ(CRYPT_EAL_PkeyEncrypt(pkeyEncPrvCtx, data, dataLen, encrypt, &encryptLen), CRYPT_SUCCESS);
uint8_t decrypt[TMP_BUFF_LEN];
uint32_t decryptLen = TMP_BUFF_LEN;
ASSERT_EQ(CRYPT_EAL_PkeyDecrypt(pkeyEncPrvCtx, encrypt, encryptLen, decrypt, &decryptLen), CRYPT_SUCCESS);
ASSERT_TRUE(dataLen == decryptLen);
ASSERT_TRUE(memcmp(data, decrypt, dataLen) == 0);
EXIT:
AppPrintErrorUioUnInit();
CRYPT_EAL_PkeyFreeCtx(pkeyEncPrvCtx);
CRYPT_RandRegist(NULL);
CRYPT_RandRegistEx(NULL);
remove(GENPKEY_ENC_PRV_FILE_PATH);
remove(PKEY_ENC_PRV_FILE_PATH);
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_app_key.c
|
C
|
unknown
| 13,362
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <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_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_replace.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 */
#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.so"
#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[] = "12345678";
(void)strcpy_s(buff, *buffLen, result);
*buffLen = (uint32_t)strlen(buff) + 1;
return BSL_SUCCESS;
}
static int32_t STUB_HITLS_APP_SM_IntegrityCheck(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_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#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_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#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_SM3, 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_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#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_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#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_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#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_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#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_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#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_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#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_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#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_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#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_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#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_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#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_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#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_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#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_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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);
EXIT:
CRYPT_EAL_PkeyFreeCtx(keyInfo.pkeyCtx);
BSL_SAL_FREE(smParam.uuid);
BSL_SAL_FREE(smParam.password);
AppTestUninit();
STUB_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#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_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_KEYMGMT_TC017(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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_SM3, "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_SM3, "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_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#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_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#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_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#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_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#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_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
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_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
#endif
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_app_keymgmt.c
|
C
|
unknown
| 44,153
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include "app_opt.h"
#include "app_print.h"
#include "bsl_uio.h"
#include "uio_abstraction.h"
#include "app_errno.h"
#include "crypt_errno.h"
#include "app_list.h"
#include "app_function.h"
#include "securec.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "stub_replace.h"
/* END_HEADER */
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_list.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c */
/**
* @test UT_HITLS_APP_LIST_TC001
* @spec -
* @title 测试UT_HITLS_APP_LIST_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_LIST_TC001(void)
{
char *argv[][20] = {
{"list", "-all-algorithms"},
{"list", "-digest-algorithms"},
{"list", "-cipher-algorithms"},
{"list", "-asym-algorithms"},
{"list", "-mac-algorithms"},
{"list", "-rand-algorithms"},
{"list", "-kdf-algorithms"},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_SUCCESS},
{2, argv[1], HITLS_APP_SUCCESS},
{2, argv[2], HITLS_APP_SUCCESS},
{2, argv[3], HITLS_APP_SUCCESS},
{2, argv[4], HITLS_APP_SUCCESS},
{2, argv[5], HITLS_APP_SUCCESS},
{2, argv[6], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_ListMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_LIST_TC002
* @spec -
* @title 测试UT_HITLS_APP_LIST_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_LIST_TC002(void)
{
char *argv[][20] = {
{"list", "-ttt"},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_OPT_UNKOWN},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_ListMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_app_list.c
|
C
|
unknown
| 2,836
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <linux/limits.h>
#include "securec.h"
#include "stub_replace.h"
#include "test.h"
#include "bsl_uio.h"
#include "bsl_types.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "sal_file.h"
#include "string.h"
#include "uio_abstraction.h"
#include "crypt_errno.h"
#include "app_opt.h"
#include "app_print.h"
#include "app_errno.h"
#include "app_function.h"
#include "app_provider.h"
#include "app_mac.h"
/* END_HEADER */
#define MAC_MAX_ARGC 22
#define MAX_BUFSIZE (1024 * 8)
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
static void PreProcArgs(char *args, int *argc, char **argv)
{
uint32_t len = strlen(args);
argv[(*argc)++] = args;
for (uint32_t i = 0; i < len; i++) {
if (args[i] == ' ') {
args[i] = '\0';
argv[(*argc)++] = args + i + 1;
}
}
if (APP_GetCurrent_LibCtx() == NULL) {
if (APP_Create_LibCtx() == NULL) {
(void)AppPrintError("Create g_libCtx failed\n");
}
}
}
static int32_t CompareOutByData(char *file1, Hex *data)
{
int ret = 1;
BSL_Buffer buff = {0};
char hexStr[2 * MAX_BUFSIZE + 1] = {0};
for (uint32_t i = 0; i < data->len; ++i) {
sprintf(hexStr + 2 * i, "%02x", data->x[i]);
}
uint32_t hexLen = strlen(hexStr);
ASSERT_EQ(BSL_SAL_ReadFile(file1, &buff.data, &buff.dataLen), 0);
ASSERT_EQ(buff.dataLen, hexLen);
ASSERT_COMPARE("Compare out data", buff.data, buff.dataLen, hexStr, hexLen);
ret = 0;
EXIT:
BSL_SAL_Free(buff.data);
return ret;
}
/**
* @test UT_HITLS_APP_MAC_InvalidOpt_TC001
* @title Test the invalid parameters of the mac command.
* @brief Enter parameters and return the error code expectRet.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_MAC_InvalidOpt_TC001(char *opts, int expectRet)
{
system("echo what do ya want for nothing? > test.txt");
int argc = 0;
char *argv[MAC_MAX_ARGC] = {0};
char *tmp = strdup(opts);
ASSERT_NE(tmp, NULL);
PreProcArgs(tmp, &argc, argv);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_MacMain(argc, argv), expectRet);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(tmp);
}
/* END_CASE */
/**
* @test UT_HITLS_APP_MAC_NormalOpt_TC001
* @title Test the normal parameters of the mac command.
* @brief Enter parameters and return HITLS_APP_SUCCESS.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_MAC_NormalOpt_TC001(char *opts, char *outFile, Hex *expectData)
{
printf("----------------------------------MAC_NormalOpt:");
int argc = 0;
char *argv[MAC_MAX_ARGC] = {0};
char *tmp = strdup(opts);
ASSERT_NE(tmp, NULL);
PreProcArgs(tmp, &argc, argv);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_MacMain(argc, argv), HITLS_APP_SUCCESS);
ASSERT_EQ(CompareOutByData(outFile, expectData), HITLS_APP_SUCCESS);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(tmp);
remove(outFile);
}
/* END_CASE */
/**
* @test UT_HITLS_APP_mac_TC002
* @spec -
* @title 测试UT_HITLS_APP_mac_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_mac_TC002(void)
{
char *argv[][10] = {
{"mac", "-help"},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_HELP},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_MacMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_app_mac.c
|
C
|
unknown
| 4,190
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <securec.h>
#include "app_passwd.h"
#include "app_errno.h"
#include "app_help.h"
#include "app_print.h"
#include "app_opt.h"
#include "bsl_ui.h"
#include "stub_replace.h"
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_passwd.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c */
/* END_HEADER */
#define BSL_SUCCESS 0
typedef struct {
int argc;
char **argv;
int expect;
} PasswdTestData;
int32_t STUB_BSL_UI_ReadPwdUtil(BSL_UI_ReadPwdParam *param, char *buff, uint32_t *buffLen, const BSL_UI_CheckDataCallBack checkDataCallBack, void *callBackData)
{
(void)param;
(void)checkDataCallBack;
(void)callBackData;
char result[] = "12345678";
(void)strcpy_s(buff, *buffLen, result);
*buffLen = (uint32_t)strlen(buff) + 1;
return BSL_SUCCESS;
}
/**
* @test UT_HITLS_APP_passwd_TC001
* @spec -
* @title test UT_HITLS_APP_passwd_TC001 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_passwd_TC001(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
char *argv[][10] = {
{"passwd", "-help"},
{"passwd", "-sha512"},
{"passwd", "-sha512", "-out", "PasswdOutFile"},
{"passwd", "-sha256"},
{"passwd"}
};
PasswdTestData testData[] = {
{2, argv[0], HITLS_APP_HELP},
{2, argv[1], HITLS_APP_SUCCESS},
{4, argv[2], HITLS_APP_SUCCESS},
{2, argv[3], HITLS_APP_OPT_UNKOWN},
{1, argv[4], HITLS_APP_OPT_VALUE_INVALID}
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(PasswdTestData)); ++i) {
int ret = HITLS_PasswdMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_BSL_UI_ReadPwdUtilIsZero(BSL_UI_ReadPwdParam *param, char *buff, uint32_t *buffLen, const BSL_UI_CheckDataCallBack checkDataCallBack, void *callBackData)
{
(void)param;
(void)checkDataCallBack;
(void)callBackData;
(void)buff;
(void)buffLen;
return BSL_SUCCESS;
}
int32_t STUB_BSL_UI_ReadPwdUtilIs1024(BSL_UI_ReadPwdParam *param, char *buff, uint32_t *buffLen,
const BSL_UI_CheckDataCallBack checkDataCallBack, void *callBackData)
{
(void)param;
(void)checkDataCallBack;
(void)callBackData;
char result[] =
"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"1111111111111111111111111111111111";
printf("=======%d\n", *buffLen);
(void)strcpy_s(buff, *buffLen, result);
*buffLen = (uint32_t)strlen(result) + 1;
printf("=======%d\n", *buffLen);
return BSL_SUCCESS;
}
/* *
* @test UT_HITLS_APP_passwd_TC002
* @spec -
* @title test UT_HITLS_APP_passwd_TC002 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_passwd_TC002(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtilIsZero);
char *argv[][10] = {
{"passwd", "-sha512", "-out", "PasswdOutFile"},
};
PasswdTestData testData[] = {
{4, argv[0], HITLS_APP_PASSWD_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(PasswdTestData)); ++i) {
int ret = HITLS_PasswdMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
/* *
* @test UT_HITLS_APP_passwd_TC003
* @spec -
* @title test UT_HITLS_APP_passwd_TC003 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_passwd_TC003(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtilIs1024);
char *argv[][10] = {
{"passwd", "-sha512", "-out", "PasswdOutFile"},
};
PasswdTestData testData[] = {
{4, argv[0], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(PasswdTestData)); ++i) {
int ret = HITLS_PasswdMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_app_passwd.c
|
C
|
unknown
| 6,159
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include "app_opt.h"
#include "app_print.h"
#include "bsl_uio.h"
#include "uio_abstraction.h"
#include "crypt_eal_rand.h"
#include "app_errno.h"
#include "bsl_base64.h"
#include "crypt_errno.h"
#include "app_pkcs12.h"
#include "app_function.h"
#include "securec.h"
#include "bsl_err.h"
#include "bsl_sal.h"
#include "bsl_ui.h"
#include "stub_replace.h"
/* END_HEADER */
#define PRI_KEY "../testdata/apps/pkcs12/server.key"
#define CERT "../testdata/apps/pkcs12/server.crt"
#define CHAIN "../testdata/apps/pkcs12/chain.crt"
#define NO_EXIST_FILE "noexistfile"
#define LARGE_FILE "../testdata/apps/x509/257k.pem"
#define EMPTY_FILE "../testdata/apps/pkcs12/empty.pem"
#define PFX "../testdata/apps/pkcs12/out.pfx"
#define NO_MACP12 "../testdata/apps/pkcs12/nomac.p12"
#define MIN_PASSWD "pass:12345678"
#define MAX_PASSWD \
"pass:" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111"
#define SHORT_PASSWD "pass:"
#define LONG_PASSWD \
"pass:" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"11111111111111111"
#define FILE_PASSWD "file:../testdata/apps/pkcs12/pass.txt"
#define PARAM_PASSWD "pass:12345678"
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_pkcs12.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c */
/**
* @test UT_HITLS_APP_PKCS12_TC001
* @spec -
* @title test UT_HITLS_APP_PKCS12_TC001 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC001(void)
{
char *argv[][16] = {
{"pkcs12", "-help"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile", CHAIN,
"-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-passout", "pass:12345678", "-out", "decode_pfx.pem"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-passout", "pass:12345678", "-out", "decode_pfx.pem", "-clcerts", "-aes256-cbc"},
{"pkcs12", "-in", NO_MACP12, "-passin", "pass:12345678", "-passout", "pass:12345678", "-out", "decode_pfx.pem", "-clcerts", "-aes256-cbc"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", FILE_PASSWD, "-chain", "-CAfile", CHAIN,
"-passout", FILE_PASSWD, "-out", "out.pfx"},
{"pkcs12", "-in", "out.pfx", "-passin", FILE_PASSWD, "-passout", FILE_PASSWD, "-out", "decode_pfx.pem"},
{"pkcs12", "-in", "out.pfx", "-passin", PARAM_PASSWD, "-passout", PARAM_PASSWD, "-out", "decode_pfx.pem"},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_HELP},
{15, argv[1], HITLS_APP_SUCCESS},
{9, argv[2], HITLS_APP_SUCCESS},
{11, argv[3], HITLS_APP_SUCCESS},
{11, argv[4], HITLS_APP_SUCCESS},
{15, argv[5], HITLS_APP_SUCCESS},
{9, argv[6], HITLS_APP_SUCCESS},
{9, argv[7], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PKCS12Main(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKCS12_TC002
* @spec -
* @title test UT_HITLS_APP_PKCS12_TC002 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC002(void)
{
char *argv[][16] = {
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-chain", "-CAfile", CHAIN,
"-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-chain", "-CAfile", CHAIN,
"-passout", SHORT_PASSWD, "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-chain", "-CAfile", CHAIN,
"-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-chain", "-CAfile", CHAIN,
"-passout", LONG_PASSWD, "-out", "out.pfx"},
{"pkcs12", "-in", PFX, "-passin", SHORT_PASSWD, "-passout", "pass:12345678", "-out", "decode_pfx.pem"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-passout", SHORT_PASSWD, "-out", "decode_pfx.pem"},
{"pkcs12", "-in", PFX, "-passin", LONG_PASSWD, "-passout", "pass:12345678", "-out", "decode_pfx.pem"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-passout", LONG_PASSWD, "-out", "decode_pfx.pem"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-chain", "-CAfile", CHAIN,
"-passout", MIN_PASSWD, "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-chain", "-CAfile", CHAIN,
"-passout", MAX_PASSWD, "-out", "out.pfx"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-passout", MIN_PASSWD, "-out", "decode_pfx.pem"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-passout", MAX_PASSWD, "-out", "decode_pfx.pem"},
};
OptTestData testData[] = {
{13, argv[0], HITLS_APP_SUCCESS},
{13, argv[1], HITLS_APP_PASSWD_FAIL},
{13, argv[2], HITLS_APP_SUCCESS},
{13, argv[3], HITLS_APP_PASSWD_FAIL},
{9, argv[4], HITLS_APP_PASSWD_FAIL},
{9, argv[5], HITLS_APP_PASSWD_FAIL},
{9, argv[6], HITLS_APP_PASSWD_FAIL},
{9, argv[7], HITLS_APP_PASSWD_FAIL},
{13, argv[8], HITLS_APP_SUCCESS},
{13, argv[9], HITLS_APP_SUCCESS},
{9, argv[10], HITLS_APP_SUCCESS},
{9, argv[11], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PKCS12Main(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKCS12_TC003
* @spec -
* @title Test UT_HITLS_APP_PKCS12_TC003 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC003(void)
{
char *argv[][16] = {
{"pkcs12", "-export", "-in", NO_EXIST_FILE, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", NO_EXIST_FILE, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
NO_EXIST_FILE, "-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-in", NO_EXIST_FILE, "-passin", "pass:12345678", "-passout", "pass:12345678", "-out", "decode.pem"},
{"pkcs12", "-export", "-in", EMPTY_FILE, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", EMPTY_FILE, "-passin", "pass:12345678", "-chain", "-CAfile", CHAIN,
"-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
EMPTY_FILE, "-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-in", EMPTY_FILE, "-passin", "pass:12345678", "-passout", "pass:12345678", "-out", "decode.pem"},
{"pkcs12", "-export", "-in", LARGE_FILE, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", LARGE_FILE, "-passin", "pass:12345678", "-chain", "-CAfile", CHAIN,
"-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
LARGE_FILE, "-passout", "pass:12345678", "-out", "out.pfx"},
};
OptTestData testData[] = {
{15, argv[0], HITLS_APP_BSL_FAIL},
{15, argv[1], HITLS_APP_BSL_FAIL},
{15, argv[2], HITLS_APP_BSL_FAIL},
{9, argv[3], HITLS_APP_BSL_FAIL},
{15, argv[4], HITLS_APP_X509_FAIL},
{15, argv[5], HITLS_APP_LOAD_KEY_FAIL},
{15, argv[6], HITLS_APP_X509_FAIL},
{9, argv[7], HITLS_APP_X509_FAIL},
{15, argv[8], HITLS_APP_UIO_FAIL},
{15, argv[9], HITLS_APP_UIO_FAIL},
{15, argv[10], HITLS_APP_UIO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PKCS12Main(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKCS12_TC004
* @spec -
* @title Test UT_HITLS_APP_PKCS12_TC004 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC004(void)
{
char *argv[][18] = {
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-keypbe", "PBE-SHA1-RC4-128"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-keypbe", "PBE-SHA1-RC4-40"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-keypbe", "PBE-SHA1-RC2-128"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-keypbe", "PBE-SHA1-3DES"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-keypbe", "PBES2"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-keypbe", "INVALID_ALG"},
};
OptTestData testData[] = {
{17, argv[0], HITLS_APP_OPT_VALUE_INVALID},
{17, argv[1], HITLS_APP_OPT_VALUE_INVALID},
{17, argv[2], HITLS_APP_OPT_VALUE_INVALID},
{17, argv[3], HITLS_APP_OPT_VALUE_INVALID},
{17, argv[4], HITLS_APP_SUCCESS},
{17, argv[5], HITLS_APP_OPT_VALUE_INVALID},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PKCS12Main(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKCS12_TC005
* @spec -
* @title Test UT_HITLS_APP_PKCS12_TC005 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC005(void)
{
char *argv[][18] = {
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-certpbe", "PBE-SHA1-RC4-128"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-certpbe", "PBE-SHA1-RC4-40"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-certpbe", "PBE-SHA1-RC2-128"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-certpbe", "PBE-SHA1-3DES"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-certpbe", "PBES2"},
};
OptTestData testData[] = {
{17, argv[0], HITLS_APP_OPT_VALUE_INVALID},
{17, argv[1], HITLS_APP_OPT_VALUE_INVALID},
{17, argv[2], HITLS_APP_OPT_VALUE_INVALID},
{17, argv[3], HITLS_APP_OPT_VALUE_INVALID},
{17, argv[4], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PKCS12Main(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKCS12_TC006
* @spec -
* @title Test UT_HITLS_APP_PKCS12_TC006 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC006(void)
{
char *argv[][18] = {
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-macalg", "sha224"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-macalg", "INVALID_ALG"},
};
OptTestData testData[] = {
{17, argv[0], HITLS_APP_SUCCESS},
{17, argv[1], HITLS_APP_OPT_VALUE_INVALID},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PKCS12Main(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKCS12_TC007
* @spec -
* @title Test UT_HITLS_APP_PKCS12_TC007 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC007(void)
{
char invalidName[2048] = {0};
(void)memset_s(invalidName, sizeof(invalidName) - 1, 'a', sizeof(invalidName) - 1);
char *argv[][18] = {
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-name", "testname"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-name"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx", "-name", invalidName},
};
OptTestData testData[] = {
{17, argv[0], HITLS_APP_SUCCESS},
{16, argv[1], HITLS_APP_OPT_UNKOWN},
{17, argv[2], HITLS_APP_OPT_VALUE_INVALID},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PKCS12Main(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKCS12_TC008
* @spec -
* @title Test UT_HITLS_APP_PKCS12_TC008 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC008(void)
{
char *validPwd = "file:../testdata/apps/pass/size_1024_pass";
char *invalidPwd = "file:../testdata/apps/pass/size_1025_pass";
char *emptyPwd = "file:../testdata/apps/pass/empty_pass";
char *argv[][18] = {
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", validPwd, "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", invalidPwd, "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", emptyPwd, "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-passout", "file:noexistfile", "-out", "out.pfx"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-passout", validPwd, "-out", "decode_pfx.pem"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-passout", invalidPwd, "-out", "decode_pfx.pem"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-passout", emptyPwd, "-out", "decode_pfx.pem"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-passout", "file:noexistfile", "-out", "decode_pfx.pem"},
};
OptTestData testData[] = {
{15, argv[0], HITLS_APP_SUCCESS},
{15, argv[1], HITLS_APP_PASSWD_FAIL},
{15, argv[2], HITLS_APP_PASSWD_FAIL},
{15, argv[3], HITLS_APP_PASSWD_FAIL},
{9, argv[4], HITLS_APP_SUCCESS},
{9, argv[5], HITLS_APP_PASSWD_FAIL},
{9, argv[6], HITLS_APP_PASSWD_FAIL},
{9, argv[7], HITLS_APP_PASSWD_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PKCS12Main(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
static int32_t BSL_UI_ReadPwdUtil_Mock(BSL_UI_ReadPwdParam *param, char *buff, uint32_t *buffLen,
const BSL_UI_CheckDataCallBack checkDataCallBack, void *callBackData)
{
(void)param;
(void)checkDataCallBack;
(void)callBackData;
(void)memcpy_s(buff, *buffLen, "12345678", strlen("12345678"));
*buffLen = strlen("12345678") + 1;
return HITLS_APP_SUCCESS;
}
/**
* @test UT_HITLS_APP_PKCS12_TC009
* @spec -
* @title Test UT_HITLS_APP_PKCS12_TC009 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC009(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UI_ReadPwdUtil, BSL_UI_ReadPwdUtil_Mock);
char *argv[][18] = {
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-chain", "-CAfile",
CHAIN, "-passout", "pass:12345678", "-out", "out.pfx"},
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-passin", "pass:12345678", "-chain", "-CAfile",
CHAIN, "-out", "out.pfx"},
{"pkcs12", "-in", PFX, "-passout", "pass:12345678", "-out", "decode_pfx.pem"},
{"pkcs12", "-in", PFX, "-passin", "pass:12345678", "-out", "decode_pfx.pem"},
};
OptTestData testData[] = {
{13, argv[0], HITLS_APP_SUCCESS},
{13, argv[1], HITLS_APP_SUCCESS},
{7, argv[2], HITLS_APP_SUCCESS},
{7, argv[3], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PKCS12Main(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
static void SplitArgs(char *str, char **result, int *count) {
char *token;
token = strtok(str, " ");
while (token != NULL) {
result[*count] = token;
(*count)++;
token = strtok(NULL, " ");
}
}
/**
* @test UT_HITLS_APP_PKCS12_TC010
* @spec -
* @title Test HITLS_PKCS12Main function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC010(char *arg, int expect)
{
char *argv[30] = {};
int argc = 0;
SplitArgs(arg, argv, &argc);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
int ret = HITLS_PKCS12Main(argc, argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, expect);
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
int32_t STUB_CRYPT_EAL_RandInit(
CRYPT_EAL_LibCtx *libCtx, int32_t algId, const char *attrName,
const uint8_t *pers, uint32_t persLen, BSL_Param *param)
{
(void)libCtx;
(void)algId;
(void)attrName;
(void)pers;
(void)persLen;
(void)param;
return CRYPT_EAL_ERR_DRBG_INIT_FAIL;
}
/**
* @test UT_HITLS_APP_PKCS12_TC011
* @spec -
* @title Test HITLS_PKCS12Main function init rand failed
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC011(char *arg, int expect)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, CRYPT_EAL_ProviderRandInitCtx, STUB_CRYPT_EAL_RandInit);
char *argv[30] = {};
int argc = 0;
SplitArgs(arg, argv, &argc);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
int ret = HITLS_PKCS12Main(argc, argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, expect);
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKCS12_TC012
* @spec -
* @title Test HITLS_PKCS12Main function file pass
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKCS12_TC012(char *passFile, char *passArg, int expect)
{
char *argv[][16] = {
{"pkcs12", "-export", "-in", CERT, "-inkey", PRI_KEY, "-chain", "-CAfile", CHAIN,
"-passout", passFile, "-out", "out.pfx"},
{"pkcs12", "-in", "out.pfx", "-passin", passArg, "-passout", passArg, "-out", "decode_pfx.pem"},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
int32_t ret = HITLS_PKCS12Main(13, argv[0]);
ASSERT_EQ(ret, expect);
if (expect == HITLS_APP_SUCCESS) {
ASSERT_EQ(HITLS_PKCS12Main(9, argv[1]), expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_app_pkcs12.c
|
C
|
unknown
| 24,939
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "app_opt.h"
#include "app_print.h"
#include "sal_file.h"
#include "bsl_uio.h"
#include "bsl_ui.h"
#include "uio_abstraction.h"
#include "app_errno.h"
#include "crypt_errno.h"
#include "app_pkey.h"
#include "app_function.h"
#include "securec.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "stub_replace.h"
/* END_HEADER */
#define BAD_KEY_PATH "../testdata/apps/pkey/bad_rsa.pem"
#define PKEY_TEST_FILE_PATH "out_test.pem"
#define PKEY_TEST_DIR_PATH "./pkey_dir"
#define PKEY_MAX_ARGC 10
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
static void PreProcArgs(char *args, int *argc, char **argv)
{
uint32_t len = strlen(args);
argv[(*argc)++] = args;
for (uint32_t i = 0; i < len; i++) {
if (args[i] == ' ') {
args[i] = '\0';
argv[(*argc)++] = args + i + 1;
}
}
}
static int32_t CompareOutByData(char *file1, Hex *data)
{
int ret = 1;
BSL_Buffer buff = {0};
ASSERT_EQ(BSL_SAL_ReadFile(file1, &buff.data, &buff.dataLen), 0);
ASSERT_EQ(buff.dataLen, data->len);
ASSERT_COMPARE("Compare out data", buff.data, buff.dataLen, data->x, data->len);
ret = 0;
EXIT:
BSL_SAL_Free(buff.data);
return ret;
}
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_pkey.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c */
/**
* @test UT_HITLS_APP_PKEY_TC001
* @spec -
* @title 测试UT_HITLS_APP_PKEY_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKEY_TC001(char *encKeyPath)
{
char *argv[][20] = {
{"pkey", "-in", encKeyPath, "-passin", "pass:123456"},
{"pkey", "-in", encKeyPath, "-passin", "pass:123456", "-out", PKEY_TEST_FILE_PATH},
{"pkey", "-in", encKeyPath, "-passin", "pass:123456", "-aes256-cbc", "-passout", "pass:123456"},
{"pkey", "-in", encKeyPath, "-passin", "pass:123456", "-aes256-cbc", "-passout", "pass:123456",
"-out", PKEY_TEST_FILE_PATH},
{"pkey", "-in", encKeyPath, "-passin", "pass:123456", "-pubout"},
{"pkey", "-in", encKeyPath, "-passin", "pass:123456", "-out", PKEY_TEST_FILE_PATH},
};
OptTestData testData[] = {
{5, argv[0], HITLS_APP_SUCCESS},
{7, argv[1], HITLS_APP_SUCCESS},
{8, argv[2], HITLS_APP_SUCCESS},
{10, argv[3], HITLS_APP_SUCCESS},
{6, argv[4], HITLS_APP_SUCCESS},
{7, argv[5], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PkeyMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
remove(PKEY_TEST_FILE_PATH);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKEY_TC002
* @spec -
* @title 测试UT_HITLS_APP_PKEY_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKEY_TC002(char *keyPath)
{
char *argv[][20] = {
{"pkey", "-in", keyPath},
{"pkey", "-in", keyPath, "-out", PKEY_TEST_FILE_PATH},
{"pkey", "-in", keyPath, "-pubout"},
{"pkey", "-in", keyPath, "-pubout", "-out", PKEY_TEST_FILE_PATH},
};
OptTestData testData[] = {
{3, argv[0], HITLS_APP_SUCCESS},
{5, argv[1], HITLS_APP_SUCCESS},
{4, argv[2], HITLS_APP_SUCCESS},
{6, argv[3], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PkeyMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
remove(PKEY_TEST_FILE_PATH);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKEY_TC003
* @spec -
* @title 测试UT_HITLS_APP_PKEY_TC003函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKEY_TC003(char *encKeyPath, char *keyPath)
{
mkdir(PKEY_TEST_DIR_PATH, 0775);
char *argv[][20] = {
{"pkey", "-ttt"},
{"pkey", "-in", "no_exist.pem"},
{"pkey", "-in", BAD_KEY_PATH},
{"pkey", "-in", encKeyPath, "-passin", "err:12"},
{"pkey", "-in", encKeyPath, "-passin", "pass:"},
{"pkey", "-in", keyPath, "-passout", "err:12"},
{"pkey", "-in", keyPath, "-aes256-cbc", "-passout", "pass:"},
{"pkey", "-in", keyPath, "-out", PKEY_TEST_DIR_PATH},
{"pkey", "-in", keyPath, "-pubout", "-out", PKEY_TEST_DIR_PATH},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_OPT_UNKOWN},
{3, argv[1], HITLS_APP_LOAD_KEY_FAIL},
{3, argv[2], HITLS_APP_LOAD_KEY_FAIL},
{5, argv[3], HITLS_APP_PASSWD_FAIL},
{5, argv[4], HITLS_APP_LOAD_KEY_FAIL},
{5, argv[5], HITLS_APP_PASSWD_FAIL},
{6, argv[6], HITLS_APP_PASSWD_FAIL},
{5, argv[7], HITLS_APP_UIO_FAIL},
{6, argv[8], HITLS_APP_UIO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PkeyMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
rmdir(PKEY_TEST_DIR_PATH);
remove(PKEY_TEST_FILE_PATH);
return;
}
/* END_CASE */
static int32_t BSL_UI_ReadPwdUtil_Mock(BSL_UI_ReadPwdParam *param, char *buff, uint32_t *buffLen,
const BSL_UI_CheckDataCallBack checkDataCallBack, void *callBackData)
{
(void)param;
(void)checkDataCallBack;
(void)callBackData;
(void)buff;
(void)buffLen;
return HITLS_APP_PASSWD_FAIL;
}
/**
* @test UT_HITLS_APP_PKEY_TC004
* @spec -
* @title 测试UT_HITLS_APP_PKEY_TC004函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKEY_TC004(char *encKeyPath, char *keyPath)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UI_ReadPwdUtil, BSL_UI_ReadPwdUtil_Mock);
char *argv[][20] = {
{"pkey", "-in", keyPath, "-passin", "pass:"},
{"pkey", "-in", keyPath, "-passin", "stdin"},
{"pkey", "-in", keyPath, "-passout", "pass:"},
{"pkey", "-in", keyPath, "-passout", "stdin"},
{"pkey", "-in", encKeyPath, "-passin", "pass:"},
{"pkey", "-in", encKeyPath, "-passin", "stdin"},
{"pkey", "-in", encKeyPath},
{"pkey", "-in", keyPath, "-aes256-cbc", "-passout", "pass:"},
{"pkey", "-in", keyPath, "-aes256-cbc", "-passout", "stdin"},
{"pkey", "-in", keyPath, "-aes256-cbc"},
};
OptTestData testData[] = {
{5, argv[0], HITLS_APP_SUCCESS},
{5, argv[1], HITLS_APP_SUCCESS},
{5, argv[2], HITLS_APP_SUCCESS},
{5, argv[3], HITLS_APP_SUCCESS},
{5, argv[4], HITLS_APP_LOAD_KEY_FAIL},
{5, argv[5], HITLS_APP_LOAD_KEY_FAIL},
{3, argv[6], HITLS_APP_LOAD_KEY_FAIL},
{6, argv[7], HITLS_APP_PASSWD_FAIL},
{6, argv[8], HITLS_APP_PASSWD_FAIL},
{4, argv[9], HITLS_APP_PASSWD_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_PkeyMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
remove(PKEY_TEST_FILE_PATH);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_PKEY_IN_FILE_SIZE_TC001
* @title Test the limit size of input key file.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_PKEY_IN_FILE_SIZE_TC001(char *opts, int ret, char *outFile, Hex *expectOut)
{
int argc = 0;
char *argv[PKEY_MAX_ARGC] = {0};
char *tmp = strdup(opts);
ASSERT_NE(tmp, NULL);
PreProcArgs(tmp, &argc, argv);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_PkeyMain(argc, argv), ret);
if (ret == 0) {
ASSERT_EQ(CompareOutByData(outFile, expectOut), HITLS_APP_SUCCESS);
}
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(tmp);
// remove(outFile);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_app_pkey.c
|
C
|
unknown
| 9,075
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include "app_opt.h"
#include "app_print.h"
#include "bsl_uio.h"
#include "uio_abstraction.h"
#include "app_errno.h"
#include "crypt_errno.h"
#include "app_req.h"
#include "app_function.h"
#include "securec.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "stub_replace.h"
/* END_HEADER */
static void SplitArgs(char *str, char **result, int *count) {
char *token;
token = strtok(str, " ");
while (token != NULL) {
result[*count] = token;
(*count)++;
token = strtok(NULL, " ");
}
}
/**
* @test UT_HITLS_APP_REQ_TC001
* @spec -
* @title 测试UT_HITLS_APP_REQ_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_REQ_TC001(char *arg, int expect)
{
char *argv[20] = {};
int argc = 0;
SplitArgs(arg, argv, &argc);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
int ret = HITLS_ReqMain(argc, argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, expect);
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_app_req.c
|
C
|
unknown
| 1,614
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <termios.h>
#include <unistd.h>
#include "securec.h"
#include "app_opt.h"
#include "app_print.h"
#include "app_utils.h"
#include "bsl_uio.h"
#include "app_errno.h"
#include "app_rsa.h"
#include "app_function.h"
#include "bsl_sal.h"
#include "bsl_err.h"
#include "app_rsa.h"
#include "stub_replace.h"
#include "app_utils.h"
#include "bsl_types.h"
#include "crypt_eal_codecs.h"
#include "crypt_errno.h"
/* END_HEADER */
#define PRV_PATH "../testdata/certificate/rsa_key/prvKey.pem"
#define PRV_PASSWD_PATH "../testdata/cert/asn1/keypem/rsa-pri-key-p8-2048.pem"
#define PRV_DER_PATH "../testdata/cert/asn1/rsa2048key_pkcs1.der"
#define OUT_FILE_PATH "../testdata/certificate/rsa_key/out.pem"
typedef struct {
int32_t outformat;
bool text;
bool noout;
char *outfile;
} OutputInfo;
typedef struct {
int argc;
char **argv;
int expect;
} RsaTestData;
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_rsa.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c */
/**
* @test UT_HITLS_APP_rsa_TC001
* @spec -
* @title 测试UT_HITLS_APP_rsa_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_TC001(void)
{
char *argv[][10] = {
{"rsa", "-in", PRV_PATH, "-noout"},
{"rsa", "-in", PRV_PATH, "-out", OUT_FILE_PATH},
{"rsa", "-in", PRV_PATH, "-out", OUT_FILE_PATH, "-text"},
{"rsa", "-in", PRV_PATH, "-out", OUT_FILE_PATH, "-text", "-noout"},
{"rsa", "-in", PRV_PATH, "-out", "/test/noexist/out.pem"},
{"rsa", "-in", "noexist.pem", "-text"}};
RsaTestData testData[] = {{4, argv[0], HITLS_APP_SUCCESS},
{5, argv[1], HITLS_APP_SUCCESS},
{6, argv[2], HITLS_APP_SUCCESS},
{7, argv[3], HITLS_APP_SUCCESS},
{5, argv[4], HITLS_APP_UIO_FAIL},
{4, argv[5], HITLS_APP_UIO_FAIL}
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_rsa_T002
* @spec -
* @title 测试UT_HITLS_APP_rsa_T002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_TC002(void)
{
char *argv[][2] = {
{"rsa", "-help"},
};
RsaTestData testData[] = {
{2, argv[0], HITLS_APP_HELP},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
int32_t STUB_HITLS_APP_OptBegin(int32_t argc, char **argv, const HITLS_CmdOption *opts)
{
(void)argc;
(void)argv;
(void)opts;
return HITLS_APP_OPT_UNKOWN;
}
/**
* @test UT_HITLS_APP_rsa_T003
* @spec -
* @title 测试UT_HITLS_APP_rsa_T003函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_T003(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptBegin, STUB_HITLS_APP_OptBegin);
char *argv[][4] = {{"rsa", "-in", PRV_PATH, "-noout"}};
RsaTestData testData[] = {
{4, argv[0], HITLS_APP_OPT_UNKOWN},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_CRYPT_EAL_DecodeBuffKey(BSL_ParseFormat format, int32_t type, BSL_Buffer *encode,
uint8_t *pwd, uint32_t pwdlen, CRYPT_EAL_PkeyCtx **ealPKey)
{
(void)format;
(void)type;
(void)encode;
(void)pwd;
(void)pwdlen;
(void)ealPKey;
return HITLS_APP_DECODE_FAIL;
}
/**
* @test UT_HITLS_APP_rsa_T004
* @spec -
* @title 测试UT_HITLS_APP_rsa_T004函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_T004(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, CRYPT_EAL_DecodeBuffKey, STUB_CRYPT_EAL_DecodeBuffKey);
char *argv[][10] = {{"rsa", "-in", PRV_PATH, "-noout"}};
RsaTestData testData[] = {
{4, argv[0], HITLS_APP_DECODE_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
BSL_UIO *STUB_BSL_UIO_New(const BSL_UIO_Method *method)
{
(void)method;
return NULL;
}
/**
* @test UT_HITLS_APP_rsa_T005
* @spec -
* @title 测试UT_HITLS_APP_rsa_T005函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_T005(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UIO_New, STUB_BSL_UIO_New);
char *argv[][10] = {{"rsa", "-in", PRV_PATH, "-noout"}};
RsaTestData testData[] = {
{4, argv[0], HITLS_APP_UIO_FAIL},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_BSL_UIO_Ctrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *parg)
{
(void)uio;
(void)cmd;
(void)larg;
(void)parg;
return BSL_NULL_INPUT;
}
/**
* @test UT_HITLS_APP_rsa_T006
* @spec -
* @title 测试UT_HITLS_APP_rsa_T006函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_T006(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UIO_Ctrl, STUB_BSL_UIO_Ctrl);
char *argv[][10] = {{"rsa", "-in", PRV_PATH, "-noout"}};
RsaTestData testData[] = {
{4, argv[0], HITLS_APP_UIO_FAIL},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
char *STUB_HITLS_APP_OptGetValueStr(void)
{
return NULL;
}
/**
* @test UT_HITLS_APP_rsa_T007
* @spec -
* @title 测试UT_HITLS_APP_rsa_T007函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_T007(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptGetValueStr, STUB_HITLS_APP_OptGetValueStr);
char *argv[][10] = {{"rsa", "-in", PRV_PATH, "-noout"}};
RsaTestData testData[] = {
{4, argv[0], HITLS_APP_OPT_VALUE_INVALID},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_HITLS_APP_OptWriteUio(BSL_UIO *uio, uint8_t *buf, uint32_t outLen, int32_t format)
{
(void)uio;
(void)buf;
(void)outLen;
(void)format;
return HITLS_APP_UIO_FAIL;
}
/**
* @test UT_HITLS_APP_rsa_T008
* @spec -
* @title 测试UT_HITLS_APP_rsa_T008函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_T008(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptWriteUio, STUB_HITLS_APP_OptWriteUio);
char *argv[][10] = {{"rsa", "-in", PRV_PATH, "-text"}};
RsaTestData testData[] = {
{4, argv[0], HITLS_APP_UIO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
bool IsFileExist(const char *fileName)
{
FILE *f = fopen(fileName, "r");
if (f == NULL) {
return false;
}
fclose(f);
return true;
}
/**
* @test UT_HITLS_APP_rsa_T009
* @spec -
* @title 测试UT_HITLS_APP_rsa_T009函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_T009(void)
{
char *filename = "_APP_rsa_T009.txt";
char *argv[][10] = {{"rsa", "-in", PRV_PATH, "-out", filename}};
RsaTestData testData[] = {{5, argv[0], HITLS_APP_SUCCESS}};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
ASSERT_TRUE(IsFileExist(filename) == false);
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
ASSERT_TRUE(IsFileExist(filename));
remove(filename);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
int32_t STUB_CRYPT_EAL_EncodeBuffKey(CRYPT_EAL_PkeyCtx *ealPKey, CRYPT_EncodeParam *encodeParam,
BSL_ParseFormat format, int32_t type, BSL_Buffer *encode)
{
(void)ealPKey;
(void)encodeParam;
(void)format;
(void)type;
(void)encode;
return HITLS_APP_UIO_FAIL;
}
/**
* @test UT_HITLS_APP_rsa_T0010
* @spec -
* @title 测试UT_HITLS_APP_rsa_T0010函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_T0010(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, CRYPT_EAL_EncodeBuffKey, STUB_CRYPT_EAL_EncodeBuffKey);
char *argv[][10] = {{"rsa", "-in", PRV_PATH}};
RsaTestData testData[] = {
{3, argv[0], HITLS_APP_UIO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_HITLS_APP_Passwd(char *buf, int32_t bufMaxLen, int32_t flag, void *userdata)
{
(void)userdata;
(void)flag;
(void)memcpy_s(buf, bufMaxLen, "123456", 6);
return 6;
}
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_T0011(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_Passwd, STUB_HITLS_APP_Passwd);
char *argv[][10] = {
{"rsa", "-in", PRV_PASSWD_PATH, "-noout"},
{"rsa", "-in", PRV_DER_PATH, "-noout"},
};
RsaTestData testData[] = {
{4, argv[0], HITLS_APP_SUCCESS},
{4, argv[1], HITLS_APP_DECODE_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
int ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
if (ret != testData[i].expect) {
printf("I is %d\n", i);
}
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void UT_HITLS_APP_rsa_TC012(void)
{
char *argv[][10] = {
{"rsa", "-in", PRV_PATH},
{"rsa", "-in", PRV_PATH, "-noout"},
{"rsa", "-in", PRV_PATH, "-text"},
{"rsa", "-in", PRV_PATH, "-noout", "-text"},
{"rsa", "-in", PRV_PATH, "-out", "out4.pem"},
{"rsa", "-in", PRV_PATH, "-noout", "-out", "out5.pem"},
{"rsa", "-in", PRV_PATH, "-text", "-out", "out6.pem"},
{"rsa", "-in", PRV_PATH, "-noout", "-text", "-out", "out7.pem"},
};
RsaTestData testData[] = {
{3, argv[0], HITLS_APP_SUCCESS},
{4, argv[1], HITLS_APP_SUCCESS},
{4, argv[2], HITLS_APP_SUCCESS},
{5, argv[3], HITLS_APP_SUCCESS},
{5, argv[4], HITLS_APP_SUCCESS},
{6, argv[5], HITLS_APP_SUCCESS},
{6, argv[6], HITLS_APP_SUCCESS},
{7, argv[7], HITLS_APP_SUCCESS},
};
int ret;
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(RsaTestData)); ++i) {
ret = HITLS_RsaMain(testData[i].argc, testData[i].argv);
fflush(stdout);
freopen("/dev/tty", "w", stdout);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_app_rsa.c
|
C
|
unknown
| 13,916
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <dirent.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include "app_enc.h"
#include "app_keymgmt.h"
#include "app_errno.h"
#include "app_help.h"
#include "app_print.h"
#include "app_opt.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_replace.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 */
#ifdef HITLS_APP_SM_MODE
#define WORK_PATH "./sm_workpath"
#define PASSWORD "12345678"
#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.so"
#define HITLS_SM_PROVIDER_ATTR "provider=sm"
static AppProvider g_appProvider = {HITLS_SM_LIB_NAME, HITLS_SM_PROVIDER_PATH, HITLS_SM_PROVIDER_ATTR};
CRYPT_SelftestCtx *STUB_CRYPT_CMVP_SelftestNewCtx(CRYPT_EAL_LibCtx *libCtx, const char *attrName)
{
(void)libCtx;
(void)attrName;
return (CRYPT_SelftestCtx *)BSL_SAL_Malloc(1);
}
static int32_t AppTestInit(void)
{
int32_t ret = AppPrintErrorUioInit(stderr);
if (ret != HITLS_APP_SUCCESS) {
return ret;
}
if (APP_Create_LibCtx() == NULL) {
AppPrintErrorUioUnInit();
return HITLS_APP_INVALID_ARG;
}
ret = HITLS_APP_LoadProvider(g_appProvider.providerPath, g_appProvider.providerName);
if (ret != HITLS_APP_SUCCESS) {
HITLS_APP_FreeLibCtx();
AppPrintErrorUioUnInit();
return ret;
}
ret = CRYPT_EAL_ProviderRandInitCtx(APP_GetCurrent_LibCtx(), CRYPT_RAND_SM4_CTR_DF, g_appProvider.providerAttr,
NULL, 0, NULL);
if (ret != HITLS_APP_SUCCESS) {
HITLS_APP_FreeLibCtx();
AppPrintErrorUioUnInit();
return ret;
}
return HITLS_APP_SUCCESS;
}
static void AppTestUninit(void)
{
CRYPT_EAL_RandDeinitEx(APP_GetCurrent_LibCtx());
HITLS_APP_FreeLibCtx();
AppPrintErrorUioUnInit();
}
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_BSL_UI_ReadPwdUtil_WrongPassword(BSL_UI_ReadPwdParam *param, char *buff, uint32_t *buffLen,
const BSL_UI_CheckDataCallBack checkDataCallBack, void *callBackData)
{
(void)param;
(void)checkDataCallBack;
(void)callBackData;
char wrongPassword[] = "wrong_password_123";
(void)strcpy_s(buff, *buffLen, wrongPassword);
*buffLen = (uint32_t)strlen(buff) + 1;
return BSL_SUCCESS;
}
static uid_t STUB_getuid(void)
{
return 0;
}
static int32_t STUB_HITLS_APP_SM_IntegrityCheck(void)
{
return HITLS_APP_SUCCESS;
}
#endif
/**
* @test UT_HITLS_APP_SM_TC001
* @spec -
* @title Test password retrieval of the command-line SM module
*/
/* BEGIN_CASE */
void UT_HITLS_APP_SM_TC001(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
char *password = NULL;
STUB_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
system("rm -rf " WORK_PATH);
system("mkdir -p " WORK_PATH);
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
int32_t status = 0;
ASSERT_EQ(HITLS_APP_SM_Init(&g_appProvider, WORK_PATH, &password, &status), HITLS_APP_SUCCESS);
ASSERT_EQ(strcmp(password, PASSWORD), 0);
BSL_SAL_FREE(password);
ASSERT_EQ(HITLS_APP_SM_Init(&g_appProvider, WORK_PATH, &password, &status), HITLS_APP_SUCCESS);
ASSERT_EQ(strcmp(password, PASSWORD), 0);
EXIT:
BSL_SAL_FREE(password);
AppTestUninit();
STUB_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
system("rm -rf " WORK_PATH);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_SM_TC002
* @spec -
* @title Test root user check of the command-line SM module
*/
/* BEGIN_CASE */
void UT_HITLS_APP_SM_TC002(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, getuid, STUB_getuid);
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
char *password = NULL;
int32_t status = 0;
ASSERT_EQ(HITLS_APP_SM_Init(&g_appProvider, WORK_PATH, &password, &status), HITLS_APP_ROOT_CHECK_FAIL);
ASSERT_EQ(password, NULL);
EXIT:
AppTestUninit();
STUB_Reset(&stubInfo);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_SM_TC003
* @spec -
* @title Test file tamper detection of the command-line SM module; simulate file content corruption
*/
/* BEGIN_CASE */
void UT_HITLS_APP_SM_TC003(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
char *password = NULL;
char userFilePath[1024] = {0};
int fd = -1;
STUB_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
system("rm -rf " WORK_PATH);
system("mkdir -p " WORK_PATH);
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
// Normal initialization
int32_t status = 0;
ASSERT_EQ(HITLS_APP_SM_Init(&g_appProvider, WORK_PATH, &password, &status), HITLS_APP_SUCCESS);
ASSERT_EQ(strcmp(password, PASSWORD), 0);
BSL_SAL_FREE(password);
// Build user file path
snprintf(userFilePath, sizeof(userFilePath), "%s/openhitls_user", WORK_PATH);
// Tamper user file content - modify salt; this passes version check but fails integrity check
fd = open(userFilePath, O_RDWR);
ASSERT_TRUE(fd >= 0);
// Calculate the offset of the salt in the file
// UserParam structure: version(4) + deriveMacId(4) + integrityMacId(4) + iter(4) + salt[64] + saltLen(4) + dKey[32] + dKeyLen(4)
// Salt offset = 4 + 4 + 4 + 4 = 16 bytes
off_t saltOffset = 16;
// Seek to the salt position
ASSERT_EQ(lseek(fd, saltOffset, SEEK_SET), saltOffset);
// Corrupt the salt by filling with 0xFF
uint8_t corruptedSalt[64];
memset(corruptedSalt, 0xFF, sizeof(corruptedSalt));
ASSERT_EQ(write(fd, corruptedSalt, sizeof(corruptedSalt)), sizeof(corruptedSalt));
close(fd);
fd = -1;
// Initialization after tampering should fail (version check passes but integrity check fails)
ASSERT_EQ(HITLS_APP_SM_Init(&g_appProvider, WORK_PATH, &password, &status), HITLS_APP_INTEGRITY_VERIFY_FAIL);
ASSERT_EQ(password, NULL);
EXIT:
if (fd >= 0) {
close(fd);
}
BSL_SAL_FREE(password);
AppTestUninit();
STUB_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
system("rm -rf " WORK_PATH);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_SM_TC004
* @spec -
* @title Test file permission tamper detection of the command-line SM module
*/
/* BEGIN_CASE */
void UT_HITLS_APP_SM_TC004(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
char *password = NULL;
char userFilePath[1024] = {0};
STUB_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
system("rm -rf " WORK_PATH);
system("mkdir -p " WORK_PATH);
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
// Normal initialization
int32_t status = 0;
ASSERT_EQ(HITLS_APP_SM_Init(&g_appProvider, WORK_PATH, &password, &status), HITLS_APP_SUCCESS);
ASSERT_EQ(strcmp(password, PASSWORD), 0);
BSL_SAL_FREE(password);
// Build user file path
snprintf(userFilePath, sizeof(userFilePath), "%s/openhitls_user", WORK_PATH);
// Tamper file permissions - remove read permission
ASSERT_EQ(chmod(userFilePath, 0), 0);
// With permissions tampered, file access should fail
ASSERT_EQ(HITLS_APP_SM_Init(&g_appProvider, WORK_PATH, &password, &status), HITLS_APP_UIO_FAIL);
ASSERT_EQ(password, NULL);
// Restore file permissions
ASSERT_EQ(chmod(userFilePath, 0644), 0);
EXIT:
BSL_SAL_FREE(password);
AppTestUninit();
STUB_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
system("rm -rf " WORK_PATH);
#endif
}
/* END_CASE */
/**
* @test UT_HITLS_APP_SM_TC005
* @spec -
* @title Test wrong user password; second login fails in the command-line SM module
*/
/* BEGIN_CASE */
void UT_HITLS_APP_SM_TC005(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
char *password = NULL;
STUB_Init();
FuncStubInfo stubInfo[2] = {0};
// First login: use correct password
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
system("rm -rf " WORK_PATH);
system("mkdir -p " WORK_PATH);
ASSERT_EQ(AppTestInit(), HITLS_APP_SUCCESS);
// First login should succeed
int32_t status = 0;
ASSERT_EQ(HITLS_APP_SM_Init(&g_appProvider, WORK_PATH, &password, &status), HITLS_APP_SUCCESS);
ASSERT_EQ(strcmp(password, PASSWORD), 0);
BSL_SAL_FREE(password);
// Second login: use wrong password
STUB_Reset(&stubInfo[0]);
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil_WrongPassword);
// Second login with wrong password should fail
ASSERT_EQ(HITLS_APP_SM_Init(&g_appProvider, WORK_PATH, &password, &status), HITLS_APP_PASSWD_FAIL);
ASSERT_EQ(password, NULL);
EXIT:
BSL_SAL_FREE(password);
AppTestUninit();
STUB_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
system("rm -rf " WORK_PATH);
#endif
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_app_sm.c
|
C
|
unknown
| 10,901
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "app_verify.h"
#include <linux/limits.h>
#include <stdbool.h>
#include "string.h"
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_errno.h"
#include "app_function.h"
#include "bsl_list.h"
#include "app_errno.h"
#include "app_opt.h"
#include "app_help.h"
#include "app_print.h"
#include "app_utils.h"
#include "stub_replace.h"
/* END_HEADER */
#define MAX_CRLFILE_SIZE (256 * 1024)
#define CAFILE_PATH "../testdata/certificate/VerifyCAfile/root_trust.ca"
#define EMPTY_CAFILE_PATH "../testdata/certificate/VerifyCAfile/emptyRoot.ca"
#define ROOT256K_CAFILE_PATH "../testdata/certificate/VerifyCAfile/root256K.ca"
#define ROOT255K_CAFILE_PATH "../testdata/certificate/VerifyCAfile/root255k.ca"
#define MISTAKE_CA_FILEPATH "../testdata/certificate/VerifyCAfile/mistakeCA.ca"
#define MID_CA_FILEPATH "../testdata/certificate/VerifyCAfile/middle_ca.pem"
#define CERT_PATH "../testdata/certificate/VerifyCAfile/future.pem"
#define EMPTY_CERT_PATH "../testdata/certificate/VerifyCAfile/emptyCert.ca"
#define CERT_256K_FILEPATH "../testdata/certificate/VerifyCAfile/256kfuture.pem"
#define CERT_257K_FILEPATH "../testdata/certificate/VerifyCAfile/257kfuture.pem"
#define MISTAKE_CERT_PATH "../testdata/certificate/VerifyCAfile/mistakeCert.pem"
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_verify.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c */
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
/**
* @test UT_HITLS_APP_Verify_TC001
* @spec -
* @title Test the UT_HITLS_APP_Verify_TC001 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_verify_TC001(void)
{
char *argv[][100] = {
{"verify", "-CAfile", CAFILE_PATH, CERT_PATH},
};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_VerifyMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_verify_TC002
* @spec -
* @title Test the UT_HITLS_APP_verify_TC002 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_verify_TC002(void)
{
char *argv[][2] = {
{"verify", "-help"},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_HELP},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_VerifyMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
int32_t STUB_HITLS_APP_OptBegin(int32_t argc, char **argv, const HITLS_CmdOption *opts)
{
(void)argc;
(void)argv;
(void)opts;
return HITLS_APP_OPT_UNKOWN;
}
/**
* @test UT_HITLS_APP_verify_TC003
* @spec -
* @title Test the UT_HITLS_APP_verify_TC003 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_verify_TC003(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptBegin, STUB_HITLS_APP_OptBegin);
char *argv[][100] = {
{"verify", "-CAfile", CAFILE_PATH, CERT_PATH},
};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_OPT_UNKOWN},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_VerifyMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_BSL_UIO_Ctrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *parg)
{
(void)uio;
(void)cmd;
(void)larg;
(void)parg;
return BSL_UIO_FAIL;
}
char *STUB_HITLS_APP_OptGetValueStr(void)
{
return NULL;
}
/**
* @test UT_HITLS_APP_verify_TC005
* @spec -
* @title Test the UT_HITLS_APP_verify_TC005 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_verify_TC005(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptGetValueStr, STUB_HITLS_APP_OptGetValueStr);
char *argv[][100] = {{"verify", "-CAfile", CAFILE_PATH, CERT_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_OPT_VALUE_INVALID},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_VerifyMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_HITLS_X509_CertMulParseFile(int32_t format, const char *path, HITLS_X509_List **certlist)
{
(void)format;
(void)path;
(void)certlist;
return HITLS_APP_DECODE_FAIL;
}
/* *
* @test UT_HITLS_APP_verify_TC006
* @spec -
* @title Test the UT_HITLS_APP_verify_TC006 function.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_verify_TC006(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_X509_CertParseBundleFile, STUB_HITLS_X509_CertMulParseFile);
char *argv[][100] = {{"verify", "-CAfile", CAFILE_PATH, CERT_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_X509_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_VerifyMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_HITLS_X509_StoreCtxCtrl(HITLS_X509_StoreCtx *storeCtx, int32_t cmd, void *val, uint32_t valLen)
{
if (cmd == HITLS_X509_STORECTX_DEEP_COPY_SET_CA) {
return HITLS_APP_DECODE_FAIL;
}
(void)storeCtx;
(void)val;
(void)valLen;
return HITLS_APP_SUCCESS;
}
/**
* @test UT_HITLS_APP_verify_TC008
* @spec -
* @titleTest UT_HITLS_APP_verify_TC008 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_verify_TC008(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_X509_StoreCtxCtrl, STUB_HITLS_X509_StoreCtxCtrl);
char *argv[][100] = {{"verify", "-CAfile", CAFILE_PATH, CERT_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_X509_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_VerifyMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
HITLS_X509_StoreCtx *STUB_HITLS_X509_StoreCtxNew(void)
{
return NULL;
}
/**
* @test UT_HITLS_APP_verify_TC009
* @spec -
* @titleTest UT_HITLS_APP_verify_TC009 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_verify_TC009(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_X509_StoreCtxNew, STUB_HITLS_X509_StoreCtxNew);
char *argv[][100] = {{"verify", "-CAfile", CAFILE_PATH, CERT_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_X509_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_VerifyMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_HITLS_X509_CertVerify(HITLS_X509_StoreCtx *storeCtx, HITLS_X509_List *chain)
{
(void)storeCtx;
(void)chain;
return HITLS_APP_X509_FAIL;
}
/**
* @test UT_HITLS_APP_verify_TC0010
* @spec -
* @titleTest UT_HITLS_APP_verify_TC0012 function
*/
/* BEGIN_CASE */
void UT_HITLS_APP_verify_TC0010(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_X509_CertVerify, STUB_HITLS_X509_CertVerify);
char *argv[][50] = {{"verify", "-CAfile", CAFILE_PATH, CERT_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_X509_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_VerifyMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_app_verify.c
|
C
|
unknown
| 9,411
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include "securec.h"
#include "stub_replace.h"
#include "test.h"
#include "bsl_uio.h"
#include "bsl_types.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "sal_file.h"
#include "uio_abstraction.h"
#include "crypt_errno.h"
#include "app_opt.h"
#include "app_print.h"
#include "app_errno.h"
#include "app_function.h"
#include "app_x509.h"
/* END_HEADER */
#define X509_MAX_ARGC 22
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
static void PreProcArgs(char *args, int *argc, char **argv)
{
uint32_t len = strlen(args);
argv[(*argc)++] = args;
for (uint32_t i = 0; i < len; i++) {
if (args[i] == ' ') {
args[i] = '\0';
argv[(*argc)++] = args + i + 1;
}
}
}
static int32_t CompareOutByFile(char *file1, char *file2)
{
int ret = 1;
BSL_Buffer buff1 = {0};
BSL_Buffer buff2 = {0};
ASSERT_EQ(BSL_SAL_ReadFile(file1, &buff1.data, &buff1.dataLen), 0);
ASSERT_EQ(BSL_SAL_ReadFile(file2, &buff2.data, &buff2.dataLen), 0);
ASSERT_EQ(buff1.dataLen, buff2.dataLen);
ASSERT_COMPARE("Compare out data", buff1.data, buff1.dataLen, buff2.data, buff2.dataLen);
ret = 0;
EXIT:
BSL_SAL_Free(buff1.data);
BSL_SAL_Free(buff2.data);
return ret;
}
static int32_t CompareOutByData(char *file1, Hex *data)
{
int ret = 1;
BSL_Buffer buff = {0};
ASSERT_EQ(BSL_SAL_ReadFile(file1, &buff.data, &buff.dataLen), 0);
ASSERT_EQ(buff.dataLen, data->len);
ASSERT_COMPARE("Compare out data", buff.data, buff.dataLen, data->x, data->len);
ret = 0;
EXIT:
BSL_SAL_Free(buff.data);
return ret;
}
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_x509.c
* ${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c */
/**
* @test UT_HITLS_APP_X509_InvalidOpt_TC001
* @title Test the invalid parameters of the x509 command.
* @brief Enter parameters and return the error code expectRet.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_X509_InvalidOpt_TC001(char *opts, int expectRet)
{
int argc = 0;
char *argv[X509_MAX_ARGC] = {0};
char *tmp = strdup(opts);
ASSERT_NE(tmp, NULL);
PreProcArgs(tmp, &argc, argv);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_X509Main(argc, argv), expectRet);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(tmp);
}
/* END_CASE */
/**
* @test UT_HITLS_APP_X509_NormalOpt_TC001
* @title Test the normal parameters of the x509 command.
* @brief Enter parameters and return HITLS_APP_SUCCESS.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_X509_NormalOpt_TC001(char *opts)
{
int argc = 0;
char *argv[X509_MAX_ARGC] = {0};
char *tmp = strdup(opts);
ASSERT_NE(tmp, NULL);
PreProcArgs(tmp, &argc, argv);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_X509Main(argc, argv), HITLS_APP_SUCCESS);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(tmp);
}
/* END_CASE */
/**
* @test UT_HITLS_APP_X509_FormatConvert_TC001
* @title Test certificate format conversion.
* @brief The input format is 'inform', the output format is 'outform', and the output result is the same as that of
* out.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_X509_FormatConvert_TC001(char *opts, char *outFile, char *expectFile)
{
int argc = 0;
char *argv[X509_MAX_ARGC] = {0};
char *tmp = strdup(opts);
ASSERT_NE(tmp, NULL);
PreProcArgs(tmp, &argc, argv);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_X509Main(argc, argv), 0);
ASSERT_EQ(CompareOutByFile(outFile, expectFile), HITLS_APP_SUCCESS);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(tmp);
remove(outFile);
}
/* END_CASE */
/**
* @test UT_HITLS_APP_X509_Print_TC001
* @title Test certificate format conversion.
* @brief The input format is 'inform', the output format is 'outform', and the output result is the same as that of
* out.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_X509_Print_TC001(char *opts, char *outFile, Hex *expectOut)
{
int argc = 0;
char *argv[X509_MAX_ARGC] = {0};
char *tmp = strdup(opts);
ASSERT_NE(tmp, NULL);
PreProcArgs(tmp, &argc, argv);
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_X509Main(argc, argv), 0);
ASSERT_EQ(CompareOutByData(outFile, expectOut), HITLS_APP_SUCCESS);
EXIT:
AppPrintErrorUioUnInit();
BSL_SAL_Free(tmp);
remove(outFile);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_app_x509.c
|
C
|
unknown
| 5,122
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "string.h"
#include "app_opt.h"
#include "app_function.h"
#include "app_errno.h"
#include "app_help.h"
#include "app_dgst.h"
#include "app_print.h"
#include "crypt_eal_md.h"
#include "bsl_sal.h"
#include "securec.h"
#include "bsl_errno.h"
#include "crypt_errno.h"
#include "stub_replace.h"
/* END_HEADER */
#define PRV_PATH "../testdata/certificate/rsa_key/prvKey.pem"
#define OUT_FILE_PATH "../testdata/certificate/rsa_key/out.pem"
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_dgst.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c */
/**
* @test UT_HITLS_APP_dgst_TC001
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC001(void)
{
char *argv[][10] = {
{"dgst", "-md", "md5", PRV_PATH},
{"dgst", PRV_PATH},
{"dgst", "-md", "md5", "-out", OUT_FILE_PATH, PRV_PATH},
};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_SUCCESS},
{2, argv[1], HITLS_APP_SUCCESS},
{6, argv[2], HITLS_APP_SUCCESS}
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_dgst_TC002
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC002(void)
{
char *argv[][10] = {{"dgst", "-md"},
{"dgst", "-md", "md10", PRV_PATH},
{"dgst", "-md", "md5", "md5", PRV_PATH},
{"dgst", "-md", "md5", "-out"},
{"dgst", "-md", "md5", "/noexist/noexist.txt"},
{"dgst", "-md", "md5", "-out", "/noexist/filepath/outfile.txt", PRV_PATH},
{"dgst", "-md", "md5", "-out", "-out", "/noexist/filepath/outfile.txt", PRV_PATH}
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_OPT_UNKOWN},
{4, argv[1], HITLS_APP_OPT_VALUE_INVALID},
{5, argv[2], HITLS_APP_UIO_FAIL},
{4, argv[3], HITLS_APP_OPT_UNKOWN},
{4, argv[4], HITLS_APP_UIO_FAIL},
{6, argv[5], HITLS_APP_UIO_FAIL},
{7, argv[6], HITLS_APP_UIO_FAIL}
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_dgst_TC003
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC003函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC003(void)
{
char *argv[][2] = {
{"dgst", "-help"},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_HELP},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
int32_t STUB_HITLS_APP_OptBegin(int32_t argc, char **argv, const HITLS_CmdOption *opts)
{
(void)argc;
(void)argv;
(void)opts;
return HITLS_APP_OPT_UNKOWN;
}
/**
* @test UT_HITLS_APP_dgst_TC004
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC004函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC004(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptBegin, STUB_HITLS_APP_OptBegin);
char *argv[][50] = {{"dgst", "-md", "md5", "-out", OUT_FILE_PATH, PRV_PATH}};
OptTestData testData[] = {
{6, argv[0], HITLS_APP_OPT_UNKOWN},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_BSL_UIO_Ctrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *parg)
{
(void)uio;
(void)cmd;
(void)larg;
(void)parg;
return BSL_UIO_FAIL;
}
/**
* @test UT_HITLS_APP_dgst_TC005
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC005函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC005(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UIO_Ctrl, STUB_BSL_UIO_Ctrl);
char *argv[][50] = {{"dgst", "-md", "md5", "-out", OUT_FILE_PATH, PRV_PATH}};
OptTestData testData[] = {
{6, argv[0], HITLS_APP_UIO_FAIL},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
char *STUB_HITLS_APP_OptGetValueStr(void)
{
return NULL;
}
/**
* @test UT_HITLS_APP_dgst_TC006
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC006函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC006(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptGetValueStr, STUB_HITLS_APP_OptGetValueStr);
char *argv[][50] = {{"dgst", "-out", OUT_FILE_PATH, PRV_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_OPT_VALUE_INVALID},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_HITLS_APP_OptWriteUio(BSL_UIO *uio, uint8_t *buf, uint32_t outLen, int32_t format)
{
(void)uio;
(void)buf;
(void)outLen;
(void)format;
return HITLS_APP_UIO_FAIL;
}
/**
* @test UT_HITLS_APP_dgst_TC007
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC007函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC007(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptWriteUio, STUB_HITLS_APP_OptWriteUio);
char *argv[][50] = {{"dgst", "-out", OUT_FILE_PATH, PRV_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_UIO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
bool IsFileExist(const char *fileName)
{
FILE *f = fopen(fileName, "r");
if (f == NULL) {
return false;
}
fclose(f);
return true;
}
/**
* @test UT_HITLS_APP_dgst_TC008
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC008函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC008(void)
{
char *filename = "_APP_dgst_T008.txt";
char *argv[][10] = {{"dgst", "-out", filename, PRV_PATH}};
OptTestData testData[] = {{4, argv[0], HITLS_APP_SUCCESS}};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
ASSERT_TRUE(IsFileExist(filename));
remove(filename);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
uint32_t STUB_CRYPT_EAL_MdGetDigestSize(CRYPT_MD_AlgId id)
{
(void)id;
return 0;
}
/**
* @test UT_HITLS_APP_dgst_TC009
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC009函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC009(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, CRYPT_EAL_MdGetDigestSize, STUB_CRYPT_EAL_MdGetDigestSize);
char *argv[][50] = {{"dgst", "-out", OUT_FILE_PATH, PRV_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_CRYPTO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
CRYPT_EAL_MdCTX *STUB_CRYPT_EAL_ProviderMdNewCtx(CRYPT_EAL_LibCtx *libCtx, int32_t algId, const char *attrName)
{
(void)algId;
(void)attrName;
(void)libCtx;
return NULL;
}
/**
* @test UT_HITLS_APP_dgst_TC0010
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC0010函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC0010(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, CRYPT_EAL_ProviderMdNewCtx, STUB_CRYPT_EAL_ProviderMdNewCtx);
char *argv[][50] = {{"dgst", "-out", OUT_FILE_PATH, PRV_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_CRYPTO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_CRYPT_EAL_MdInit(CRYPT_EAL_MdCTX *ctx){
(void)ctx;
return HITLS_APP_CRYPTO_FAIL;
}
/**
* @test UT_HITLS_APP_dgst_TC0011
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC0011函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC0011(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, CRYPT_EAL_MdInit, STUB_CRYPT_EAL_MdInit);
char *argv[][50] = {{"dgst", "-out", OUT_FILE_PATH, PRV_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_CRYPTO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_CRYPT_EAL_MdUpdate(CRYPT_EAL_MdCTX *ctx, const uint8_t *data, uint32_t len){
(void)ctx;
(void)data;
(void)len;
return CRYPT_EAL_ERR_STATE;
}
/**
* @test UT_HITLS_APP_dgst_TC0012
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC0012函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC0012(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, CRYPT_EAL_MdUpdate, STUB_CRYPT_EAL_MdUpdate);
char *argv[][50] = {{"dgst", "-out", OUT_FILE_PATH, PRV_PATH}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_UIO_FAIL},
};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_CRYPT_EAL_MdFinal(CRYPT_EAL_MdCTX *ctx, uint8_t *out, uint32_t *len){
(void)ctx;
(void)out;
(void)len;
return CRYPT_EAL_ERR_STATE;
}
/**
* @test UT_HITLS_APP_dgst_TC0013
* @spec -
* @title 测试UT_HITLS_APP_dgst_TC0013函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_dgst_TC0013(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, CRYPT_EAL_MdFinal, STUB_CRYPT_EAL_MdFinal);
char *argv[][50] = {{"dgst", "-out", OUT_FILE_PATH, PRV_PATH}};
OptTestData testData[] = {{4, argv[0], HITLS_APP_CRYPTO_FAIL}};
ASSERT_EQ(AppPrintErrorUioInit(stderr), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_DgstMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_dgst.c
|
C
|
unknown
| 13,165
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include "app_enc.h"
#include "app_errno.h"
#include "app_help.h"
#include "app_print.h"
#include "app_opt.h"
#include "app_provider.h"
#include "bsl_uio.h"
#include "crypt_eal_cipher.h"
#include "crypt_eal_kdf.h"
#include "eal_cipher_local.h"
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_enc.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c ${HITLS_ROOT_PATH}/apps/src/app_utils.c */
/* END_HEADER */
typedef struct {
uint16_t version;
} ResumeTestInfo;
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
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();
}
/**
* @test UT_HITLS_APP_ENC_TC001
* @spec -
* @title 测试命令行二级命令enc正常场景
*/
/* BEGIN_CASE */
void UT_HITLS_APP_ENC_TC001(void)
{
char *argv[][13] = {
{"enc", "-enc", "-cipher", "aes128_cbc", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-enc", "-cipher", "aes128_cbc", "-in", "../testdata/apps/enc/test_encfile", "-pass", "file:../testdata/apps/pass/size_1024_pass", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-enc", "-cipher", "aes128_cbc", "-md", "sha1", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-enc", "-cipher", "aes128_cbc", "-in", "../testdata/apps/enc/test_encfile", "-pass", "file:../testdata/apps/enc/enter_pass_file", "-out", "../testdata/apps/enc/res_encfile"}
};
OptTestData testData[] = {
{10, argv[0], HITLS_APP_SUCCESS},
{10, argv[1], HITLS_APP_SUCCESS},
{12, argv[2], HITLS_APP_SUCCESS},
{10, argv[3], HITLS_APP_SUCCESS}
};
ASSERT_EQ(AppInit(), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_EncMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppUninit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_ENC_TC002
* @spec -
* @title 测试命令行二级命令enc不同对称加解密算法的加解密流程
*/
/* BEGIN_CASE */
void UT_HITLS_APP_ENC_TC002(void)
{
char *argv[][11] = {
{"enc", "-enc", "-cipher", "aes128_cbc", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:12345678", "-out", "res_tmpfile"},
{"enc", "-dec", "-cipher", "aes128_cbc", "-in", "res_tmpfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_decfile"},
{"enc", "-enc", "-cipher", "aes128_ctr", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-dec", "-cipher", "aes128_ctr", "-in", "../testdata/apps/enc/res_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_decfile"},
{"enc", "-enc", "-cipher", "aes128_ecb", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-dec", "-cipher", "aes128_ecb", "-in", "../testdata/apps/enc/res_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_decfile"},
{"enc", "-enc", "-cipher", "aes128_xts", "-in", "../testdata/apps/enc/test_xts_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-dec", "-cipher", "aes128_xts", "-in", "../testdata/apps/enc/res_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_decfile"},
{"enc", "-enc", "-cipher", "aes128_gcm", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-dec", "-cipher", "aes128_gcm", "-in", "../testdata/apps/enc/res_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_decfile"},
{"enc", "-enc", "-cipher", "chacha20_poly1305", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-dec", "-cipher", "chacha20_poly1305", "-in", "../testdata/apps/enc/res_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_decfile"},
{"enc", "-enc", "-cipher", "sm4_cfb", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-dec", "-cipher", "sm4_cfb", "-in", "../testdata/apps/enc/res_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_decfile"}
};
OptTestData testData[] = {
{10, argv[0], HITLS_APP_SUCCESS},
{10, argv[1], HITLS_APP_SUCCESS},
{10, argv[2], HITLS_APP_SUCCESS},
{10, argv[3], HITLS_APP_SUCCESS},
{10, argv[4], HITLS_APP_SUCCESS},
{10, argv[5], HITLS_APP_SUCCESS},
{10, argv[6], HITLS_APP_SUCCESS},
{10, argv[7], HITLS_APP_SUCCESS},
{10, argv[8], HITLS_APP_SUCCESS},
{10, argv[9], HITLS_APP_SUCCESS},
{10, argv[10], HITLS_APP_SUCCESS},
{10, argv[11], HITLS_APP_SUCCESS},
{10, argv[12], HITLS_APP_SUCCESS},
{10, argv[13], HITLS_APP_SUCCESS}
};
ASSERT_EQ(AppInit(), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_EncMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppUninit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_ENC_TC003
* @spec -
* @title 测试命令行二级命令enc异常场景
*/
/* BEGIN_CASE */
void UT_HITLS_APP_ENC_TC003(void)
{
char *argv[][13] = {
{"enc", "-enc", "-cipher", "aes128_abc", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-enc", "-cipher", "aes128_cbc", "-in", "../testdata/apps/enc/test_encfile", "-pass", "file:../testdata/apps/pass/empty_pass", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-enc", "-cipher", "aes128_cbc", "-md", "md_abc", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:12345678", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-enc", "-cipher", "aes128_cbc", "-in", "../testdata/apps/enc/test_encfile", "-pass", "pass:", "-out", "../testdata/apps/enc/res_encfile"},
{"enc", "-enc", "-cipher", "aes128_cbc", "-in", "../testdata/apps/enc/test_encfile", "-pass", "file:../testdata/apps/pass/size_1025_pass", "-out", "../testdata/apps/enc/res_encfile"}
};
OptTestData testData[] = {
{10, argv[0], HITLS_APP_OPT_VALUE_INVALID},
{10, argv[1], HITLS_APP_PASSWD_FAIL},
{12, argv[2], HITLS_APP_OPT_VALUE_INVALID},
{10, argv[3], HITLS_APP_PASSWD_FAIL},
{10, argv[4], HITLS_APP_PASSWD_FAIL}
};
ASSERT_EQ(AppInit(), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_EncMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppUninit();
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_enc.c
|
C
|
unknown
| 8,116
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include "app_opt.h"
#include "securec.h"
#include "app_errno.h"
#include "bsl_uio.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "app_print.h"
#include "stub_replace.h"
#include "bsl_base64.h"
#ifdef HITLS_BSL_SAL_DOPRA_V3
#include <unistd.h>
#include "vfs_core.h"
#endif
/* END_HEADER */
typedef struct {
int argc;
char **argv;
HITLS_CmdOption *opts;
int expect;
} OptTestData;
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c */
/**
* @test UT_HITLS_APP_OptBegin_TC001
* @spec -
* @title 测试HITLS_APP_OptBegine异常
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptBegin_TC001(void)
{
HITLS_CmdOption opts[] = {{"test1", 1, HITLS_APP_OPT_VALUETYPE_NO_VALUE, "test1"}, {NULL}};
OptTestData testData[] = {
{0, NULL, NULL, HITLS_APP_OPT_UNKOWN}, // case1:invalid arg argc、argv、opt
{0, NULL, opts, HITLS_APP_OPT_UNKOWN} // case2:invalid argc and argv
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
ASSERT_EQ(HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts), testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_OptBegin_TC002
* @spec -
* @title 测试HITLS_APP_OptBegine异常
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptBegin_TC002(void)
{
HITLS_CmdOption opts[] = {{"-test1", 1, HITLS_APP_OPT_VALUETYPE_NO_VALUE, "test1"}, {NULL}};
char *argv[] = {"path", "help"};
OptTestData testData[] = {
{2, argv, opts, HITLS_APP_OPT_NAME_INVALID}, // case1： invald optname
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
ASSERT_EQ(HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts), testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_OptBegin_TC003
* @spec -
* @title 测试HITLS_APP_OptBegine异常
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptBegin_TC003(void)
{
HITLS_CmdOption opts[][4] = {
{{"test1", 1, HITLS_APP_OPT_VALUETYPE_NONE, "test1"}, {NULL}},
{{"test2", 1, HITLS_APP_OPT_VALUETYPE_NONE - 1, "test1"}, {NULL}},
{{"test3", 1, HITLS_APP_OPT_VALUETYPE_MAX, "test1"}, {NULL}},
{{"test4", 1, HITLS_APP_OPT_VALUETYPE_MAX + 1, "test1"}, {NULL}}
};
char *argv[] = {"path", "help"};
OptTestData testData[] = {
{2, argv, opts[0], HITLS_APP_OPT_VALUETYPE_INVALID}, // case1： invalid valuetype = 0
{2, argv, opts[1], HITLS_APP_OPT_VALUETYPE_INVALID}, // case2： invalid valuetype < 0
{2, argv, opts[2], HITLS_APP_OPT_VALUETYPE_INVALID}, // case3： invalid valuetype = max
{2, argv, opts[3], HITLS_APP_OPT_VALUETYPE_INVALID}, // case4： invalid valuetype > max
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
ASSERT_EQ(HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts), testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_OptBegin_TC004
* @spec -
* @title 测试HITLS_APP_OptBegine异常
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptBegin_TC004(void)
{
HITLS_CmdOption opts[][4] = {
{
{"test1", 1, HITLS_APP_OPT_VALUETYPE_NONE + 1, "test1"},
{"test1", 1, HITLS_APP_OPT_VALUETYPE_NONE + 1, "test1"},
{NULL}
},
{
{"test1", 1, HITLS_APP_OPT_VALUETYPE_NONE + 1, "test1"},
{"test2", 1, HITLS_APP_OPT_VALUETYPE_NONE + 1, "test1"},
{"test1", 1, HITLS_APP_OPT_VALUETYPE_NONE + 1, "test1"},
{NULL}
},
{
{"", 1, HITLS_APP_OPT_VALUETYPE_MAX - 1, "test1"},
{"", 1, HITLS_APP_OPT_VALUETYPE_MAX - 1, "test1"},
{NULL}
},
{
{"", 1, HITLS_APP_OPT_VALUETYPE_NONE + 1, "test1"},
{"test2", 1, HITLS_APP_OPT_VALUETYPE_NONE + 1, "test1"},
{"", 1, HITLS_APP_OPT_VALUETYPE_NONE + 1, "test1"},
{NULL}
}
};
char *argv[] = {"path", "help"};
OptTestData testData[] = {
{2, argv, opts[0], HITLS_APP_OPT_NAME_INVALID}, // case1： optname(test1) dup (neighbour)
{2, argv, opts[1], HITLS_APP_OPT_NAME_INVALID}, // case2： optname(test1) dup (separate)
{2, argv, opts[2], HITLS_APP_OPT_NAME_INVALID}, // case3： optname("") dup (neighbour)
{2, argv, opts[3], HITLS_APP_OPT_NAME_INVALID}, // case4： optname("") dup (separate)
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
ASSERT_EQ(HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts), testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_OptBegin_TC005
* @spec -
* @title 测试HITLS_APP_OptBegine异常
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptBegin_TC005(void)
{
HITLS_CmdOption opts[] = {{"", 1, HITLS_APP_OPT_VALUETYPE_FMT_PEMDER, "test1"}, {NULL}};
char *argv[] = {"path", "help"};
OptTestData testData[] = {
{2, argv, opts, HITLS_APP_OPT_NAME_INVALID} // case1： optname is "",but opttype is not no value
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
ASSERT_EQ(HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts), testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_OptBegin_TC006
* @spec -
* @title 测试HITLS_APP_OptBegine正常
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptBegin_TC006(void)
{
HITLS_CmdOption opts[2][2] = {
{{"", 1, HITLS_APP_OPT_VALUETYPE_NO_VALUE, "test1"},{NULL}},
{{"test", 1, HITLS_APP_OPT_VALUETYPE_NO_VALUE, "test1"},{NULL}}
};
char *argv[] = {"test", "help"};
OptTestData testData[] = {
{2, argv, opts[0], HITLS_APP_SUCCESS}, // case1： HITLS_Optbegin success
{2, argv, opts[1], HITLS_APP_SUCCESS} // case2： HITLS_Optbegin success
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
ASSERT_EQ(HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts), testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test HITLS_APP_OptNext_TC001
* @spec -
* @title 测试HITLS_APP_OptNext异常
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptNext_TC001(void)
{
HITLS_CmdOption opts[] = {
{"", 1, HITLS_APP_OPT_VALUETYPE_STRING, "test1"},
{"test", 1, HITLS_APP_OPT_VALUETYPE_NO_VALUE, "test1"},
{NULL}
};
char *argv[3][2] = {{"help", "-"}, {"help", "--"}, {"help", NULL}};
OptTestData testData[] = {
{1, argv[0], opts, HITLS_APP_OPT_ERR}, // case1： input arg only contain "-"
{2, argv[1], opts, HITLS_APP_OPT_ERR}, // case2： input arg only contain "--"
{2, argv[2], opts, HITLS_APP_OPT_EOF}
}; // case3： input arg is NULL
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
(void)HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts);
ASSERT_EQ(HITLS_APP_OptNext(), testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test HITLS_OptNext_TC002
* @spec -
* @title 测试HITLS_OptNext异常
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptNext_TC002(void)
{
char testcmd[] = "-test=21";
HITLS_CmdOption opts[] = {
{"11", 1, HITLS_APP_OPT_VALUETYPE_STRING, "test1"},
{"test", 1, HITLS_APP_OPT_VALUETYPE_NO_VALUE, "test1"},
{"test2", 1, HITLS_APP_OPT_VALUETYPE_STRING, "test2"},
{NULL},
{NULL}
};
char *argv[][3] = {
{"help", "-test"}, // case1:no opt value
{"help", testcmd }, // case2: -key=value not support
{"help", "-test2", NULL}, // case3: opt should have value,but input isn't opt's value
{"help", "-xxx"} // case4: invalid opt
};
OptTestData testData[] = {
{2, argv[0], opts, 1},
{2, argv[1], opts, HITLS_APP_OPT_ERR},
{3, argv[2], opts, HITLS_APP_OPT_ERR},
{2, argv[3], opts, HITLS_APP_OPT_ERR},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
(void)HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts);
ASSERT_EQ(HITLS_APP_OptNext(), testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
HITLS_CmdOption g_tc003Opts[] = {
{"novalue", 1, HITLS_APP_OPT_VALUETYPE_NO_VALUE, "test"},
{"infile", 1, HITLS_APP_OPT_VALUETYPE_IN_FILE, "test1"},
{"outfile", 1, HITLS_APP_OPT_VALUETYPE_OUT_FILE, "test2"},
{"string", 1, HITLS_APP_OPT_VALUETYPE_STRING, "test2"},
{"params", 1, HITLS_APP_OPT_VALUETYPE_PARAMTERS, "test2"},
{"dir", 1, HITLS_APP_OPT_VALUETYPE_DIR, "test2"},
{"int", 1, HITLS_APP_OPT_VALUETYPE_INT, "test2"},
{"uint", 1, HITLS_APP_OPT_VALUETYPE_UINT, "test2"},
{"pint", 1, HITLS_APP_OPT_VALUETYPE_POSITIVE_INT, "test2"},
{"long", 1, HITLS_APP_OPT_VALUETYPE_LONG, "test2"},
{"ulong", 1, HITLS_APP_OPT_VALUETYPE_ULONG, "test2"},
{"pemder", 1, HITLS_APP_OPT_VALUETYPE_FMT_PEMDER, "test2"},
{"any", 1, HITLS_APP_OPT_VALUETYPE_FMT_ANY, "test2"},
{NULL}
};
char *g_tc003Argv[][3] = {
{"help", "-novalue", NULL}, // 0 novalue tpye case
{"help", "-infile", "1.txt"}, // 1 infiletype case
{"help", "-outfile", "1.txt"}, // 2 outfiletype case
{"help", "-string", "11111"}, // 3 string case
{"help", "-params", "1211"}, // 4 params case
{"help", "-dir", "."}, // 5 dir case
{"help", "-int", "131231"}, // 6 int > 0 case
{"help", "-int", "-131231"}, // 7 int < 0 case
{"help", "-uint", "131231"}, // 8 uint > 0 case
{"help", "-uint", "-131231"}, // 9 uint < 0 case
{"help", "-uint", "3147483637"}, // 10 uint > max_uint case
{"help", "-pint", "13123"}, // 11 positive int > 0 case
{"help", "-pint", "0"}, // 12 positive int = 0 case
{"help", "-long", "13123"}, // 13 long > 0 case
{"help", "-ulong", "13123"}, // 14 ulong > 0 case
{"help", "-ulong", "1312312"}, // 15 ulong > 0 case
{"help", "-pemder", "PEM"}, // 16 pem case
{"help", "-pemder", "DER"}, // 17 der case
{"help", "-pemder", "xxx"}, // 18 any case
{"help", "-any", "PEM"}, // 19 any case
{"help", "-dir", NULL}, // 20 dir (value is NULL) case
{"help", "-dir", "1"}, // 21 dir (not exist) case
};
OptTestData g_tc003TestData[] = {
{3, g_tc003Argv[0], g_tc003Opts, 1},
{3, g_tc003Argv[1], g_tc003Opts, 1},
{3, g_tc003Argv[2], g_tc003Opts, 1},
{3, g_tc003Argv[3], g_tc003Opts, 1},
{3, g_tc003Argv[4], g_tc003Opts, 1},
{3, g_tc003Argv[5], g_tc003Opts, 1},
{3, g_tc003Argv[6], g_tc003Opts, 1},
{3, g_tc003Argv[7], g_tc003Opts, 1},
{3, g_tc003Argv[8], g_tc003Opts, 1},
{3, g_tc003Argv[9], g_tc003Opts, -1},
{3, g_tc003Argv[10], g_tc003Opts, -1},
{3, g_tc003Argv[11], g_tc003Opts, 1},
{3, g_tc003Argv[12], g_tc003Opts, 1},
{3, g_tc003Argv[13], g_tc003Opts, 1},
{3, g_tc003Argv[14], g_tc003Opts, 1},
{3, g_tc003Argv[15], g_tc003Opts, 1},
{3, g_tc003Argv[16], g_tc003Opts, 1},
{3, g_tc003Argv[17], g_tc003Opts, 1},
{3, g_tc003Argv[18], g_tc003Opts, -1},
{3, g_tc003Argv[19], g_tc003Opts, 1},
{3, g_tc003Argv[20], g_tc003Opts, -1},
{3, g_tc003Argv[21], g_tc003Opts, -1},
{3, g_tc003Argv[21], g_tc003Opts, -1},
};
/**
* @test HITLS_APP_OptNext_TC003
* @spec -
* @title 测试HITLS_APP_OptNext中各类值类型
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptNext_TC003(void)
{
AppPrintErrorUioInit(stderr);
for (int i = 0; i < (int)(sizeof(g_tc003TestData) / sizeof(OptTestData)); i++) {
(void)HITLS_APP_OptBegin(g_tc003TestData[i].argc, g_tc003TestData[i].argv, g_tc003TestData[i].opts);
ASSERT_EQ(HITLS_APP_OptNext(), g_tc003TestData[i].expect);
}
EXIT:
AppPrintErrorUioUnInit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_OptNext_TC004
* @spec -
* @title 测试HITLS_APP_OptNext函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptNext_TC004(void)
{
enum OptType{param = 0,help,cipher};
HITLS_CmdOption opts[] = {
{"help",help , HITLS_APP_OPT_VALUETYPE_NO_VALUE, "print help"},
{"",cipher,HITLS_APP_OPT_VALUETYPE_NO_VALUE,"cipher alg" },
{"param", param, HITLS_APP_OPT_VALUETYPE_PARAMTERS, "input paramters"},
{NULL}
};
char *argv[][3] = {
{"cmd", "-help", NULL},
{"cmd", "-aes128-cbc", NULL},
{"cmd", "a", "b"}
};
OptTestData testData[] = {
{3, argv[0], opts, help},
{3, argv[1], opts, cipher},
{3, argv[2], opts, param},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
(void)HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts);
ASSERT_EQ(HITLS_APP_OptNext(), testData[i].expect);
HITLS_APP_OptEnd();
}
EXIT:
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_GetRestOptNum_TC001
* @spec -
* @title 测试HITLS_APP_GetRestOptNum函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_GetRestOptNum_TC001(void)
{
char *argv[] = {"help", "-infile", "1.txt"};
HITLS_CmdOption opts[] = {
{"infile", 1, HITLS_APP_OPT_VALUETYPE_IN_FILE, "test1"},
{NULL}
};
OptTestData testData[] = {
{3, argv, opts, 2} // case1: rest opt number
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
(void)HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts);
ASSERT_EQ(HITLS_APP_GetRestOptNum(), testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_GetRestOpt_TC001
* @spec -
* @title 测试UT_HITLS_APP_GetRestOpt函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_GetRestOpt_TC001(void)
{
char *argv[] = {"help", "-infile", "1.txt"};
HITLS_CmdOption opts[] = {
{"infile", 1, HITLS_APP_OPT_VALUETYPE_IN_FILE, "test1"}, // case1: rest opt number
{NULL}
};
OptTestData testData[] = {
{3, argv, opts, 1}
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); i++) {
(void)HITLS_APP_OptBegin(testData[i].argc, testData[i].argv, testData[i].opts);
ASSERT_EQ(HITLS_APP_GetRestOpt() == &argv[1], testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
static bsl_sal_file_handle fileHandle = NULL;
static int32_t InitStderrUIOForFp(const char *filename, const char *mode)
{
int32_t ret = BSL_SAL_FileOpen(&fileHandle, filename, mode);
if (ret != BSL_SUCCESS) {
return HITLS_APP_INTERNAL_EXCEPTION;
}
return AppPrintErrorUioInit(fileHandle);
}
#define MAX_BUF_SIZE (1024 * 2)
static int32_t CheckResult()
{
char buf[MAX_BUF_SIZE] = {0};
size_t len;
int32_t ret = BSL_SAL_FileOpen(&fileHandle, "test.dat", "r");
if (ret != BSL_SUCCESS) {
return HITLS_APP_INTERNAL_EXCEPTION;
}
ret = BSL_SAL_FileRead(fileHandle, buf, sizeof(buf) / sizeof(char), sizeof(char), &len);
if (ret != BSL_SUCCESS) {
return HITLS_APP_INTERNAL_EXCEPTION;
}
(void)BSL_SAL_FileClose(fileHandle);
fileHandle = NULL;
/* check infile opt */
if (strstr(buf, "-infile infile input infile") == NULL) {
return HITLS_APP_INTERNAL_EXCEPTION;
}
/* check inint opt */
if (strstr(buf, "-inint int input int") == NULL) {
return HITLS_APP_INTERNAL_EXCEPTION;
}
/* check help opt */
if (strstr(buf, "-help print help") == NULL) {
return HITLS_APP_INTERNAL_EXCEPTION;
}
/* check param opt */
if (strstr(buf, "[param] input paramters") == NULL) {
return HITLS_APP_INTERNAL_EXCEPTION;
}
return HITLS_APP_SUCCESS;
}
static void *TestOptHelpPrint(void *args)
{
(void)args;
HITLS_CmdOption opts[] = {
{"infile", 1, HITLS_APP_OPT_VALUETYPE_IN_FILE, "input infile"}, // case1: rest opt number
{"inint", 1, HITLS_APP_OPT_VALUETYPE_INT, "input int"}, // case1: rest opt number
{"help", 1, HITLS_APP_OPT_VALUETYPE_NO_VALUE, "print help"}, // case1: rest opt number
{"param", 1, HITLS_APP_OPT_VALUETYPE_PARAMTERS, "input paramters"}, // case1: rest opt number
{NULL}
};
char *argv[] = {"help"};
#ifdef HITLS_BSL_SAL_DOPRA_V3
char* abPath = getcwd(NULL, 0);
ASSERT_EQ(VOS_VFS_SetWorkPath(abPath), 0);
#endif
ASSERT_TRUE(InitStderrUIOForFp("test.dat", "w+") == HITLS_APP_SUCCESS);
HITLS_APP_OptBegin(1, argv, opts);
HITLS_APP_OptHelpPrint(opts);
AppPrintErrorUioUnInit();
(void)BSL_SAL_FileClose(fileHandle);
fileHandle = NULL;
ASSERT_TRUE(CheckResult() == HITLS_APP_SUCCESS);
EXIT:
return NULL;
}
/**
* @test UT_HITLS_APP_OptHelpPrint_TC001
* @spec -
* @title 测试HITLS_APP_OptHelpPrint函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptHelpPrint_TC001(void)
{
#ifdef HITLS_BSL_SAL_DOPRA_V3
BSL_SAL_ThreadId serverThread = NULL;
ASSERT_EQ(BSL_SAL_ThreadCreate(&serverThread, TestOptHelpPrint, NULL), BSL_SUCCESS);
EXIT:
BSL_SAL_ThreadClose(serverThread);
#else
TestOptHelpPrint(NULL);
#endif
}
/* END_CASE */
typedef struct{
char* filename;
char mode;
int32_t flag;
}OptUioData;
/**
* @test UT_HITLS_APP_OptUioOpen_TC001
* @spec -
* @title UT_HITLS_APP_OptUioOpen_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptUioOpen_TC001(void)
{
OptUioData testData[] = {
{NULL, 'w', 0},
{NULL, 'r', 0},
{"1.txt", 'w', 0},
{"1.txt", 'r', 0},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptUioData)); ++i) {
BSL_UIO *ret = HITLS_APP_UioOpen(testData[i].filename, testData[i].mode, testData[i].flag);
ASSERT_TRUE(ret != NULL);
BSL_UIO_Free(ret);
}
EXIT:
return;
}
/* END_CASE */
int32_t STUB_BSL_UIO_Ctrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *parg)
{
(void)uio;
(void)cmd;
(void)larg;
(void)parg;
return BSL_UIO_FAIL;
}
/**
* @test UT_HITLS_APP_OptUioOpen_TC002
* @spec -
* @title UT_HITLS_APP_OptUioOpen_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptUioOpen_TC002(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UIO_Ctrl, STUB_BSL_UIO_Ctrl);
OptUioData testData[] = {
{NULL, 'w', 0},
{NULL, 'a', 0},
{NULL, 'b', 0},
{NULL, 'r', 0},
{"1.txt", 'w', 0},
{"1.txt", 'a', 0},
{"1.txt", 'b', 0},
{"1.txt", 'r', 0},
{"D:\\outfile\\1.txt", 'w', 0},
{"D:\\outfile\\1.txt", 'r', 0},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptUioData)); ++i) {
BSL_UIO *uio = HITLS_APP_UioOpen(testData[i].filename, testData[i].mode, testData[i].flag);
ASSERT_TRUE(uio == NULL);
}
EXIT:
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
BSL_UIO *STUB_BSL_UIO_New(const BSL_UIO_Method *method)
{
(void)method;
return NULL;
}
/**
* @test UT_HITLS_APP_OptUioOpen_TC003
* @spec -
* @title UT_HITLS_APP_OptUioOpen_TC003函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptUioOpen_TC003(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UIO_New, STUB_BSL_UIO_New);
OptUioData testData[] = {
{NULL, 'w', 0},
{NULL, 'r', 0},
{"1.txt", 'w', 0},
{"1.txt", 'r', 0}
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptUioData)); ++i) {
BSL_UIO *uio = HITLS_APP_UioOpen(testData[i].filename, testData[i].mode, testData[i].flag);
ASSERT_TRUE(uio == NULL);
}
EXIT:
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
typedef struct {
BSL_UIO *uio;
uint8_t *buf;
uint32_t outLen;
int32_t format;
int32_t expect;
} OutputUioData;
/**
* @test UT_HITLS_APP_OptUioOut_TC001
* @spec -
* @title 测试UT_HITLS_APP_OptUioOut_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptUioOut_TC001(void)
{
BSL_UIO *uio[] = {
HITLS_APP_UioOpen(NULL, 'w', 0),
HITLS_APP_UioOpen("D:\\outfile\\1.txt", 'w', 0),
HITLS_APP_UioOpen("1.txt", 'w', 0),
HITLS_APP_UioOpen(NULL, 'w', 0),
HITLS_APP_UioOpen(NULL, 'w', 0),
HITLS_APP_UioOpen(NULL, 'w', 0)
};
uint8_t buf[10] = {"123456789"};
OutputUioData testData[] = {
{uio[0], buf, 10, HITLS_APP_FORMAT_BASE64, HITLS_APP_SUCCESS},
{uio[1], buf, 10, HITLS_APP_FORMAT_HEX, HITLS_APP_SUCCESS},
{uio[2], buf, 10, HITLS_APP_FORMAT_BINARY, HITLS_APP_SUCCESS},
{uio[3], NULL, 10, HITLS_APP_FORMAT_BASE64, HITLS_APP_INTERNAL_EXCEPTION},
{uio[4], NULL, 10, HITLS_APP_FORMAT_HEX, HITLS_APP_INTERNAL_EXCEPTION},
{uio[5], buf, 0, HITLS_APP_FORMAT_BINARY, HITLS_APP_INTERNAL_EXCEPTION},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OutputUioData)); ++i) {
int ret = HITLS_APP_OptWriteUio(testData[i].uio, testData[i].buf, testData[i].outLen, testData[i].format);
BSL_UIO_Free(testData[i].uio);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
return;
}
/* END_CASE */
int32_t STUB_BSL_UIO_Write(BSL_UIO *uio, const void *data, uint32_t len, uint32_t *writeLen)
{
(void)uio;
(void)data;
(void)len;
(void)writeLen;
return BSL_INTERNAL_EXCEPTION;
}
/**
* @test UT_HITLS_APP_OptUioOut_TC002
* @spec -
* @title 测试UT_HITLS_APP_OptUioOut_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptUioOut_TC002(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UIO_Write, STUB_BSL_UIO_Write);
BSL_UIO *uio[] = {
HITLS_APP_UioOpen(NULL, 'w', 0),
HITLS_APP_UioOpen(NULL, 'w', 0),
HITLS_APP_UioOpen("1.txt", 'w', 0),
HITLS_APP_UioOpen("1.txt", 'w', 0),
};
uint8_t buf[][1024] = {"123456789qweeeeeeqweqweqweqwasd12312", "1234567893123123123123123", "", "NULL"};
OutputUioData testData[] = {
{uio[0], buf[0], 1024, HITLS_APP_FORMAT_BASE64, HITLS_APP_UIO_FAIL},
{uio[1], buf[1], 1024, HITLS_APP_FORMAT_HEX, HITLS_APP_UIO_FAIL},
{uio[2], buf[1], 1024, HITLS_APP_FORMAT_BINARY, HITLS_APP_UIO_FAIL},
{uio[3], buf[2], 1024, HITLS_APP_FORMAT_BASE64, HITLS_APP_UIO_FAIL},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OutputUioData)); ++i) {
int ret = HITLS_APP_OptWriteUio(testData[i].uio, testData[i].buf, testData[i].outLen, testData[i].format);
BSL_UIO_Free(testData[i].uio);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_BSL_Base64Encode(const uint8_t *srcBuf, const uint32_t srcBufLen, char *dstBuf, uint32_t *dstBufLen)
{
(void)srcBuf;
(void)srcBufLen;
(void)dstBuf;
(void)dstBufLen;
return BSL_UIO_FAIL;
}
/**
* @test UT_HITLS_APP_OptUioOut_TC003
* @spec -
* @title 测试UT_HITLS_APP_OptUioOut_TC003函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptUioOut_TC003(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_BASE64_Encode, STUB_BSL_Base64Encode);
BSL_UIO *uio[] = {
HITLS_APP_UioOpen(NULL, 'w', 0),
HITLS_APP_UioOpen(NULL, 'w', 0),
HITLS_APP_UioOpen("1.txt", 'w', 0),
HITLS_APP_UioOpen("1.txt", 'w', 0),
};
uint8_t buf[][1024] = {"123456789qweeeeeeqweqweqweqwasd12312", "1234567893123123123123123", "", "NULL"};
OutputUioData testData[] = {
{uio[0], buf[0], 1024, HITLS_APP_FORMAT_BASE64, HITLS_APP_ENCODE_FAIL},
{uio[1], NULL, 1024, HITLS_APP_FORMAT_BASE64, HITLS_APP_INTERNAL_EXCEPTION},
{uio[2], buf[2], 1024, HITLS_APP_FORMAT_BASE64, HITLS_APP_ENCODE_FAIL},
{uio[3], buf[3], 1024, HITLS_APP_FORMAT_BASE64, HITLS_APP_ENCODE_FAIL},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OutputUioData)); ++i) {
int ret = HITLS_APP_OptWriteUio(testData[i].uio, testData[i].buf, testData[i].outLen, testData[i].format);
BSL_UIO_Free(testData[i].uio);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_OptToBase64_TC001
* @spec -
* @title 测试UT_HITLS_APP_OptToBase64_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptToBase64_TC001(void)
{
uint8_t str[] = "hello, world";
char outBuf[1024] = {0};
int ret = HITLS_APP_OptToBase64(str, 0, outBuf, 1024);
ASSERT_EQ(ret, HITLS_APP_INTERNAL_EXCEPTION);
int ret1 = HITLS_APP_OptToBase64(NULL, 12, outBuf, 1024);
ASSERT_EQ(ret1, HITLS_APP_INTERNAL_EXCEPTION);
int ret2 = HITLS_APP_OptToBase64(str, 12, NULL, 1024);
ASSERT_EQ(ret2, HITLS_APP_INTERNAL_EXCEPTION);
int ret3 = HITLS_APP_OptToBase64(str, 12, outBuf, 0);
ASSERT_EQ(ret3, HITLS_APP_INTERNAL_EXCEPTION);
EXIT:
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_OptToHex_TC001
* @spec -
* @title 测试UT_HITLS_APP_OptToHex_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_OptToHex_TC001(void)
{
uint8_t str[] = "hello, world";
char outBuf[1024] = {0};
int ret = HITLS_APP_OptToHex(str, 0, outBuf, 1024);
ASSERT_EQ(ret, HITLS_APP_INTERNAL_EXCEPTION);
int ret1 = HITLS_APP_OptToHex(NULL, 12, outBuf, 1024);
ASSERT_EQ(ret1, HITLS_APP_INTERNAL_EXCEPTION);
int ret2 = HITLS_APP_OptToHex(str, 12, NULL, 1024);
ASSERT_EQ(ret2, HITLS_APP_INTERNAL_EXCEPTION);
int ret3 = HITLS_APP_OptToHex(str, 12, outBuf, 0);
ASSERT_EQ(ret3, HITLS_APP_INTERNAL_EXCEPTION);
int ret4 = HITLS_APP_OptToHex(str, 12, outBuf, 4);
ASSERT_EQ(ret4, HITLS_APP_INTERNAL_EXCEPTION);
EXIT:
return;
}
/* END_CASE */
bool IsFileExist(const char *fileName)
{
FILE *f = fopen(fileName, "r");
if (f == NULL) {
return false;
}
fclose(f);
return true;
}
int32_t CreateFile(const char *fileName, const char *data)
{
size_t dataLen = strlen(data);
FILE *f = fopen(fileName, "w");
ASSERT_EQ(fwrite(data, dataLen, 1, f), 1);
(void)fclose(f);
return 1;
EXIT:
return 0;
}
/* @
* @test UT_HITLS_APP_Opt_Write_TC001
* @spec -
* @title file uio 测试: "w"模式打开文件，不存在则新建，存在则删除后再新建
@ */
/* BEGIN_CASE */
void UT_HITLS_APP_Opt_Write_TC001(void)
{
const char *data = "1";
uint32_t dataLen = strlen(data);
BSL_UIO *uio = NULL;
char *testFile = "uio.txt";
ASSERT_TRUE(IsFileExist(testFile) == false);
uio = HITLS_APP_UioOpen(testFile, 'w', 1);
ASSERT_TRUE(uio != NULL);
ASSERT_TRUE(IsFileExist(testFile));
ASSERT_EQ(HITLS_APP_OptWriteUio(uio, (uint8_t *)data, dataLen, HITLS_APP_FORMAT_BINARY), HITLS_APP_SUCCESS);
EXIT:
BSL_UIO_Free(uio);
remove(testFile);
}
/* END_CASE */
/**
* @test UT_HITLS_APP_Opt_Uio_Read_TC001
* @spec -
* @title 测试UT_HITLS_APP_Opt_Uio_Read_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_Opt_Uio_Read_TC001(void)
{
char *testFile = "file_uio.txt";
char data[] = "0123456789abcdef";
uint32_t dataLen = strlen(data);
BSL_UIO *uio = NULL;
uint8_t *readBuf = NULL;
uint64_t readBufLen = 0;
ASSERT_TRUE(IsFileExist(testFile) == false);
ASSERT_EQ(HITLS_APP_OptReadUio(uio, &readBuf, &readBufLen, 0), HITLS_APP_INTERNAL_EXCEPTION);
ASSERT_EQ(CreateFile(testFile, data), 1);
ASSERT_TRUE(IsFileExist(testFile));
uio = HITLS_APP_UioOpen(testFile, 'r', 0);
ASSERT_TRUE(uio != NULL);
ASSERT_EQ(HITLS_APP_OptReadUio(uio, &readBuf, &readBufLen, 2048), HITLS_APP_SUCCESS);
ASSERT_EQ(readBufLen, dataLen);
EXIT:
BSL_UIO_Free(uio);
BSL_SAL_FREE(readBuf);
remove(testFile);
return;
}
/* END_CASE */
int32_t STUB_BSL_UIO_Read(BSL_UIO *uio, const void *data, uint32_t len, uint32_t *writeLen)
{
(void)uio;
(void)data;
(void)len;
(void)writeLen;
return HITLS_APP_UIO_FAIL;
}
/**
* @test UT_HITLS_APP_Opt_Uio_Read_TC002
* @spec -
* @title 测试UT_HITLS_APP_Opt_Uio_Read_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_Opt_Uio_Read_TC002(void)
{
char *testFile = "file_read_uio.txt";
const char *data = "0123456789abcdef";
BSL_UIO *uio = NULL;
uint8_t *readBuf = NULL;
uint64_t readBufLen = 0;
ASSERT_EQ(CreateFile(testFile, data), 1);
uio = HITLS_APP_UioOpen(testFile, 'r', 0);
ASSERT_TRUE(uio != NULL);
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UIO_Read, STUB_BSL_UIO_Read);
ASSERT_EQ(HITLS_APP_OptReadUio(uio, &readBuf, &readBufLen, 0), HITLS_APP_UIO_FAIL);
testFile = NULL;
ASSERT_EQ(HITLS_APP_OptReadUio(uio, &readBuf, &readBufLen, 0), HITLS_APP_UIO_FAIL);
EXIT:
BSL_UIO_Free(uio);
BSL_SAL_FREE(readBuf);
remove(testFile);
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_Opt_Uio_Read_TC003
* @spec -
* @title 测试UT_HITLS_APP_Opt_Uio_Read_TC003函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_Opt_Uio_Read_TC003(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, BSL_UIO_Ctrl, STUB_BSL_UIO_Ctrl);
char *testFile = "file_read_uio.txt";
const char *data = "0123456789abcdef";
BSL_UIO *uio = NULL;
uint8_t *readBuf = NULL;
uint64_t readBufLen = 0;
ASSERT_EQ(CreateFile(testFile, data), 1);
uio = HITLS_APP_UioOpen(testFile, 'r', 0);
ASSERT_TRUE(uio == NULL);
ASSERT_EQ(HITLS_APP_OptReadUio(uio, &readBuf, &readBufLen, 0), HITLS_APP_INTERNAL_EXCEPTION);
EXIT:
BSL_UIO_Free(uio);
BSL_SAL_FREE(readBuf);
remove(testFile);
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_opt.c
|
C
|
unknown
| 30,359
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "app_opt.h"
#include "securec.h"
#include "app_errno.h"
#include "bsl_uio.h"
#include "app_print.h"
/* END_HEADER */
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c */
/**
* @test UT_HITLS_APP_PrintStderr_TC001
* @spec -
* @title 测试UT_HITLS_APP_PrintStderr_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APPPrint_TC001(void)
{
AppPrintErrorUioInit(stderr);
AppPrintError("\n%d %x\n", BSL_UIO_FILE_PTR, BSL_UIO_FILE_PTR + 1);
AppPrintErrorUioUnInit();
}
/* END_CASE */
BSL_UIO *g_stderrUio = NULL;
static int32_t InitStderrUIO(void)
{
if (g_stderrUio != NULL)
return HITLS_APP_SUCCESS;
g_stderrUio = BSL_UIO_New(BSL_UIO_FileMethod());
if (g_stderrUio == NULL)
return HITLS_APP_MEM_ALLOC_FAIL;
return BSL_UIO_Ctrl(g_stderrUio, BSL_UIO_FILE_PTR, 0, (void *)stderr);
}
/**
* @test UT_HITLS_APP_Print_TC001
* @spec -
* @title 测试UT_HITLS_APP_Print_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APPPrint_TC002(void)
{
InitStderrUIO();
ASSERT_EQ(AppPrint(g_stderrUio, "\n%d %x\n", HITLS_APP_SUCCESS, HITLS_APP_SUCCESS + 1), HITLS_APP_SUCCESS);
EXIT:
BSL_UIO_Free(g_stderrUio);
g_stderrUio = NULL;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_print.c
|
C
|
unknown
| 1,777
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include "app_opt.h"
#include "app_print.h"
#include "bsl_uio.h"
#include "uio_abstraction.h"
#include "crypt_eal_rand.h"
#include "app_errno.h"
#include "bsl_base64.h"
#include "crypt_errno.h"
#include "app_rand.h"
#include "app_function.h"
#include "app_provider.h"
#include "app_sm.h"
#include "securec.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "bsl_ui.h"
#include "stub_replace.h"
/* END_HEADER */
#define WORK_PATH "./rand_workpath"
#define PASSWORD "12345678"
typedef struct {
int argc;
char **argv;
int expect;
} OptTestData;
/* INCLUDE_SOURCE ${HITLS_ROOT_PATH}/apps/src/app_print.c ${HITLS_ROOT_PATH}/apps/src/app_rand.c ${HITLS_ROOT_PATH}/apps/src/app_opt.c */
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(void)
{
return HITLS_APP_SUCCESS;
}
#endif
/**
* @test UT_HITLS_APP_rand_TC001
* @spec -
* @title 测试UT_HITLS_APP_rand_TC001函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC001(void)
{
char *argv[][10] = {
{"rand", "-hex", "10"},
{"rand", "10"},
{"rand", "-base64", "10"},
{"rand", "-out", "TC001_binary.txt", "10"},
{"rand", "-out", "TC001_hex.txt", "-hex", "10"},
{"rand", "-out", "TC001_base64.txt", "-base64", "10"}
};
OptTestData testData[] = {
{3, argv[0], HITLS_APP_SUCCESS},
{2, argv[1], HITLS_APP_SUCCESS},
{3, argv[2], HITLS_APP_SUCCESS},
{4, argv[3], HITLS_APP_SUCCESS},
{5, argv[4], HITLS_APP_SUCCESS},
{5, argv[5], HITLS_APP_SUCCESS}
};
ASSERT_EQ(AppInit(), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppUninit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_rand_TC002
* @spec -
* @title 测试UT_HITLS_APP_rand_TC002函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC002(void)
{
char *argv[][5] = {
{"rand", "-base64", "-out", "1.txt", "10"},
{"rand", "-hex", "-out", "D:\\outfile\\1.txt", "10"},
{"rand", "-hex", "1.txt", "10"},
{"rand", "-out"}
};
OptTestData testData[] =
{
{5, argv[0], HITLS_APP_SUCCESS},
{5, argv[1], HITLS_APP_SUCCESS},
{4, argv[2], HITLS_APP_OPT_UNKOWN},
{2, argv[3], HITLS_APP_OPT_UNKOWN}
};
ASSERT_EQ(AppInit(), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppUninit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_rand_TC003
* @spec -
* @title 测试UT_HITLS_APP_rand_TC003函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC003(void)
{
char *argv[][4] = {
{"rand", "1231-31231"},
{"rand", "asdsaldsalkdsjadl"},
{"rand", "2147483648"},
{"rand", "-10"},
{"rand", "2312/0"},
{"rand", "-out", "D:\\outfile\\1.txt", "123"},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_OPT_VALUE_INVALID},
{2, argv[1], HITLS_APP_OPT_VALUE_INVALID},
{2, argv[2], HITLS_APP_OPT_VALUE_INVALID},
{2, argv[3], HITLS_APP_OPT_UNKOWN}, //带了'-'误认为是命令
{2, argv[4], HITLS_APP_OPT_VALUE_INVALID},
{4, argv[5], HITLS_APP_SUCCESS}
};
ASSERT_EQ(AppInit(), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppUninit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_rand_TC004
* @spec -
* @title 测试UT_HITLS_APP_rand_TC004函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC004(void)
{
char *argv[][2] = {
{"rand", "-help"},
};
OptTestData testData[] = {
{2, argv[0], HITLS_APP_HELP},
};
ASSERT_EQ(AppInit(), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppUninit();
return;
}
/* END_CASE */
int32_t STUB_HITLS_APP_OptBegin(int32_t argc, char **argv, const HITLS_CmdOption *opts)
{
(void)argc;
(void)argv;
(void)opts;
return HITLS_APP_OPT_UNKOWN;
}
/**
* @test UT_HITLS_APP_rand_TC005
* @spec -
* @title 测试UT_HITLS_APP_rand_TC005函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC005(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptBegin, STUB_HITLS_APP_OptBegin);
char *argv[][3] = {
{"rand", "-hex", "10"},
};
OptTestData testData[] = {
{3, argv[0], HITLS_APP_OPT_UNKOWN},
};
ASSERT_EQ(AppInit(), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppUninit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_BSL_UIO_Ctrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *parg)
{
(void)uio;
(void)cmd;
(void)larg;
(void)parg;
return BSL_NULL_INPUT;
}
/**
* @test UT_HITLS_APP_rand_TC007
* @spec -
* @title 测试UT_HITLS_APP_rand_TC007函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC007(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
ASSERT_EQ(AppInit(), HITLS_APP_SUCCESS);
STUB_Replace(&stubInfo, BSL_UIO_Ctrl, STUB_BSL_UIO_Ctrl);
char *argv[][4] = {
{"rand", "-hex", "2049"},
{"rand", "-out", "1.txt", "10"},
{"rand", "-out", "D:\\outfile\\1.txt", "10"}
};
OptTestData testData[] = {
{3, argv[0], HITLS_APP_UIO_FAIL},
{4, argv[1], HITLS_APP_UIO_FAIL},
{4, argv[2], HITLS_APP_UIO_FAIL},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
STUB_Reset(&stubInfo);
AppUninit();
return;
}
/* END_CASE */
int32_t STUB_CRYPT_EAL_RandInit(
CRYPT_EAL_LibCtx *libCtx, int32_t algId, const char *attrName,
const uint8_t *pers, uint32_t persLen, BSL_Param *param)
{
(void)libCtx;
(void)algId;
(void)attrName;
(void)pers;
(void)persLen;
(void)param;
return CRYPT_EAL_ERR_DRBG_INIT_FAIL;
}
/**
* @test UT_HITLS_APP_rand_TC008
* @spec -
* @title 测试UT_HITLS_APP_rand_TC008函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC008(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, CRYPT_EAL_ProviderRandInitCtx, STUB_CRYPT_EAL_RandInit);
char *argv[][3] = {
{"rand", "-hex", "10"},
};
OptTestData testData[] = {
{3, argv[0], HITLS_APP_CRYPTO_FAIL},
};
ASSERT_EQ(AppInit(), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppUninit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_CRYPT_EAL_Randbytes(void *libctx, uint8_t *byte, uint32_t len)
{
(void)byte;
(void)len;
(void)libctx;
return CRYPT_EAL_ERR_GLOBAL_DRBG_NULL;
}
/**
* @test UT_HITLS_APP_rand_TC009
* @spec -
* @title 测试UT_HITLS_APP_rand_TC009函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC009(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, CRYPT_EAL_RandbytesEx, STUB_CRYPT_EAL_Randbytes);
char *argv[][3] = {
{"rand", "-hex", "10"},
};
OptTestData testData[] = {
{3, argv[0], HITLS_APP_CRYPTO_FAIL},
};
ASSERT_EQ(AppInit(), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppUninit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
BSL_UIO *STUB_BSL_UIO_New(const BSL_UIO_Method *method)
{
(void)method;
return NULL;
}
/**
* @test UT_HITLS_APP_rand_TC0010
* @spec -
* @title 测试UT_HITLS_APP_rand_TC0010函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC0010(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
ASSERT_EQ(AppInit(), HITLS_APP_SUCCESS);
STUB_Replace(&stubInfo, BSL_UIO_New, STUB_BSL_UIO_New);
char *argv[][3] = {
{"rand", "-hex", "10"},
};
OptTestData testData[] = {
{3, argv[0], HITLS_APP_UIO_FAIL},
};
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
STUB_Reset(&stubInfo);
AppUninit();
return;
}
/* END_CASE */
char *STUB_HITLS_APP_OptGetValueStr(void)
{
return NULL;
}
/**
* @test UT_HITLS_APP_rand_TC0011
* @spec -
* @title 测试UT_HITLS_APP_rand_TC0011函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC0011(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptGetValueStr, STUB_HITLS_APP_OptGetValueStr);
char *argv[][4] = {{"rand", "-out", "1.txt", "10"}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_OPT_VALUE_INVALID},
};
ASSERT_EQ(AppInit(), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppUninit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
int32_t STUB_HITLS_APP_OptWriteUio(BSL_UIO *uio, uint8_t *buf, uint32_t outLen, int32_t format)
{
(void)uio;
(void)buf;
(void)outLen;
(void)format;
return HITLS_APP_UIO_FAIL;
}
/**
* @test UT_HITLS_APP_rand_TC0012
* @spec -
* @title 测试UT_HITLS_APP_rand_TC0012函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC0012(void)
{
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, HITLS_APP_OptWriteUio, STUB_HITLS_APP_OptWriteUio);
char *argv[][4] = {{"rand", "-out", "1.txt", "10"}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_UIO_FAIL},
};
ASSERT_EQ(AppInit(), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
}
EXIT:
AppUninit();
STUB_Reset(&stubInfo);
return;
}
/* END_CASE */
bool IsFileExist(const char *fileName)
{
FILE *f = fopen(fileName, "r");
if (f == NULL) {
return false;
}
fclose(f);
return true;
}
/**
* @test UT_HITLS_APP_rand_TC0013
* @spec -
* @title 测试UT_HITLS_APP_rand_TC0013函数
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC0013(void)
{
char* filename = "TC0013_binary.txt";
char *argv[][10] = {
{"rand", "-out", filename, "10"},
{"rand", "-out", filename, "-hex", "10"},
{"rand", "-out", filename, "-base64", "10"}};
OptTestData testData[] = {
{4, argv[0], HITLS_APP_SUCCESS},
{5, argv[1], HITLS_APP_SUCCESS},
{5, argv[2], HITLS_APP_SUCCESS},
};
ASSERT_EQ(AppInit(), HITLS_APP_SUCCESS);
for (int i = 0; i < (int)(sizeof(testData) / sizeof(OptTestData)); ++i) {
ASSERT_TRUE(IsFileExist(filename) == false);
int ret = HITLS_RandMain(testData[i].argc, testData[i].argv);
ASSERT_EQ(ret, testData[i].expect);
ASSERT_TRUE(IsFileExist(filename));
remove(filename);
}
EXIT:
AppUninit();
return;
}
/* END_CASE */
/**
* @test UT_HITLS_APP_rand_TC0014
* @spec -
* @title Test the random function in SM mode.
*/
/* BEGIN_CASE */
void UT_HITLS_APP_rand_TC0014(void)
{
#ifndef HITLS_APP_SM_MODE
SKIP_TEST();
#else
system("rm -rf " WORK_PATH);
system("mkdir -p " WORK_PATH);
STUB_Init();
FuncStubInfo stubInfo[2] = {0};
STUB_Replace(&stubInfo[0], BSL_UI_ReadPwdUtil, STUB_BSL_UI_ReadPwdUtil);
STUB_Replace(&stubInfo[1], HITLS_APP_SM_IntegrityCheck, STUB_HITLS_APP_SM_IntegrityCheck);
char *argv[7] = {"rand", "-sm", "-workpath", WORK_PATH, "-hex", "10", NULL};
ASSERT_EQ(AppInit(), HITLS_APP_SUCCESS);
ASSERT_EQ(HITLS_RandMain(6, argv), HITLS_APP_SUCCESS);
EXIT:
AppUninit();
STUB_Reset(&stubInfo[0]);
STUB_Reset(&stubInfo[1]);
system("rm -rf " WORK_PATH);
#endif
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/apps/test_suite_ut_rand.c
|
C
|
unknown
| 14,329
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdint.h>
#include "privpass_token.h"
#include "auth_privpass_token.h"
#include "auth_errno.h"
#include "auth_params.h"
#include "crypt_util_rand.h"
#include "crypt_eal_rand.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_codecs.h"
#include "crypt_errno.h"
#include "crypt_params_key.h"
#include "eal_md_local.h"
#include "securec.h"
/* END_HEADER */
#define MAX_LEN 512
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_SERIALIZATION_TC001
* @spec Private Pass Token Serialization
* @title Test serialization and deserialization of Private Pass Token objects
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_SERIALIZATION_TC001(int type, Hex *buffer)
{
TestRandInit();
uint8_t output[MAX_LEN];
uint32_t outputLen = 0;
HITLS_AUTH_PrivPassToken *challenge = NULL;
HITLS_AUTH_PrivPassCtx *ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
// Test deserialization
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, type, buffer->x, buffer->len, &challenge), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, challenge, NULL, &outputLen), HITLS_AUTH_SUCCESS);
outputLen--;
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, challenge, output, &outputLen),
HITLS_AUTH_PRIVPASS_BUFFER_NOT_ENOUGH);
outputLen++;
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, challenge, output, &outputLen), HITLS_AUTH_SUCCESS);
// Test serialization
ASSERT_COMPARE("compare token", output, outputLen, buffer->x, buffer->len);
EXIT:
HITLS_AUTH_PrivPassFreeToken(challenge);
HITLS_AUTH_PrivPassFreeCtx(ctx);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_SERIALIZATION_TC002
* @spec Private Pass Token challenge serialization
* @title Test serialization of Private Pass Token challenge
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_SERIALIZATION_TC002(Hex *tokenType, Hex *issuerName, Hex *redemption, Hex *originInfo)
{
HITLS_AUTH_PrivPassCtx *ctx = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge1 = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge2 = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge3 = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge4 = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge3_1 = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge4_1 = NULL;
uint8_t output1[MAX_LEN >> 1];
uint32_t outputLen1 = MAX_LEN >> 1;
uint8_t output2[MAX_LEN >> 1];
uint32_t outputLen2 = MAX_LEN >> 1;
uint8_t output3[MAX_LEN >> 1];
uint32_t outputLen3 = MAX_LEN >> 1;
uint8_t output4[MAX_LEN >> 1];
uint32_t outputLen4 = MAX_LEN >> 1;
uint16_t tokenTypeValue = tokenType->x[0] << 8 | tokenType->x[1];
BSL_Param param1[5] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenTypeValue, 2, 2},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerName->x, issuerName->len,
issuerName->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemption->x, redemption->len,
redemption->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ORIGININFO, BSL_PARAM_TYPE_OCTETS_PTR, originInfo->x, originInfo->len,
originInfo->len},
BSL_PARAM_END};
BSL_Param param2[5] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerName->x, issuerName->len,
issuerName->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenTypeValue, 2, 2},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ORIGININFO, BSL_PARAM_TYPE_OCTETS_PTR, originInfo->x, originInfo->len,
originInfo->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemption->x, redemption->len,
redemption->len},
BSL_PARAM_END};
BSL_Param param3[5] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerName->x, issuerName->len,
issuerName->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ORIGININFO, BSL_PARAM_TYPE_OCTETS_PTR, originInfo->x, originInfo->len,
originInfo->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, 0, 0, 0},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenTypeValue, 2, 2}, BSL_PARAM_END};
BSL_Param param4[4] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerName->x, issuerName->len,
issuerName->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemption->x, redemption->len,
redemption->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenTypeValue, 2, 2}, BSL_PARAM_END};
TestRandInit();
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(ctx, param1, &tokenChallenge1), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, tokenChallenge1, output1, &outputLen1), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(ctx, param2, &tokenChallenge2), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, tokenChallenge2, output2, &outputLen2), HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare token", output1, outputLen1, output2, outputLen2);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(ctx, param3, &tokenChallenge3), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, tokenChallenge3, output3, &outputLen3), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE, output3, outputLen3,
&tokenChallenge3_1), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(ctx, param4, &tokenChallenge4), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, tokenChallenge4, output4, &outputLen4), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE, output4, outputLen4,
&tokenChallenge4_1), HITLS_AUTH_SUCCESS);
EXIT:
CRYPT_EAL_RandDeinit();
HITLS_AUTH_PrivPassFreeToken(tokenChallenge1);
HITLS_AUTH_PrivPassFreeToken(tokenChallenge2);
HITLS_AUTH_PrivPassFreeToken(tokenChallenge3);
HITLS_AUTH_PrivPassFreeToken(tokenChallenge4);
HITLS_AUTH_PrivPassFreeToken(tokenChallenge3_1);
HITLS_AUTH_PrivPassFreeToken(tokenChallenge4_1);
HITLS_AUTH_PrivPassFreeCtx(ctx);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_SERIALIZATION_INVALID_TC001
* @spec Private Pass Token Serialization Invalid Parameters
* @title Test serialization and deserialization with invalid parameters
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_SERIALIZATION_INVALID_TC001()
{
uint8_t output[MAX_LEN];
uint32_t outputLen = MAX_LEN;
HITLS_AUTH_PrivPassToken *token = NULL;
uint8_t dummyData[8] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
HITLS_AUTH_PrivPassCtx *ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
// Test NULL parameters
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE,
NULL, sizeof(dummyData), &token), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE,
dummyData, 0, &token), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE,
dummyData, sizeof(dummyData), NULL), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
// Test invalid token type
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, 999, dummyData,
sizeof(dummyData), &token), HITLS_AUTH_PRIVPASS_INVALID_TOKEN_TYPE);
// Test serialization with NULL parameters
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, NULL, output, &outputLen), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, token, NULL, &outputLen), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, token, output, NULL), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
EXIT:
HITLS_AUTH_PrivPassFreeToken(token);
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_SERIALIZATION_INVALID_TC002
* @spec Private Pass Token Invalid Serialization
* @title Test deserialization with invalid token data
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_SERIALIZATION_INVALID_TC002(int type, Hex *buffer)
{
HITLS_AUTH_PrivPassToken *token = NULL;
HITLS_AUTH_PrivPassCtx *ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_NE(HITLS_AUTH_PrivPassDeserialization(ctx, type, buffer->x, buffer->len, &token), HITLS_AUTH_SUCCESS);
EXIT:
HITLS_AUTH_PrivPassFreeToken(token);
HITLS_AUTH_PrivPassFreeCtx(ctx);
CRYPT_EAL_RandDeinit();
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_SERIALIZATION_INVALID_TC003
* @spec Private Pass Token Invalid Serialization
* @title Test serialization with invalid data
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_SERIALIZATION_INVALID_TC003(int type, Hex *buffer)
{
HITLS_AUTH_PrivPassToken *token = NULL;
HITLS_AUTH_PrivPassToken *token2 = NULL;
uint8_t output[MAX_LEN];
uint32_t outputLen = MAX_LEN;
HITLS_AUTH_PrivPassCtx *ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, type, buffer->x, buffer->len, &token), HITLS_AUTH_SUCCESS);
if (type == HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE) {
token->st.tokenChallenge->tokenType = 0x0001; // support prv type
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, token, output, &outputLen), HITLS_AUTH_SUCCESS);
}
if (type == HITLS_AUTH_PRIVPASS_TOKEN_REQUEST) {
token->st.tokenRequest->tokenType = 0x0001; // not support prv type
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, token, output, &outputLen),
HITLS_AUTH_PRIVPASS_INVALID_TOKEN_REQUEST);
}
if (type == HITLS_AUTH_PRIVPASS_TOKEN_RESPONSE) {
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, type, buffer->x, buffer->len - 1, &token2),
HITLS_AUTH_PRIVPASS_INVALID_TOKEN_TYPE);
token->st.tokenResponse->type = 0; // not support prv type
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, token, output, &outputLen),
HITLS_AUTH_PRIVPASS_INVALID_TOKEN_RESPONSE);
token->st.tokenResponse->type = 1;
}
if (type == HITLS_AUTH_PRIVPASS_TOKEN_INSTANCE) {
token->st.token->tokenType = 0; // not support prv type
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, token, output, &outputLen),
HITLS_AUTH_PRIVPASS_INVALID_TOKEN_INSTANCE);
}
EXIT:
HITLS_AUTH_PrivPassFreeToken(token);
HITLS_AUTH_PrivPassFreeCtx(ctx);
CRYPT_EAL_RandDeinit();
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_GEN_PROCESS_TC001
* @spec Private Pass Token Generation Process
* @title Test complete token generation process including challenge, request, response and verification
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_GEN_PROCESS_TC001(Hex *pki, Hex *ski, Hex *tokenType, Hex *issuerName,
Hex *redemption, Hex *originInfo)
{
HITLS_AUTH_PrivPassCtx *client = NULL;
HITLS_AUTH_PrivPassCtx *issuer = NULL;
HITLS_AUTH_PrivPassCtx *server = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge2 = NULL;
HITLS_AUTH_PrivPassToken *tokenRequest = NULL;
HITLS_AUTH_PrivPassToken *tokenResponse = NULL;
HITLS_AUTH_PrivPassToken *finalToken = NULL;
uint8_t output[MAX_LEN];
uint32_t outputLen = MAX_LEN;
uint16_t tokenTypeValue = tokenType->x[0] << 8 | tokenType->x[1];
BSL_Param param[5] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenTypeValue, 2, 2},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerName->x, issuerName->len,
issuerName->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemption->x, redemption->len,
redemption->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ORIGININFO, BSL_PARAM_TYPE_OCTETS_PTR, originInfo->x, originInfo->len,
originInfo->len},
BSL_PARAM_END};
TestRandInit();
// Create context
client = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(client, NULL);
issuer = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(issuer, NULL);
server = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(server, NULL);
// Set keys
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(client, pki->x, pki->len), HITLS_AUTH_SUCCESS);
// issuer needs pub and prv key
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(issuer, NULL, ski->x, ski->len), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(issuer, pki->x, pki->len), HITLS_AUTH_SUCCESS);
// server
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(server, pki->x, pki->len), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(server, param, &tokenChallenge), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(server, tokenChallenge, output, &outputLen), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(client, HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE, output,
outputLen, &tokenChallenge2), HITLS_AUTH_SUCCESS);
// Generate token request
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenReq(client, tokenChallenge, &tokenRequest), HITLS_AUTH_SUCCESS);
// Generate token response
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenResponse(issuer, tokenRequest, &tokenResponse), HITLS_AUTH_SUCCESS);
// Generate final token
ASSERT_EQ(HITLS_AUTH_PrivPassGenToken(client, tokenChallenge, tokenResponse, &finalToken), HITLS_AUTH_SUCCESS);
// Verify token
ASSERT_EQ(HITLS_AUTH_PrivPassVerifyToken(server, tokenChallenge, finalToken), HITLS_AUTH_SUCCESS);
EXIT:
CRYPT_EAL_RandDeinit();
HITLS_AUTH_PrivPassFreeToken(tokenChallenge);
HITLS_AUTH_PrivPassFreeToken(tokenChallenge2);
HITLS_AUTH_PrivPassFreeToken(tokenRequest);
HITLS_AUTH_PrivPassFreeToken(tokenResponse);
HITLS_AUTH_PrivPassFreeToken(finalToken);
HITLS_AUTH_PrivPassFreeCtx(client);
HITLS_AUTH_PrivPassFreeCtx(issuer);
HITLS_AUTH_PrivPassFreeCtx(server);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_GEN_TOKEN_CHALLENGE_TC001
* @spec Private Pass Token gen invalid token challenge
* @title Test gen invalid token challenge
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_GEN_TOKEN_CHALLENGE_TC001(Hex *tokenType, Hex *issuerName, Hex *redemption,
Hex *originInfo)
{
HITLS_AUTH_PrivPassCtx *ctx = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge = NULL;
uint16_t invaliedTokenType = 3;
uint16_t tokenTypeValue = tokenType->x[0] << 8 | tokenType->x[1];
BSL_Param param1[5] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerName->x, issuerName->len,
issuerName->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &invaliedTokenType, 2, 2},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ORIGININFO, BSL_PARAM_TYPE_OCTETS_PTR, originInfo->x, originInfo->len,
originInfo->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemption->x, redemption->len,
redemption->len},
BSL_PARAM_END};
BSL_Param param2[4] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenTypeValue, 2, 2},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ORIGININFO, BSL_PARAM_TYPE_OCTETS_PTR, originInfo->x, originInfo->len,
originInfo->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemption->x, redemption->len,
redemption->len},
BSL_PARAM_END};
BSL_Param param3[4] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenTypeValue, 2, 2},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerName->x,
PRIVPASS_MAX_ISSUER_NAME_LEN + 1, PRIVPASS_MAX_ISSUER_NAME_LEN + 1},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemption->x, redemption->len,
redemption->len},
BSL_PARAM_END};
BSL_Param param4[5] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenTypeValue, 2, 2},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerName->x, issuerName->len,
issuerName->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemption->x, redemption->len,
redemption->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ORIGININFO, BSL_PARAM_TYPE_OCTETS_PTR, originInfo->x,
PRIVPASS_MAX_ISSUER_NAME_LEN + 1, PRIVPASS_MAX_ORIGIN_INFO_LEN + 1},
BSL_PARAM_END};
BSL_Param param5[4] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenTypeValue, 2, 2},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerName->x, issuerName->len,
issuerName->len},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemption->x,
PRIVPASS_MAX_ISSUER_NAME_LEN + 1, PRIVPASS_REDEMPTION_LEN + 1},
BSL_PARAM_END};
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(ctx, param1, &tokenChallenge),
HITLS_AUTH_PRIVPASS_INVALID_TOKEN_TYPE);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(ctx, param2, &tokenChallenge),
HITLS_AUTH_PRIVPASS_NO_TOKEN_CHALLENGE_ISSUERNAME);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(ctx, param3, &tokenChallenge),
HITLS_AUTH_PRIVPASS_INVALID_ISSUER_NAME);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(ctx, param4, &tokenChallenge),
HITLS_AUTH_PRIVPASS_INVALID_ORIGIN_INFO);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(ctx, param5, &tokenChallenge),
HITLS_AUTH_PRIVPASS_INVALID_REDEMPTION);
EXIT:
CRYPT_EAL_RandDeinit();
HITLS_AUTH_PrivPassFreeToken(tokenChallenge);
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
static uint8_t *g_nonceBuf;
static uint32_t g_nonceLen;
static uint8_t *g_saltBuf;
static uint32_t g_saltLen;
static uint8_t *g_blindBuf;
static uint32_t g_blindLen;
static int32_t ref = 0;
static int32_t STUB_ReplaceRandom(uint8_t *r, uint32_t randLen)
{
if (ref == 0) {
for (uint32_t i = 0; i < randLen; i++) {
r[i] = g_nonceBuf[i];
}
ref++;
} else if (ref == 1) {
for (uint32_t i = 0; i < randLen; i++) {
r[i] = g_saltBuf[i];
}
ref++;
} else if (ref == 2) {
for (uint32_t i = 0; i < randLen; i++) {
r[i] = g_blindBuf[i];
}
}
return 0;
}
static int32_t STUB_ReplaceRandomWEx(void *libCtx, uint8_t *r, uint32_t randLen)
{
(void) libCtx;
return STUB_ReplaceRandom(r, randLen);
}
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_VECTOR_TEST_TC001
* @spec Private Pass Token Vector Testing
* @title Test token generation process with predefined test vectors
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_VECTOR_TEST_TC001(Hex *ski, Hex *pki, Hex *challenge, Hex *nonce, Hex *blind, Hex *salt,
Hex *request, Hex *response, Hex *token)
{
ref = 0;
TestRandInit();
uint8_t tokenChallengeBuffer[MAX_LEN];
uint32_t tokenChallengeBufferLen = MAX_LEN;
uint8_t tokenRequestBuffer[MAX_LEN];
uint32_t tokenRequestBufferLen = MAX_LEN;
uint8_t tokenResponseBuffer[MAX_LEN];
uint32_t tokenResponseBufferLen = MAX_LEN;
uint8_t finalTokenBuffer[MAX_LEN];
uint32_t finalTokenBufferLen = MAX_LEN;
uint8_t nonceBuff[MAX_LEN];
uint32_t nonceLen = MAX_LEN;
HITLS_AUTH_PrivPassCtx *ctx = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge = NULL;
HITLS_AUTH_PrivPassToken *tokenRequest = NULL;
HITLS_AUTH_PrivPassToken *tokenResponse = NULL;
HITLS_AUTH_PrivPassToken *finalToken = NULL;
g_nonceBuf = (uint8_t *)nonce->x;
g_saltBuf = (uint8_t *)salt->x;
g_nonceLen = nonce->len;
g_saltLen = salt->len;
g_blindBuf = (uint8_t *)blind->x;
g_blindLen = blind->len;
BSL_Param param[2] = {
{AUTH_PARAM_PRIVPASS_TOKEN_NONCE, BSL_PARAM_TYPE_OCTETS_PTR, nonceBuff, nonceLen, 0}, BSL_PARAM_END};
// Create context
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ctx->method.random = STUB_ReplaceRandom;
ASSERT_NE(ctx, NULL);
// Set keys
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(ctx, pki->x, pki->len), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(ctx, NULL, ski->x, ski->len), HITLS_AUTH_SUCCESS);
CRYPT_RandRegist(STUB_ReplaceRandom);
CRYPT_RandRegistEx(STUB_ReplaceRandomWEx);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE, challenge->x, challenge->len,
&tokenChallenge), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, tokenChallenge, tokenChallengeBuffer, &tokenChallengeBufferLen),
HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare tokenchallenge", tokenChallengeBuffer, tokenChallengeBufferLen,
challenge->x, challenge->len);
// Generate token request
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenReq(ctx, tokenChallenge, &tokenRequest), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, tokenRequest, tokenRequestBuffer, &tokenRequestBufferLen),
HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare tokenrequest", tokenRequestBuffer, tokenRequestBufferLen, request->x, request->len);
// Generate token response
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenResponse(ctx, tokenRequest, &tokenResponse), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, tokenResponse, tokenResponseBuffer, &tokenResponseBufferLen),
HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare tokenresponse", tokenResponseBuffer, tokenResponseBufferLen, response->x, response->len);
// Generate final token
ASSERT_EQ(HITLS_AUTH_PrivPassGenToken(ctx, tokenChallenge, tokenResponse, &finalToken), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, finalToken, finalTokenBuffer, &finalTokenBufferLen),
HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare finaltoken", finalTokenBuffer, finalTokenBufferLen, token->x, token->len);
// Verify token
ASSERT_EQ(HITLS_AUTH_PrivPassVerifyToken(ctx, tokenChallenge, finalToken), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(finalToken, HITLS_AUTH_PRIVPASS_GET_TOKEN_NONCE, param, 0),
HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare nonce", param->value, param->useLen, nonce->x, nonce->len);
EXIT:
TestRandDeInit();
HITLS_AUTH_PrivPassFreeToken(tokenChallenge);
HITLS_AUTH_PrivPassFreeToken(tokenRequest);
HITLS_AUTH_PrivPassFreeToken(tokenResponse);
HITLS_AUTH_PrivPassFreeToken(finalToken);
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_CHALLENGE_OBTAIN_TC001
* @spec Private Pass Token Challenge Parameters
* @title Test obtaining and validating token challenge parameters
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_CHALLENGE_OBTAIN_TC001(Hex *challenge)
{
uint8_t tokenChallengeBuffer[MAX_LEN];
uint32_t tokenChallengeBufferLen = MAX_LEN;
uint16_t tokenType;
uint8_t issuerNameBuffer[MAX_LEN];
uint32_t issuerNameBufferLen = MAX_LEN;
uint8_t redemptionBuffer[MAX_LEN];
uint32_t redemptionBufferLen = MAX_LEN;
uint8_t originInfoBuffer[MAX_LEN];
uint32_t originInfoBufferLen = MAX_LEN;
HITLS_AUTH_PrivPassToken *tokenChallenge1 = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge2 = NULL;
HITLS_AUTH_PrivPassCtx *ctx = NULL;
BSL_Param param1[5] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenType, 2, 0},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerNameBuffer,
issuerNameBufferLen, 0},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemptionBuffer,
redemptionBufferLen, 0},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ORIGININFO, BSL_PARAM_TYPE_OCTETS_PTR, originInfoBuffer,
originInfoBufferLen, 0},
BSL_PARAM_END};
BSL_Param param2[5] = {
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_TYPE, BSL_PARAM_TYPE_UINT16, &tokenType, 2, 0},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ISSUERNAME, BSL_PARAM_TYPE_OCTETS_PTR, issuerNameBuffer, 0, 0},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REDEMPTION, BSL_PARAM_TYPE_OCTETS_PTR, redemptionBuffer, 0, 0},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_ORIGININFO, BSL_PARAM_TYPE_OCTETS_PTR, originInfoBuffer, 0, 0},
BSL_PARAM_END};
// Create context
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE, challenge->x, challenge->len,
&tokenChallenge1), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenChallenge1, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGE_TYPE, param1, 0),
HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenChallenge1, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGE_REDEMPTION,
param1, 0),
HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenChallenge1, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGE_ORIGININFO,
param1, 0),
HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenChallenge1, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGE_ISSUERNAME,
param1, 0),
HITLS_AUTH_SUCCESS);
param2[0].valueLen = param1[0].useLen;
param2[1].valueLen = param1[1].useLen;
param2[2].valueLen = param1[2].useLen;
param2[3].valueLen = param1[3].useLen;
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenChallenge(ctx, param2, &tokenChallenge2), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, tokenChallenge2, tokenChallengeBuffer,
&tokenChallengeBufferLen), HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare token challenge", tokenChallengeBuffer, tokenChallengeBufferLen, challenge->x,
challenge->len);
EXIT:
CRYPT_EAL_RandDeinit();
HITLS_AUTH_PrivPassFreeToken(tokenChallenge1);
HITLS_AUTH_PrivPassFreeToken(tokenChallenge2);
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
void *NewPkeyCtxTmp(void *libCtx, int algId)
{
(void)libCtx;
(void)algId;
return NULL;
}
/**
* @test SDV_AUTH_PRIVPASS_TEST_SET_CRYPTO_CB_TC001
* @brief Test setting and validating crypto callback functionality
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TEST_SET_CRYPTO_CB_TC001(Hex *ski, Hex *pki)
{
TestRandInit();
HITLS_AUTH_PrivPassCtx *ctx = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE);
HITLS_AUTH_PrivPassToken *tokenRequest = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_REQUEST);
HITLS_AUTH_PrivPassToken *tokenResponse = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_RESPONSE);
HITLS_AUTH_PrivPassToken *finalToken = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_INSTANCE);
HITLS_AUTH_PrivPassToken *tokenRequest1 = NULL;
HITLS_AUTH_PrivPassToken *tokenResponse1 = NULL;
HITLS_AUTH_PrivPassToken *finalToken1 = NULL;
CRYPT_EAL_PkeyCtx *pkeyCtx = NULL;
ASSERT_NE(tokenChallenge, NULL);
ASSERT_NE(tokenRequest, NULL);
ASSERT_NE(tokenResponse, NULL);
ASSERT_NE(finalToken, NULL);
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(ctx, pki->x, pki->len), 0);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(ctx, NULL, ski->x, ski->len), 0);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenReq(ctx, tokenChallenge, &tokenRequest1),
HITLS_AUTH_PRIVPASS_INVALID_TOKEN_TYPE);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenResponse(ctx, tokenRequest, &tokenResponse1),
HITLS_AUTH_PRIVPASS_INVALID_TOKEN_TYPE);
ASSERT_EQ(HITLS_AUTH_PrivPassGenToken(ctx, tokenChallenge, tokenResponse, &finalToken1),
HITLS_AUTH_PRIVPASS_INVALID_TOKEN_TYPE);
ASSERT_EQ(HITLS_AUTH_PrivPassVerifyToken(ctx, tokenChallenge, finalToken), HITLS_AUTH_PRIVPASS_INVALID_TOKEN_TYPE);
pkeyCtx = ctx->method.newPkeyCtx(NULL, NULL, HITLS_AUTH_PRIVPASS_CRYPTO_RSA);
ASSERT_NE(pkeyCtx, NULL);
ASSERT_EQ(CRYPT_EAL_PkeyGetId(pkeyCtx), CRYPT_PKEY_RSA);
ctx->method.freePkeyCtx(pkeyCtx);
pkeyCtx = NULL;
ASSERT_EQ(HITLS_AUTH_PrivPassSetCryptCb(ctx, HITLS_AUTH_PRIVPASS_NEW_PKEY_CTX_CB - 1, NewPkeyCtxTmp),
HITLS_AUTH_PRIVPASS_INVALID_CRYPTO_CALLBACK_TYPE);
ASSERT_EQ(HITLS_AUTH_PrivPassSetCryptCb(ctx, HITLS_AUTH_PRIVPASS_NEW_PKEY_CTX_CB, NewPkeyCtxTmp),
HITLS_AUTH_SUCCESS);
pkeyCtx = ctx->method.newPkeyCtx(NULL, NULL, HITLS_AUTH_PRIVPASS_CRYPTO_RSA);
ASSERT_EQ(pkeyCtx, NULL);
EXIT:
HITLS_AUTH_PrivPassFreeCtx(ctx);
HITLS_AUTH_PrivPassFreeToken(tokenChallenge);
HITLS_AUTH_PrivPassFreeToken(tokenRequest);
HITLS_AUTH_PrivPassFreeToken(tokenResponse);
HITLS_AUTH_PrivPassFreeToken(finalToken);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_SET_KEY_TC001
* @brief Test case for setting public and private keys in PrivPass context
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_SET_KEY_TC001(Hex *ski, Hex *pki)
{
TestRandInit();
HITLS_AUTH_PrivPassCtx *ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
// Test NULL pointer parameters
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(NULL, pki->x, pki->len), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(ctx, NULL, pki->len), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(NULL, NULL, ski->x, ski->len), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(ctx, NULL, NULL, ski->len), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
// Test zero length
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(ctx, pki->x, 0), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(ctx, NULL, ski->x, 0), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
// Test duplicate key setting
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(ctx, pki->x, pki->len), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(ctx, pki->x, pki->len), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(ctx, NULL, ski->x, ski->len), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(ctx, NULL, ski->x, ski->len), HITLS_AUTH_SUCCESS);
ctx->method.checkKeyPair = NULL;
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(ctx, NULL, ski->x, ski->len), HITLS_AUTH_PRIVPASS_NO_KEYPAIR_CHECK_CALLBACK);
EXIT:
HITLS_AUTH_PrivPassFreeCtx(ctx);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_SET_KEY_TC002
* @brief Test case for validating that mismatched public/private key pairs are rejected
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_SET_KEY_TC002()
{
TestRandInit();
uint8_t e[] = {1, 0, 1};
BSL_Buffer pubBuffer = {0};
BSL_Buffer prvBuffer = {0};
CRYPT_EAL_PkeyPara para = {0};
HITLS_AUTH_PrivPassCtx *ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
CRYPT_EAL_PkeyCtx *pkey1 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_RSA);
CRYPT_EAL_PkeyCtx *pkey2 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_RSA);
CRYPT_MD_AlgId mdId = CRYPT_MD_SHA384;
uint32_t saltLen = 0;
BSL_Param pssParam[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &saltLen, sizeof(saltLen), 0}, BSL_PARAM_END};
ASSERT_NE(ctx, NULL);
ASSERT_NE(pkey1, NULL);
ASSERT_NE(pkey2, NULL);
para.id = CRYPT_PKEY_RSA;
para.para.rsaPara.e = e;
para.para.rsaPara.eLen = 3;
para.para.rsaPara.bits = 2048;
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey1, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeySetPara(pkey2, ¶), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey1), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_PkeyGen(pkey2), CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey1, CRYPT_CTRL_SET_RSA_EMSA_PSS, &pssParam, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_PkeyCtrl(pkey2, CRYPT_CTRL_SET_RSA_EMSA_PSS, &pssParam, 0) == CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkey1, NULL, BSL_FORMAT_ASN1, CRYPT_PUBKEY_SUBKEY, &pubBuffer), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_EncodeBuffKey(pkey2, NULL, BSL_FORMAT_PEM, CRYPT_PRIKEY_PKCS8_UNENCRYPT, &prvBuffer),
CRYPT_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(ctx, pubBuffer.data, pubBuffer.dataLen), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(ctx, NULL, prvBuffer.data, prvBuffer.dataLen),
HITLS_AUTH_PRIVPASS_CHECK_KEYPAIR_FAILED);
HITLS_AUTH_PrivPassFreeCtx(ctx);
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPrvkey(ctx, NULL, prvBuffer.data, prvBuffer.dataLen),
HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(ctx, pubBuffer.data, pubBuffer.dataLen),
HITLS_AUTH_PRIVPASS_CHECK_KEYPAIR_FAILED);
EXIT:
BSL_SAL_Free(pubBuffer.data);
BSL_SAL_Free(prvBuffer.data);
HITLS_AUTH_PrivPassFreeCtx(ctx);
CRYPT_EAL_PkeyFreeCtx(pkey1);
CRYPT_EAL_PkeyFreeCtx(pkey2);
TestRandDeInit();
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_GEN_INVALID_TC001
* @spec Private Pass Token Generation Invalid Cases
* @title Test token generation process with invalid parameters and states
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_INVALID_INTERACTION_TC001()
{
HITLS_AUTH_PrivPassCtx *ctx = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge = NULL;
HITLS_AUTH_PrivPassToken *tokenRequest = NULL;
HITLS_AUTH_PrivPassToken *tokenResponse = NULL;
HITLS_AUTH_PrivPassToken *finalToken = NULL;
TestRandInit();
// Test with NULL context
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenReq(NULL, tokenChallenge, &tokenRequest), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenResponse(NULL, tokenRequest, &tokenResponse),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenToken(NULL, tokenChallenge, tokenResponse, &finalToken),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassVerifyToken(NULL, tokenChallenge, finalToken), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
// Create context but don't set keys
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenReq(ctx, tokenChallenge, &tokenRequest), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenResponse(ctx, tokenRequest, &tokenResponse),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenToken(ctx, tokenChallenge, tokenResponse, &finalToken),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassVerifyToken(ctx, tokenChallenge, finalToken), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
// Test with NULL tokens
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenReq(ctx, NULL, &tokenRequest), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenResponse(ctx, NULL, &tokenResponse), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenToken(ctx, NULL, tokenResponse, &finalToken), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassVerifyToken(ctx, NULL, finalToken), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
EXIT:
TestRandDeInit();
HITLS_AUTH_PrivPassFreeToken(tokenChallenge);
HITLS_AUTH_PrivPassFreeToken(tokenRequest);
HITLS_AUTH_PrivPassFreeToken(tokenResponse);
HITLS_AUTH_PrivPassFreeToken(finalToken);
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_GEN_INVALID_TC001
* @brief Test case to verify error handling for invalid PrivPass token interactions
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_INVALID_INTERACTION_TC002(Hex *challenge, Hex *request, Hex *response, Hex *token)
{
TestRandInit();
HITLS_AUTH_PrivPassCtx *ctx = NULL;
HITLS_AUTH_PrivPassToken *tokenChallenge = NULL;
HITLS_AUTH_PrivPassToken *tokenRequest = NULL;
HITLS_AUTH_PrivPassToken *tokenResponse = NULL;
HITLS_AUTH_PrivPassToken *finalToken = NULL;
HITLS_AUTH_PrivPassToken *tokenRequest1 = NULL;
HITLS_AUTH_PrivPassToken *tokenResponse1 = NULL;
HITLS_AUTH_PrivPassToken *finalToken1 = NULL;
// Create a new PrivPass context
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE, challenge->x, challenge->len,
&tokenChallenge), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_REQUEST, request->x, request->len,
&tokenRequest), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_RESPONSE, response->x, response->len,
&tokenResponse), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_INSTANCE, token->x, token->len,
&finalToken), HITLS_AUTH_SUCCESS);
// The entered token object does not match the expected value
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenReq(ctx, finalToken, &tokenRequest), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenResponse(ctx, finalToken, &tokenResponse), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenToken(ctx, tokenResponse, tokenResponse, &finalToken),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenToken(ctx, tokenChallenge, tokenChallenge, &finalToken),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassVerifyToken(ctx, tokenResponse, finalToken), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
// When the output != NULL
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenReq(ctx, tokenChallenge, &tokenRequest), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenResponse(ctx, tokenRequest, &tokenResponse),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassGenToken(ctx, tokenChallenge, tokenResponse, &finalToken),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
// There is no key info
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenReq(ctx, tokenChallenge, &tokenRequest1), HITLS_AUTH_PRIVPASS_NO_PUBKEY_INFO);
ASSERT_EQ(HITLS_AUTH_PrivPassGenTokenResponse(ctx, tokenRequest, &tokenResponse1),
HITLS_AUTH_PRIVPASS_NO_PRVKEY_INFO);
ASSERT_EQ(HITLS_AUTH_PrivPassGenToken(ctx, tokenChallenge, tokenResponse, &finalToken1),
HITLS_AUTH_PRIVPASS_NO_PUBKEY_INFO);
ASSERT_EQ(HITLS_AUTH_PrivPassVerifyToken(ctx, tokenChallenge, finalToken), HITLS_AUTH_PRIVPASS_NO_PUBKEY_INFO);
EXIT:
TestRandDeInit();
HITLS_AUTH_PrivPassFreeToken(tokenChallenge);
HITLS_AUTH_PrivPassFreeToken(tokenRequest);
HITLS_AUTH_PrivPassFreeToken(tokenResponse);
HITLS_AUTH_PrivPassFreeToken(finalToken);
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_CHALLENGEREQUEST_OBTAIN_TC001
* @spec Private Pass Token challenge Request Parameters
* @title Test obtaining and validating token challenge request parameters obtain
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_CHALLENGEREQUEST_OBTAIN_TC001(Hex *challRequest)
{
uint8_t challengeRequestBuffer[MAX_LEN];
HITLS_AUTH_PrivPassToken *challengeRequest = NULL;
HITLS_AUTH_PrivPassCtx *ctx = NULL;
BSL_Param param[3] = {
{AUTH_PARAM_PRIVPASS_TOKEN, BSL_PARAM_TYPE_OCTETS_PTR, challengeRequestBuffer,
MAX_LEN, MAX_LEN},
{AUTH_PARAM_PRIVPASS_TOKENCHALLENGE_REQUEST, BSL_PARAM_TYPE_OCTETS_PTR, challengeRequestBuffer,
MAX_LEN, MAX_LEN},
BSL_PARAM_END};
// Create context
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE_REQUEST, challRequest->x,
challRequest->len, &challengeRequest), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(challengeRequest, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGEREQUEST_INFO,
param, 0), HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare token challenge request", challengeRequestBuffer, param[1].useLen, challRequest->x,
challRequest->len);
EXIT:
HITLS_AUTH_PrivPassFreeToken(challengeRequest);
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_REQUEST_OBTAIN_TC001
* @spec Private Pass Token challenge Request Parameters
* @title Test obtaining and validating token challenge request parameters obtain
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_REQUEST_OBTAIN_TC001(Hex *request)
{
uint8_t tokenRequestBuffer[MAX_LEN];
uint32_t tokenRequestBufferLen = MAX_LEN;
uint16_t tokenType;
uint8_t truncatedTokenKeyId;
uint8_t blindedMsgBuffer[MAX_LEN];
uint32_t blindedMsgBufferLen = MAX_LEN;
HITLS_AUTH_PrivPassToken *tokenRequest1 = NULL;
HITLS_AUTH_PrivPassToken *tokenRequest2 = NULL;
HITLS_AUTH_PrivPassCtx *ctx = NULL;
PrivPass_TokenRequest *tmpRequest = NULL;
BSL_Param param[4] = {
{AUTH_PARAM_PRIVPASS_TOKENREQUEST_BLINDEDMSG, BSL_PARAM_TYPE_OCTETS_PTR, blindedMsgBuffer, blindedMsgBufferLen, 0},
{AUTH_PARAM_PRIVPASS_TOKENREQUEST_TRUNCATEDTOKENKEYID, BSL_PARAM_TYPE_UINT8, &truncatedTokenKeyId, 1, 0},
{AUTH_PARAM_PRIVPASS_TOKENREQUEST_TYPE, BSL_PARAM_TYPE_UINT16, &tokenType, 2, 0},
BSL_PARAM_END
};
// Create context
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_TRUE(ctx != NULL);
// Deserialize the request
ASSERT_TRUE(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_REQUEST, request->x, request->len,
&tokenRequest1) == HITLS_AUTH_SUCCESS);
// Extract parameters
ASSERT_TRUE(HITLS_AUTH_PrivPassTokenCtrl(tokenRequest1, HITLS_AUTH_PRIVPASS_GET_TOKENREQUEST_TYPE, param, 0)
== HITLS_AUTH_SUCCESS);
ASSERT_TRUE(HITLS_AUTH_PrivPassTokenCtrl(tokenRequest1, HITLS_AUTH_PRIVPASS_GET_TOKENREQUEST_TRUNCATEDTOKENKEYID,
param, 0) == HITLS_AUTH_SUCCESS);
ASSERT_TRUE(HITLS_AUTH_PrivPassTokenCtrl(tokenRequest1, HITLS_AUTH_PRIVPASS_GET_TOKENREQUEST_BLINDEDMSG, param,
0) == HITLS_AUTH_SUCCESS);
// Create new token request
tokenRequest2 = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_REQUEST);
tmpRequest = tokenRequest2->st.tokenRequest;
tmpRequest->tokenType = tokenType;
tmpRequest->truncatedTokenKeyId = truncatedTokenKeyId;
tmpRequest->blindedMsg.data = blindedMsgBuffer;
tmpRequest->blindedMsg.dataLen = param[0].useLen;
// Serialize and compare
ASSERT_TRUE(HITLS_AUTH_PrivPassSerialization(ctx, tokenRequest2, tokenRequestBuffer, &tokenRequestBufferLen)
== HITLS_AUTH_SUCCESS);
ASSERT_TRUE(memcmp(tokenRequestBuffer, request->x, request->len) == 0);
ASSERT_COMPARE("compare token request", tokenRequestBuffer, tokenRequestBufferLen, request->x, request->len);
EXIT:
tmpRequest->blindedMsg.data = NULL;
HITLS_AUTH_PrivPassFreeToken(tokenRequest1);
HITLS_AUTH_PrivPassFreeToken(tokenRequest2);
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_INSTANCE_OBTAIN_TC001
* @spec Private Pass Token Instance Parameters
* @title Test obtaining and validating token instance parameters
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_INSTANCE_OBTAIN_TC001(Hex *token)
{
uint8_t tokenInstanceBuffer[MAX_LEN];
uint32_t tokenInstanceBufferLen = MAX_LEN;
uint16_t tokenType;
uint8_t nonceBuffer[MAX_LEN];
uint32_t nonceBufferLen = MAX_LEN;
uint8_t challengeDigestBuffer[MAX_LEN];
uint32_t challengeDigestBufferLen = MAX_LEN;
uint8_t tokenKeyIdBuffer[MAX_LEN];
uint32_t tokenKeyIdBufferLen = MAX_LEN;
uint8_t authenticatorBuffer[MAX_LEN];
uint32_t authenticatorBufferLen = MAX_LEN;
HITLS_AUTH_PrivPassToken *tokenInstance1 = NULL;
HITLS_AUTH_PrivPassToken *tokenInstance2 = NULL;
HITLS_AUTH_PrivPassCtx *ctx = NULL;
PrivPass_TokenInstance *tmpToken = NULL;
BSL_Param param[6] = {
{AUTH_PARAM_PRIVPASS_TOKEN_NONCE, BSL_PARAM_TYPE_OCTETS_PTR, nonceBuffer, nonceBufferLen, 0},
{AUTH_PARAM_PRIVPASS_TOKEN_AUTHENTICATOR, BSL_PARAM_TYPE_OCTETS_PTR, authenticatorBuffer,
authenticatorBufferLen, 0},
{AUTH_PARAM_PRIVPASS_TOKEN_TYPE, BSL_PARAM_TYPE_UINT16, &tokenType, 2, 0},
{AUTH_PARAM_PRIVPASS_TOKEN_CHALLENGEDIGEST, BSL_PARAM_TYPE_OCTETS_PTR, challengeDigestBuffer,
challengeDigestBufferLen, 0},
{AUTH_PARAM_PRIVPASS_TOKEN_TOKENKEYID, BSL_PARAM_TYPE_OCTETS_PTR, tokenKeyIdBuffer, tokenKeyIdBufferLen, 0},
BSL_PARAM_END
};
// Create context
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
// Deserialize the token instance
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_INSTANCE, token->x, token->len,
&tokenInstance1), HITLS_AUTH_SUCCESS);
// Extract parameters
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenInstance1, HITLS_AUTH_PRIVPASS_GET_TOKEN_TYPE, param, 0),
HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenInstance1, HITLS_AUTH_PRIVPASS_GET_TOKEN_NONCE, param, 0),
HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenInstance1, HITLS_AUTH_PRIVPASS_GET_TOKEN_CHALLENGEDIGEST, param, 0),
HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenInstance1, HITLS_AUTH_PRIVPASS_GET_TOKEN_TOKENKEYID, param, 0),
HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenInstance1, HITLS_AUTH_PRIVPASS_GET_TOKEN_AUTHENTICATOR, param, 0),
HITLS_AUTH_SUCCESS);
// Create new token instance
tokenInstance2 = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_INSTANCE);
tmpToken = tokenInstance2->st.token;
tmpToken->tokenType = tokenType;
(void)memcpy_s(tmpToken->nonce, param[0].useLen, nonceBuffer, param[0].useLen);
(void)memcpy_s(tmpToken->challengeDigest, param[3].useLen, challengeDigestBuffer, param[3].useLen);
(void)memcpy_s(tmpToken->tokenKeyId, param[4].useLen, tokenKeyIdBuffer, param[4].useLen);
tmpToken->authenticator.data = authenticatorBuffer;
tmpToken->authenticator.dataLen = param[1].useLen;
// Serialize and compare
ASSERT_EQ(HITLS_AUTH_PrivPassSerialization(ctx, tokenInstance2, tokenInstanceBuffer, &tokenInstanceBufferLen),
HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare token instance", tokenInstanceBuffer, tokenInstanceBufferLen, token->x, token->len);
EXIT:
tmpToken->authenticator.data = NULL;
HITLS_AUTH_PrivPassFreeToken(tokenInstance1);
HITLS_AUTH_PrivPassFreeToken(tokenInstance2);
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_RESPONSE_OBTAIN_TC001
* @spec Private Pass Token Response Parameters
* @title Test obtaining and validating token response parameters obtain
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_RESPONSE_OBTAIN_TC001(Hex *response)
{
uint8_t responseBuffer[MAX_LEN];
uint32_t responseBufferLen = MAX_LEN;
HITLS_AUTH_PrivPassToken *responseToken = NULL;
HITLS_AUTH_PrivPassCtx *ctx = NULL;
BSL_Param param[3] = {
{AUTH_PARAM_PRIVPASS_TOKEN, BSL_PARAM_TYPE_OCTETS_PTR, responseBuffer, responseBufferLen, 0},
{AUTH_PARAM_PRIVPASS_TOKENRESPONSE_INFO, BSL_PARAM_TYPE_OCTETS_PTR, responseBuffer, responseBufferLen, 0},
BSL_PARAM_END};
// Create context
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassDeserialization(ctx, HITLS_AUTH_PRIVPASS_TOKEN_RESPONSE, response->x,
response->len, &responseToken), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(responseToken, HITLS_AUTH_PRIVPASS_GET_TOKENRESPONSE_INFO, param, 0),
HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare token response", responseBuffer, param[1].useLen, response->x,
response->len);
EXIT:
HITLS_AUTH_PrivPassFreeToken(responseToken);
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_TOKEN_CTRL_INVALIED_TEST_TC001
* @spec Private Pass Token Ctrl Invalid Test
* @title Test obtaining and validating token ctrl invalid test
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_TOKEN_CTRL_INVALIED_TEST_TC001()
{
uint8_t buffer[MAX_LEN];
uint32_t bufferLen = MAX_LEN;
BSL_Param param[4] = {
{AUTH_PARAM_PRIVPASS_TOKENREQUEST_BLINDEDMSG, BSL_PARAM_TYPE_OCTETS_PTR, buffer, bufferLen, 0},
{AUTH_PARAM_PRIVPASS_TOKENRESPONSE_INFO, BSL_PARAM_TYPE_OCTETS_PTR, buffer, bufferLen, 0},
{AUTH_PARAM_PRIVPASS_TOKEN_AUTHENTICATOR, BSL_PARAM_TYPE_OCTETS_PTR, buffer, bufferLen, 0},
BSL_PARAM_END};
HITLS_AUTH_PrivPassToken *tokenChallReq = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE_REQUEST);
HITLS_AUTH_PrivPassToken *tokenChallenge = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE);
HITLS_AUTH_PrivPassToken *tokenRequest = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_REQUEST);
HITLS_AUTH_PrivPassToken *tokenResponse = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_RESPONSE);
HITLS_AUTH_PrivPassToken *tokenInstance = HITLS_AUTH_PrivPassNewToken(HITLS_AUTH_PRIVPASS_TOKEN_INSTANCE);
ASSERT_TRUE(tokenChallReq != NULL);
ASSERT_TRUE(tokenChallenge != NULL);
ASSERT_TRUE(tokenRequest != NULL);
ASSERT_TRUE(tokenResponse != NULL);
ASSERT_TRUE(tokenInstance != NULL);
// for test invailed token challenge request
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(NULL, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGEREQUEST_INFO, param, 0),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenChallReq, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGEREQUEST_INFO, NULL, 0),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenChallReq, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGEREQUEST_INFO, param, 0),
HITLS_AUTH_PRIVPASS_NO_TOKEN_CHALLENGE_REQUEST);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenChallenge, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGEREQUEST_INFO, param,
0), HITLS_AUTH_PRIVPASS_INVALID_INPUT);
// for test invailed token challenge
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenChallenge, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGE_TYPE, NULL, 0),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenChallenge, HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGE_ISSUERNAME, param, 0),
HITLS_AUTH_PRIVPASS_NO_ISSUERNAME);
// for test invailed token request
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenRequest, HITLS_AUTH_PRIVPASS_GET_TOKENREQUEST_TYPE, NULL, 0),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenRequest, HITLS_AUTH_PRIVPASS_GET_TOKENREQUEST_BLINDEDMSG, param, 0),
HITLS_AUTH_PRIVPASS_NO_BLINDEDMSG);
// for test invailed token response
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(NULL, HITLS_AUTH_PRIVPASS_GET_TOKENRESPONSE_INFO, param, 0),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenResponse, HITLS_AUTH_PRIVPASS_GET_TOKENRESPONSE_INFO, param, 0),
HITLS_AUTH_PRIVPASS_NO_RESPONSE_INFO);
// for test invailed token
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(NULL, HITLS_AUTH_PRIVPASS_GET_TOKEN_TYPE, param, 0),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassTokenCtrl(tokenInstance, HITLS_AUTH_PRIVPASS_GET_TOKEN_AUTHENTICATOR, param, 0),
HITLS_AUTH_PRIVPASS_NO_AUTHENTICATOR);
EXIT:
HITLS_AUTH_PrivPassFreeToken(tokenChallReq);
HITLS_AUTH_PrivPassFreeToken(tokenChallenge);
HITLS_AUTH_PrivPassFreeToken(tokenRequest);
HITLS_AUTH_PrivPassFreeToken(tokenResponse);
HITLS_AUTH_PrivPassFreeToken(tokenInstance);
}
/* END_CASE */
/**
* @test SDV_AUTH_PRIVPASS_CTX_DATA_OBTAIN_TC001
* @spec Private Pass ctx data obtain
* @title Test obtaining and validating ctx data obtain
*/
/* BEGIN_CASE */
void SDV_AUTH_PRIVPASS_CTX_DATA_OBTAIN_TC001(Hex *pki, Hex *nonce)
{
uint8_t nonceBuffer[MAX_LEN];
uint32_t nonceBufferLen = MAX_LEN;
uint8_t truncatedTokenKeyId;
uint8_t tokenKeyIdBuffer[MAX_LEN];
uint32_t tokenKeyIdBufferLen = MAX_LEN;
uint8_t hashBuffer[PRIVPASS_TOKEN_SHA256_SIZE];
uint32_t hashBufferLen = PRIVPASS_TOKEN_SHA256_SIZE;
HITLS_AUTH_PrivPassCtx *ctx = NULL;
BSL_Param param[4] = {
{AUTH_PARAM_PRIVPASS_CTX_NONCE, BSL_PARAM_TYPE_OCTETS_PTR, nonceBuffer, nonceBufferLen, 0},
{AUTH_PARAM_PRIVPASS_CTX_TOKENKEYID, BSL_PARAM_TYPE_OCTETS_PTR, tokenKeyIdBuffer, tokenKeyIdBufferLen, 0},
{AUTH_PARAM_PRIVPASS_CTX_TRUNCATEDTOKENKEYID, BSL_PARAM_TYPE_UINT8, &truncatedTokenKeyId, 1, 0},
BSL_PARAM_END
};
ctx = HITLS_AUTH_PrivPassNewCtx(HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS);
ASSERT_NE(ctx, NULL);
ASSERT_EQ(HITLS_AUTH_PrivPassCtxCtrl(NULL, HITLS_AUTH_PRIVPASS_GET_CTX_TOKENKEYID, param, 0),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassCtxCtrl(ctx, HITLS_AUTH_PRIVPASS_GET_CTX_TOKENKEYID, NULL, 0),
HITLS_AUTH_PRIVPASS_INVALID_INPUT);
ASSERT_EQ(HITLS_AUTH_PrivPassCtxCtrl(ctx, HITLS_AUTH_PRIVPASS_GET_CTX_TOKENKEYID, param, 0),
HITLS_AUTH_PRIVPASS_NO_PUBKEY_INFO);
ASSERT_EQ(HITLS_AUTH_PrivPassCtxCtrl(ctx, HITLS_AUTH_PRIVPASS_GET_CTX_TRUNCATEDTOKENKEYID, param, 0),
HITLS_AUTH_PRIVPASS_NO_PUBKEY_INFO);
ASSERT_EQ(HITLS_AUTH_PrivPassSetPubkey(ctx, pki->x, pki->len), HITLS_AUTH_SUCCESS);
(void)memcpy_s(ctx->nonce, nonce->len, nonce->x, nonce->len);
ASSERT_EQ(HITLS_AUTH_PrivPassCtxCtrl(ctx, HITLS_AUTH_PRIVPASS_GET_CTX_NONCE, param, 0), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassCtxCtrl(ctx, HITLS_AUTH_PRIVPASS_GET_CTX_TOKENKEYID, param, 0), HITLS_AUTH_SUCCESS);
ASSERT_EQ(HITLS_AUTH_PrivPassCtxCtrl(ctx, HITLS_AUTH_PRIVPASS_GET_CTX_TRUNCATEDTOKENKEYID, param, 0),
HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare ctx nonce", nonceBuffer, param[0].useLen, nonce->x, nonce->len);
ASSERT_EQ(EAL_Md(CRYPT_MD_SHA256, NULL, NULL, pki->x, pki->len, hashBuffer, &hashBufferLen), HITLS_AUTH_SUCCESS);
ASSERT_COMPARE("compare token key id", hashBuffer, hashBufferLen, tokenKeyIdBuffer, param[1].useLen);
ASSERT_EQ(truncatedTokenKeyId, hashBuffer[PRIVPASS_TOKEN_SHA256_SIZE - 1]);
EXIT:
HITLS_AUTH_PrivPassFreeCtx(ctx);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/auth/privpass_token/test_suite_sdv_privpass_token.c
|
C
|
unknown
| 56,548
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include "bsl_sal.h"
#include "bsl_asn1_internal.h"
#include "bsl_err.h"
#include "bsl_log.h"
#include "sal_time.h"
#include "sal_file.h"
#include "bsl_obj_internal.h"
#include "hitls_x509_local.h"
/* END_HEADER */
/* They are placed in their respective implementations and belong to specific applications, not asn1 modules */
#define BSL_ASN1_CTX_SPECIFIC_TAG_VER 0
#define BSL_ASN1_CTX_SPECIFIC_TAG_ISSUERID 1
#define BSL_ASN1_CTX_SPECIFIC_TAG_SUBJECTID 2
#define BSL_ASN1_CTX_SPECIFIC_TAG_EXTENSION 3
BSL_ASN1_TemplateItem certTempl[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0}, /* x509 */
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1}, /* tbs */
/* 2: version */
{BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_CTX_SPECIFIC_TAG_VER, BSL_ASN1_FLAG_DEFAULT, 2},
{BSL_ASN1_TAG_INTEGER, 0, 3},
/* 2: serial number */
{BSL_ASN1_TAG_INTEGER, 0, 2},
/* 2: signature info */
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 2},
{BSL_ASN1_TAG_OBJECT_ID, 0, 3},
{BSL_ASN1_TAG_ANY, BSL_ASN1_FLAG_OPTIONAL, 3}, // 8
/* 2: issuer */
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_HEADERONLY | BSL_ASN1_FLAG_SAME, 2},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SET, BSL_ASN1_FLAG_SAME, 3},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 4},
{BSL_ASN1_TAG_OBJECT_ID, 0, 5},
{BSL_ASN1_TAG_ANY, 0, 5},
/* 2: validity */
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 2},
{BSL_ASN1_TAG_CHOICE, 0, 3},
{BSL_ASN1_TAG_CHOICE, 0, 3}, // 16
/* 2: subject ref: issuer */
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_HEADERONLY | BSL_ASN1_FLAG_SAME, 2},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SET, BSL_ASN1_FLAG_SAME, 3},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 4},
{BSL_ASN1_TAG_OBJECT_ID, 0, 5},
{BSL_ASN1_TAG_ANY, 0, 5},
/* 2: subject public key info ref signature info */
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 2},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 3},
{BSL_ASN1_TAG_OBJECT_ID, 0, 4},
{BSL_ASN1_TAG_ANY, BSL_ASN1_FLAG_OPTIONAL, 4}, // 25
{BSL_ASN1_TAG_BITSTRING, 0, 3},
/* 2: issuer id, subject id */
{BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_CTX_SPECIFIC_TAG_ISSUERID, BSL_ASN1_FLAG_OPTIONAL, 2},
{BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_CTX_SPECIFIC_TAG_SUBJECTID, BSL_ASN1_FLAG_OPTIONAL, 2},
/* 2: extension */
{BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_CTX_SPECIFIC_TAG_EXTENSION,
BSL_ASN1_FLAG_OPTIONAL | BSL_ASN1_FLAG_HEADERONLY | BSL_ASN1_FLAG_SAME, 2},
{BSL_ASN1_TAG_OBJECT_ID, 0, 3},
{BSL_ASN1_TAG_BOOLEAN, BSL_ASN1_FLAG_DEFAULT, 3},
{BSL_ASN1_TAG_OCTETSTRING, 0, 3},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1}, /* signAlg */
{BSL_ASN1_TAG_OBJECT_ID, 0, 2},
{BSL_ASN1_TAG_ANY, BSL_ASN1_FLAG_OPTIONAL, 2}, // 35
{BSL_ASN1_TAG_BITSTRING, 0, 1} /* sig */
};
BSL_ASN1_TemplateItem maxDepthTempl[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 7},
};
#ifdef HITLS_BSL_SAL_FILE
static BSL_ASN1_TemplateItem g_rsaPub[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0}, /* ignore seq */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* n */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* e */
};
static BSL_ASN1_TemplateItem g_rsaPrv[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0}, /* ignore seq header */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* version */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* n */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* e */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* d */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* p */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* q */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* d mod (p-1) */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* d mod (q-1) */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* q^-1 mod p */
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE,
BSL_ASN1_FLAG_OPTIONAL | BSL_ASN1_FLAG_HEADERONLY | BSL_ASN1_FLAG_SAME, 1}, /* OtherPrimeInfos OPTIONAL */
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 2}, /* OtherPrimeInfo */
{BSL_ASN1_TAG_INTEGER, 0, 3}, /* ri */
{BSL_ASN1_TAG_INTEGER, 0, 3}, /* di */
{BSL_ASN1_TAG_INTEGER, 0, 3} /* ti */
};
typedef struct {
BSL_ASN1_TemplateItem *items;
uint32_t itemNum;
uint32_t asnNum;
} TestAsn1Param;
static TestAsn1Param g_tests[] = {
{g_rsaPub, sizeof(g_rsaPub) / sizeof(g_rsaPub[0]), 2},
{g_rsaPrv, sizeof(g_rsaPrv) / sizeof(g_rsaPrv[0]), 10},
};
#endif
typedef enum {
BSL_ASN1_TAG_VERSION_IDX = 0,
BSL_ASN1_TAG_SERIAL_IDX = 1,
BSL_ASN1_TAG_SIGNINFO_OID_IDX = 2,
BSL_ASN1_TAG_SIGNINFO_ANY_IDX = 3,
BSL_ASN1_TAG_ISSUER_IDX = 4,
BSL_ASN1_TAG_BEFORE_VALID_IDX = 5,
BSL_ASN1_TAG_AFTER_VALID_IDX = 6,
BSL_ASN1_TAG_SUBJECT_IDX = 7,
BSL_ASN1_TAG_SUBKEYINFO_IDX = 8,
BSL_ASN1_TAG_SUBKEYINFO_ANY_IDX = 9,
BSL_ASN1_TAG_SUBKEYINFO_BITSTRING_IDX = 10,
BSL_ASN1_TAG_ISSUERID_IDX = 11,
BSL_ASN1_TAG_SUBJECTID_IDX = 12,
BSL_ASN1_TAG_EXT_IDX = 13,
BSL_ASN1_TAG_SIGNALG_IDX = 14,
BSL_ASN1_TAG_SIGNALG_ANY_IDX = 15,
BSL_ASN1_TAG_SIGN_IDX = 16
} CERT_TEMPL_IDX;
#define BSL_ASN1_TIME_UTC_1 14
#define BSL_ASN1_TIME_UTC_2 15
#define BSL_ASN1_ID_ANY_1 7
#define BSL_ASN1_ID_ANY_2 24
#define BSL_ASN1_ID_ANY_3 34
char *g_oidEcc = "\x2a\x86\x48\xce\x3d\x02\01";
char *g_oidRsaPss = "\x2a\x86\x48\x86\xf7\x0d\x01\x01\x0a";
int32_t BSL_ASN1_CertTagGetOrCheck(int32_t type, uint32_t idx, void *data, void *expVal)
{
BSL_ASN1_Buffer *param = NULL;
uint32_t len = 0;
switch (type) {
case BSL_ASN1_TYPE_CHECK_CHOICE_TAG:
if (idx == BSL_ASN1_TIME_UTC_1 || idx == BSL_ASN1_TIME_UTC_2) {
uint8_t tag = *(uint8_t *) data;
if ((tag & BSL_ASN1_TAG_UTCTIME) || (tag & BSL_ASN1_TAG_GENERALIZEDTIME)) {
*(uint8_t *) expVal = tag;
return BSL_SUCCESS;
}
}
return BSL_ASN1_FAIL;
case BSL_ASN1_TYPE_GET_ANY_TAG:
param = (BSL_ASN1_Buffer *) data;
len = param->len;
if (idx == BSL_ASN1_ID_ANY_1 || idx == BSL_ASN1_ID_ANY_3) {
if (strlen(g_oidRsaPss) == len && memcmp(param->buff, g_oidRsaPss, len) == 0) {
// note: any It can be encoded empty or it can be null
*(uint8_t *) expVal = BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE;
return BSL_SUCCESS;
} else {
*(uint8_t *) expVal = BSL_ASN1_TAG_NULL; // is null
return BSL_SUCCESS;
}
}
if (idx == BSL_ASN1_ID_ANY_2) {
if (strlen(g_oidEcc) == len && memcmp(param->buff, g_oidEcc, len) == 0) {
// note: any It can be encoded empty or it can be null
*(uint8_t *) expVal = BSL_ASN1_TAG_OBJECT_ID;
return BSL_SUCCESS;
} else { //
*(uint8_t *) expVal = BSL_ASN1_TAG_NULL; // is null
return BSL_SUCCESS;
}
}
return BSL_ASN1_FAIL;
default:
break;
}
return BSL_ASN1_FAIL;
}
#ifdef HITLS_BSL_SAL_FILE
static int32_t ReadCert(const char *path, uint8_t **buff, uint32_t *len)
{
size_t readLen;
size_t fileLen = 0;
int32_t ret = BSL_SAL_FileLength(path, &fileLen);
if (ret != BSL_SUCCESS) {
return ret;
}
bsl_sal_file_handle stream = NULL;
ret = BSL_SAL_FileOpen(&stream, path, "rb");
if (ret != BSL_SUCCESS) {
return ret;
}
uint8_t *fileBuff = BSL_SAL_Malloc(fileLen);
if (fileBuff == NULL) {
BSL_SAL_FileClose(stream);
return BSL_MALLOC_FAIL;
}
do {
ret = BSL_SAL_FileRead(stream, fileBuff, 1, fileLen, &readLen);
BSL_SAL_FileClose(stream);
if (ret != BSL_SUCCESS) {
break;
}
*buff = fileBuff;
*len = (uint32_t)fileLen;
return ret;
} while (0);
BSL_SAL_FREE(fileBuff);
return ret;
}
#else
static int32_t ReadCert(const char *path, uint8_t **buff, uint32_t *len)
{
(void)path;
(void)buff;
(void)len;
return BSL_INTERNAL_EXCEPTION;
}
#endif
#ifdef HITLS_BSL_LOG
void BinLogFixLenFunc(uint32_t logId, uint32_t logLevel, uint32_t logType,
void *format, void *para1, void *para2, void *para3, void *para4)
{
(void)logLevel;
(void)logType;
printf("logId:%u\t", logId);
printf(format, para1, para2, para3, para4);
printf("\n");
}
void BinLogVarLenFunc(uint32_t logId, uint32_t logLevel, uint32_t logType,
void *format, void *para)
{
(void)logLevel;
(void)logType;
printf("logId:%u\t", logId);
printf(format, para);
printf("\n");
}
#endif
/* BEGIN_CASE */
void SDV_BSL_ASN1_DecodeTemplate_TC001(char *path)
{
#ifndef HITLS_BSL_SAL_FILE
SKIP_TEST();
#endif
#ifdef HITLS_BSL_LOG
BSL_LOG_BinLogFuncs func = {0};
func.fixLenFunc = BinLogFixLenFunc;
func.varLenFunc = BinLogVarLenFunc;
ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_SUCCESS);
#endif
uint32_t fileLen = 0;
uint8_t *fileBuff = NULL;
int32_t ret = ReadCert(path, &fileBuff, &fileLen);
ASSERT_EQ(ret, BSL_SUCCESS);
uint8_t *rawBuff = fileBuff;
BSL_ASN1_Buffer asnArr[BSL_ASN1_TAG_SIGN_IDX + 1] = {0};
BSL_ASN1_Template templ = {certTempl, sizeof(certTempl) / sizeof(certTempl[0])};
ret = BSL_ASN1_DecodeTemplate(NULL, BSL_ASN1_CertTagGetOrCheck, &fileBuff, &fileLen, asnArr, BSL_ASN1_TAG_SIGN_IDX + 1);
ASSERT_EQ(ret, BSL_NULL_INPUT);
ret = BSL_ASN1_DecodeTemplate(&templ, NULL, &fileBuff, &fileLen, asnArr, BSL_ASN1_TAG_SIGN_IDX + 1);
ASSERT_EQ(ret, BSL_ASN1_ERR_NO_CALLBACK);
ret = BSL_ASN1_DecodeTemplate(&templ, BSL_ASN1_CertTagGetOrCheck, NULL, &fileLen, asnArr, BSL_ASN1_TAG_SIGN_IDX + 1);
ASSERT_EQ(ret, BSL_NULL_INPUT);
ret = BSL_ASN1_DecodeTemplate(&templ, BSL_ASN1_CertTagGetOrCheck, &fileBuff, NULL, asnArr, BSL_ASN1_TAG_SIGN_IDX + 1);
ASSERT_EQ(ret, BSL_NULL_INPUT);
ret = BSL_ASN1_DecodeTemplate(&templ, BSL_ASN1_CertTagGetOrCheck, &fileBuff, &fileLen, NULL, BSL_ASN1_TAG_SIGN_IDX + 1);
ASSERT_EQ(ret, BSL_NULL_INPUT);
ret = BSL_ASN1_DecodeTemplate(&templ, BSL_ASN1_CertTagGetOrCheck, &fileBuff, &fileLen, asnArr, 0);
ASSERT_EQ(ret, BSL_NULL_INPUT);
EXIT:
BSL_SAL_FREE(rawBuff);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_DECODE_TEMPLATE_TC002(char *path)
{
#ifndef HITLS_BSL_SAL_FILE
SKIP_TEST();
#endif
#ifdef HITLS_BSL_LOG
BSL_LOG_BinLogFuncs func = {0};
func.fixLenFunc = BinLogFixLenFunc;
func.varLenFunc = BinLogVarLenFunc;
ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_SUCCESS);
#endif
uint32_t fileLen = 0;
uint8_t *fileBuff = NULL;
int32_t ret = ReadCert(path, &fileBuff, &fileLen);
ASSERT_EQ(ret, BSL_SUCCESS);
uint8_t *rawBuff = fileBuff;
BSL_ASN1_Buffer asnArr[BSL_ASN1_TAG_SIGN_IDX + 1] = {0};
BSL_ASN1_Template templ = {maxDepthTempl, sizeof(maxDepthTempl) / sizeof(maxDepthTempl[0])};
ret = BSL_ASN1_DecodeTemplate(&templ, BSL_ASN1_CertTagGetOrCheck, &fileBuff, &fileLen, asnArr, BSL_ASN1_TAG_SIGN_IDX + 1);
ASSERT_EQ(ret, BSL_ASN1_ERR_MAX_DEPTH);
EXIT:
BSL_SAL_FREE(rawBuff);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_CERT_FUNC_TC001(char *path, Hex *version, Hex *serial, Hex *algId, Hex *anyAlgId,
Hex *issuer, Hex *before, Hex *after, Hex *subject, Hex *pubId, Hex *pubAny, Hex *pubKey, Hex *issuerId,
Hex *subjectId, Hex *ext, Hex *signAlg, Hex *signAlgAny, Hex *sign)
{
#ifndef HITLS_BSL_SAL_FILE
SKIP_TEST();
#endif
#ifdef HITLS_BSL_LOG
BSL_LOG_BinLogFuncs func = {0};
func.fixLenFunc = BinLogFixLenFunc;
func.varLenFunc = BinLogVarLenFunc;
ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_SUCCESS);
#endif
uint32_t fileLen = 0;
uint8_t *fileBuff = NULL;
int32_t ret = ReadCert(path, &fileBuff, &fileLen);
ASSERT_EQ(ret, BSL_SUCCESS);
uint8_t *rawBuff = fileBuff;
BSL_ASN1_Buffer asnArr[BSL_ASN1_TAG_SIGN_IDX + 1] = {0};
BSL_ASN1_Template templ = {certTempl, sizeof(certTempl) / sizeof(certTempl[0])};
ret = BSL_ASN1_DecodeTemplate(&templ, BSL_ASN1_CertTagGetOrCheck,
&fileBuff, &fileLen, asnArr, BSL_ASN1_TAG_SIGN_IDX + 1);
ASSERT_EQ(ret, BSL_SUCCESS);
ASSERT_EQ(fileLen, 0);
// 证书对比
if (version->len != 0) {
ASSERT_EQ_LOG("version compare tag", asnArr[BSL_ASN1_TAG_VERSION_IDX].tag, BSL_ASN1_TAG_INTEGER);
ASSERT_COMPARE("version compare", version->x, version->len,
asnArr[BSL_ASN1_TAG_VERSION_IDX].buff, asnArr[BSL_ASN1_TAG_VERSION_IDX].len);
}
ASSERT_EQ_LOG("serial compare tag", asnArr[BSL_ASN1_TAG_SERIAL_IDX].tag, BSL_ASN1_TAG_INTEGER);
ASSERT_COMPARE("serial compare", serial->x, serial->len,
asnArr[BSL_ASN1_TAG_SERIAL_IDX].buff, asnArr[BSL_ASN1_TAG_SERIAL_IDX].len);
ASSERT_EQ_LOG("algid compare tag", asnArr[BSL_ASN1_TAG_SIGNINFO_OID_IDX].tag, BSL_ASN1_TAG_OBJECT_ID);
ASSERT_COMPARE("algid compare", algId->x, algId->len,
asnArr[BSL_ASN1_TAG_SIGNINFO_OID_IDX].buff, asnArr[BSL_ASN1_TAG_SIGNINFO_OID_IDX].len);
if (anyAlgId->len != 0) {
ASSERT_COMPARE("any algid compare", anyAlgId->x, anyAlgId->len,
asnArr[BSL_ASN1_TAG_SIGNINFO_ANY_IDX].buff, asnArr[BSL_ASN1_TAG_SIGNINFO_ANY_IDX].len);
} else {
ASSERT_EQ(asnArr[BSL_ASN1_TAG_SIGNINFO_ANY_IDX].buff, NULL);
ASSERT_EQ(asnArr[BSL_ASN1_TAG_SIGNINFO_ANY_IDX].len, 0);
}
ASSERT_EQ_LOG("issuer compare tag", asnArr[BSL_ASN1_TAG_ISSUER_IDX].tag,
BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE);
ASSERT_COMPARE("issuer compare", issuer->x, issuer->len,
asnArr[BSL_ASN1_TAG_ISSUER_IDX].buff, asnArr[BSL_ASN1_TAG_ISSUER_IDX].len);
ASSERT_COMPARE("before compare", before->x, before->len,
asnArr[BSL_ASN1_TAG_BEFORE_VALID_IDX].buff, asnArr[BSL_ASN1_TAG_BEFORE_VALID_IDX].len);
ASSERT_COMPARE("after compare", after->x, after->len,
asnArr[BSL_ASN1_TAG_AFTER_VALID_IDX].buff, asnArr[BSL_ASN1_TAG_AFTER_VALID_IDX].len);
ASSERT_EQ_LOG("subject compare tag", asnArr[BSL_ASN1_TAG_SUBJECT_IDX].tag,
BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE);
ASSERT_COMPARE("subject compare", subject->x, subject->len,
asnArr[BSL_ASN1_TAG_SUBJECT_IDX].buff, asnArr[BSL_ASN1_TAG_SUBJECT_IDX].len);
ASSERT_EQ_LOG("subject pub key compare tag", asnArr[BSL_ASN1_TAG_SUBKEYINFO_IDX].tag, BSL_ASN1_TAG_OBJECT_ID);
ASSERT_COMPARE("subject pub key id compare", pubId->x, pubId->len,
asnArr[BSL_ASN1_TAG_SUBKEYINFO_IDX].buff, asnArr[BSL_ASN1_TAG_SUBKEYINFO_IDX].len);
if (pubAny->len != 0) {
ASSERT_COMPARE("any pub key compare", pubAny->x, pubAny->len,
asnArr[BSL_ASN1_TAG_SUBKEYINFO_ANY_IDX].buff, asnArr[BSL_ASN1_TAG_SUBKEYINFO_ANY_IDX].len);
} else {
ASSERT_EQ(asnArr[BSL_ASN1_TAG_SUBKEYINFO_ANY_IDX].buff, NULL);
ASSERT_EQ(asnArr[BSL_ASN1_TAG_SUBKEYINFO_ANY_IDX].len, 0);
}
ASSERT_EQ_LOG("subject pub key compare tag", asnArr[BSL_ASN1_TAG_SUBKEYINFO_BITSTRING_IDX].tag,
BSL_ASN1_TAG_BITSTRING);
ASSERT_COMPARE("subject pub key compare", pubKey->x, pubKey->len,
asnArr[BSL_ASN1_TAG_SUBKEYINFO_BITSTRING_IDX].buff, asnArr[BSL_ASN1_TAG_SUBKEYINFO_BITSTRING_IDX].len);
if (issuerId->len != 0) {
ASSERT_COMPARE("issuerId compare", issuerId->x, issuerId->len,
asnArr[BSL_ASN1_TAG_ISSUERID_IDX].buff, asnArr[BSL_ASN1_TAG_ISSUERID_IDX].len);
} else {
ASSERT_EQ(asnArr[BSL_ASN1_TAG_ISSUERID_IDX].buff, NULL);
ASSERT_EQ(asnArr[BSL_ASN1_TAG_ISSUERID_IDX].len, 0);
}
if (subjectId->len != 0) {
ASSERT_COMPARE("subjectId compare", subjectId->x, subjectId->len,
asnArr[BSL_ASN1_TAG_SUBJECTID_IDX].buff, asnArr[BSL_ASN1_TAG_SUBJECTID_IDX].len);
} else {
ASSERT_EQ(asnArr[BSL_ASN1_TAG_SUBJECTID_IDX].buff, NULL);
ASSERT_EQ(asnArr[BSL_ASN1_TAG_SUBJECTID_IDX].len, 0);
}
if (ext->len != 0) { // v1 没有ext
ASSERT_EQ_LOG("ext compare tag", asnArr[BSL_ASN1_TAG_EXT_IDX].tag,
BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_CTX_SPECIFIC_TAG_EXTENSION);
ASSERT_COMPARE("ext compare", ext->x, ext->len,
asnArr[BSL_ASN1_TAG_EXT_IDX].buff, asnArr[BSL_ASN1_TAG_EXT_IDX].len);
}
ASSERT_EQ_LOG("signAlg compare tag", asnArr[BSL_ASN1_TAG_SIGNALG_IDX].tag, BSL_ASN1_TAG_OBJECT_ID);
ASSERT_COMPARE("signAlg compare", signAlg->x, signAlg->len,
asnArr[BSL_ASN1_TAG_SIGNALG_IDX].buff, asnArr[BSL_ASN1_TAG_SIGNALG_IDX].len);
if (signAlgAny->len != 0) {
ASSERT_COMPARE("signAlgAny compare", signAlgAny->x, signAlgAny->len,
asnArr[BSL_ASN1_TAG_SIGNALG_ANY_IDX].buff, asnArr[BSL_ASN1_TAG_SIGNALG_ANY_IDX].len);
} else {
ASSERT_EQ(asnArr[BSL_ASN1_TAG_SIGNALG_ANY_IDX].buff, NULL);
ASSERT_EQ(asnArr[BSL_ASN1_TAG_SIGNALG_ANY_IDX].len, 0);
}
ASSERT_EQ_LOG("sign compare tag", asnArr[BSL_ASN1_TAG_SIGN_IDX].tag, BSL_ASN1_TAG_BITSTRING);
ASSERT_COMPARE("sign compare", sign->x, sign->len,
asnArr[BSL_ASN1_TAG_SIGN_IDX].buff, asnArr[BSL_ASN1_TAG_SIGN_IDX].len);
EXIT:
BSL_SAL_FREE(rawBuff);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_DecodePrimitiveItem_FUNC_TC001(Hex *val)
{
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BOOLEAN, val->len, val->x};
bool res;
int32_t ret = BSL_ASN1_DecodePrimitiveItem(NULL, &res);
ASSERT_EQ(ret, BSL_NULL_INPUT);
ret = BSL_ASN1_DecodePrimitiveItem(&asn, NULL);
ASSERT_EQ(ret, BSL_NULL_INPUT);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_DecodePrimitiveItem_FUNC_TC002(int tag, Hex *val)
{
BSL_ASN1_Buffer asn = {(uint8_t)tag, val->len, val->x};
int32_t res;
int32_t ret = BSL_ASN1_DecodePrimitiveItem(NULL, &res);
ASSERT_EQ(ret, BSL_NULL_INPUT);
ret = BSL_ASN1_DecodePrimitiveItem(&asn, NULL);
ASSERT_EQ(ret, BSL_NULL_INPUT);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_DecodePrimitiveItem_FUNC_TC003(Hex *val)
{
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BITSTRING, val->len, val->x};
BSL_ASN1_BitString res;
int32_t ret = BSL_ASN1_DecodePrimitiveItem(NULL, &res);
ASSERT_EQ(ret, BSL_NULL_INPUT);
ret = BSL_ASN1_DecodePrimitiveItem(&asn, NULL);
ASSERT_EQ(ret, BSL_NULL_INPUT);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_BOOL_PRIMITIVEITEM_FUNC(Hex *val, int expectVal)
{
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BOOLEAN, val->len, val->x};
bool res;
int32_t ret = BSL_ASN1_DecodePrimitiveItem(&asn, &res);
ASSERT_EQ(ret, BSL_SUCCESS);
ASSERT_EQ((bool)expectVal, res);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_INT_PRIMITIVEITEM_FUNC(int tag, Hex *val, int result, int expectVal)
{
BSL_ASN1_Buffer asn = {(uint8_t)tag, val->len, val->x};
int32_t res;
int32_t ret = BSL_ASN1_DecodePrimitiveItem(&asn, &res);
ASSERT_EQ(ret, result);
if (ret == BSL_SUCCESS) {
ASSERT_EQ((uint32_t)expectVal, res);
}
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_BITSTRING_PRIMITIVEITEM_FUNC(Hex *val, int result, int unusedBits)
{
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BITSTRING, val->len, val->x};
BSL_ASN1_BitString res;
int32_t ret = BSL_ASN1_DecodePrimitiveItem(&asn, &res);
ASSERT_EQ(ret, result);
if (ret == BSL_SUCCESS) {
ASSERT_EQ((uint32_t)unusedBits, res.unusedBits);
ASSERT_EQ(val->len - 1, res.len);
ASSERT_COMPARE("bit string", res.buff, res.len, val->x + 1, val->len - 1);
}
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_PARSE_TIME_PRIMITIVEITEM_FUNC(int tag, Hex *val, int result,
int year, int month, int day, int hour, int minute, int second)
{
BSL_ASN1_Buffer asn = {tag, val->len, val->x};
BSL_TIME res = {0};
int32_t ret = BSL_ASN1_DecodePrimitiveItem(&asn, &res);
ASSERT_EQ(ret, result);
if (ret == BSL_SUCCESS) {
ASSERT_EQ(res.year, year);
ASSERT_EQ(res.month, month);
ASSERT_EQ(res.day, day);
ASSERT_EQ(res.hour, hour);
ASSERT_EQ(res.minute, minute);
ASSERT_EQ(res.second, second);
}
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_DECODELEN_FUNC(int flag, Hex *val, int res)
{
uint8_t *encode = val->x;
uint32_t encodeLen = val->len;
uint32_t len = 0;
ASSERT_EQ(BSL_ASN1_DecodeLen(&encode, &encodeLen, flag, &len), res);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_DECODE_WRONG_INPUT_FUNC()
{
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
uint32_t valueLen = 0;
bool completeLen = 0;
uint8_t tag = 0x30;
BSL_ASN1_Buffer asnItem = {0};
ASSERT_EQ(BSL_ASN1_DecodeLen(&encode, &encodeLen, completeLen, &valueLen), BSL_NULL_INPUT);
ASSERT_EQ(BSL_ASN1_DecodeTagLen(tag, &encode, &encodeLen, &valueLen), BSL_NULL_INPUT);
ASSERT_EQ(BSL_ASN1_DecodeItem(&encode, &encodeLen, &asnItem), BSL_NULL_INPUT);
BSL_ASN1_TemplateItem listTempl = {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0};
BSL_ASN1_Template templ = {&listTempl, 1};
ASSERT_EQ(BSL_ASN1_DecodeTemplate(&templ, NULL, &encode, &encodeLen, &asnItem, 1), BSL_NULL_INPUT);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_DECODECOMPLETELEN_FUNC(Hex *val, int ecpLen, int res)
{
uint8_t *encode = val->x;
uint32_t encodeLen = val->len;
ASSERT_EQ(BSL_ASN1_GetCompleteLen(encode, &encodeLen), res);
if (res == BSL_SUCCESS) {
ASSERT_EQ(encodeLen, ecpLen);
}
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_TEMPLATE_API_TC001(void)
{
BSL_ASN1_TemplateItem item[] = {{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0}};
BSL_ASN1_Template templ = {item, 1};
BSL_ASN1_Buffer asnArr[1] = {0};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
/* templ */
ASSERT_EQ(BSL_ASN1_EncodeTemplate(NULL, asnArr, 1, &encode, &encodeLen), BSL_INVALID_ARG);
templ.templItems = NULL;
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 1, &encode, &encodeLen), BSL_INVALID_ARG);
templ.templItems = item;
templ.templNum = 0;
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 1, &encode, &encodeLen), BSL_INVALID_ARG);
templ.templNum = 1;
/* asnArr */
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, NULL, 1, &encode, &encodeLen), BSL_INVALID_ARG);
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 0, &encode, &encodeLen), BSL_INVALID_ARG);
/* encode */
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 1, NULL, &encodeLen), BSL_INVALID_ARG);
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 1, &encode, NULL), BSL_INVALID_ARG);
encode = (uint8_t*)&encodeLen;
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 1, &encode, &encodeLen), BSL_INVALID_ARG);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_TEMPLATE_ERROR_TC001(void)
{
BSL_ASN1_Template templ = {maxDepthTempl, sizeof(maxDepthTempl) / sizeof(maxDepthTempl[0])};
BSL_ASN1_Buffer asnArr[1] = {0};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 1, &encode, &encodeLen), BSL_ASN1_ERR_MAX_DEPTH);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_TEMPLATE_ERROR_TC002(int tag, int len, int ret)
{
BSL_ASN1_TemplateItem item[] = {{tag, 0, 0}};
BSL_ASN1_Template templ = {item, 1};
uint8_t data = 1;
BSL_ASN1_Buffer asn = {tag, len, &data};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), ret);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_TEMPLATE_ERROR_TC003(Hex *data)
{
BSL_ASN1_TemplateItem items[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_INTEGER, 0, 1},
{BSL_ASN1_TAG_ANY, 0, 1},
{BSL_ASN1_TAG_CHOICE, 0, 1}
};
BSL_ASN1_Template templ = {items, sizeof(items) / sizeof(items[0])};
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_INTEGER, data->len, data->x};
BSL_ASN1_Buffer asns[] = {asn, asn, asn, asn};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
uint32_t expectAsnNum = 3;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, expectAsnNum - 1, &encode, &encodeLen),
BSL_ASN1_ERR_ENCODE_ASN_LACK);
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, expectAsnNum + 1, &encode, &encodeLen),
BSL_ASN1_ERR_ENCODE_ASN_TOO_MUCH);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_TEMPLATE_ERROR_TC004(void)
{
BSL_ASN1_TemplateItem items[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_INTEGER, 0, 1},
};
BSL_ASN1_Template templ = {items, sizeof(items) / sizeof(items[0])};
int iData = 256;
BSL_ASN1_Buffer asn[] = {{BSL_ASN1_TAG_ENUMERATED, sizeof(int), (uint8_t *)&iData}};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asn, sizeof(asn) / sizeof(asn[0]), &encode, &encodeLen),
BSL_ASN1_ERR_TAG_EXPECTED);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_BOOL_FUNC(int data, Hex *expect)
{
bool bData = (bool)data;
BSL_ASN1_TemplateItem item[] = {{BSL_ASN1_TAG_BOOLEAN, 0, 0}};
BSL_ASN1_Template templ = {item, 1};
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BOOLEAN, 1, (uint8_t *)&bData};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), BSL_SUCCESS);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode bool", expect->x, expect->len, encode, encodeLen);
EXIT:
BSL_SAL_Free(encode);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_INT_LIMB_FUNC(int ret, int data, Hex *expect)
{
BSL_ASN1_TemplateItem item[] = {{BSL_ASN1_TAG_INTEGER, 0, 0}};
BSL_ASN1_Template templ = {item, 1};
BSL_ASN1_Buffer asn = {0};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeLimb(BSL_ASN1_TAG_INTEGER, data, &asn), BSL_SUCCESS);
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), ret);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode int", expect->x, expect->len, encode, encodeLen);
EXIT:
BSL_SAL_Free(asn.buff);
if (ret == BSL_SUCCESS) {
BSL_SAL_Free(encode);
}
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_INT_BN_FUNC(Hex *bn, Hex *expect)
{
BSL_ASN1_TemplateItem item[] = {{BSL_ASN1_TAG_INTEGER, 0, 0}};
BSL_ASN1_Template templ = {item, 1};
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_INTEGER, bn->len, bn->x};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), BSL_SUCCESS);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode int", expect->x, expect->len, encode, encodeLen);
EXIT:
BSL_SAL_Free(encode);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_BITSTRING_FUNC(int ret, Hex *data, int unusedBits, Hex *expect)
{
BSL_ASN1_TemplateItem item[] = {{BSL_ASN1_TAG_BITSTRING, 0, 0}};
BSL_ASN1_Template templ = {item, 1};
BSL_ASN1_BitString bs = {data->x, data->len, unusedBits};
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BITSTRING,
data->len == 0 ? 0 : sizeof(BSL_ASN1_BitString),
data->len == 0 ? NULL : (uint8_t *)&bs};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), ret);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode bitstring", expect->x, expect->len, encode, encodeLen);
EXIT:
if (ret == BSL_SUCCESS) {
BSL_SAL_Free(encode);
}
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_TIME_FUNC(int tag, int ret, int year, int month, int day, int hour, int minute, int second,
Hex *expect)
{
BSL_ASN1_TemplateItem item[] = {{tag, 0, 0}};
BSL_ASN1_Template templ = {item, 1};
BSL_TIME time = {year, month, day, hour, minute, 0, second, 0};
BSL_ASN1_Buffer asn = {tag, sizeof(BSL_TIME), (uint8_t *)&time};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), ret);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode time", expect->x, expect->len, encode, encodeLen);
EXIT:
if (ret == BSL_SUCCESS) {
BSL_SAL_Free(encode);
}
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_NULL_FUNC_TC001(Hex *expect)
{
BSL_ASN1_TemplateItem item[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_NULL, 0, 1},
{BSL_ASN1_TAG_NULL, BSL_ASN1_FLAG_OPTIONAL, 1},
{BSL_ASN1_TAG_NULL, BSL_ASN1_FLAG_DEFAULT, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
{BSL_ASN1_TAG_NULL, 0, 2},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_OPTIONAL, 1},
{BSL_ASN1_TAG_NULL, 0, 2},
};
BSL_ASN1_Template templ = {item, sizeof(item) / sizeof(item[0])};
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_NULL, 0, NULL};
BSL_ASN1_Buffer asns[] = {asn, asn, asn, asn, asn};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, sizeof(asns) / sizeof(asn), &encode, &encodeLen), BSL_SUCCESS);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode null", expect->x, expect->len, encode, encodeLen);
EXIT:
BSL_SAL_Free(encode);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_NULL_FUNC_TC002(Hex *expect)
{
uint8_t data = 1;
BSL_ASN1_TemplateItem item[] = {{BSL_ASN1_TAG_NULL, 0, 0}};
BSL_ASN1_Template templ = {item, sizeof(item) / sizeof(item[0])};
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_NULL, 1, &data};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), BSL_SUCCESS);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode null", expect->x, expect->len, encode, encodeLen);
EXIT:
BSL_SAL_Free(encode);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_TEMPLATE_FUNC_TC001(Hex *expect)
{
BSL_ASN1_TemplateItem items[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_INTEGER, 0, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_OPTIONAL | BSL_ASN1_FLAG_HEADERONLY, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_OPTIONAL | BSL_ASN1_FLAG_HEADERONLY, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_OPTIONAL | BSL_ASN1_FLAG_HEADERONLY, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 2},
{BSL_ASN1_TAG_INTEGER, 0, 3},
{BSL_ASN1_TAG_INTEGER, 0, 3},
{BSL_ASN1_TAG_INTEGER, 0, 1},
};
BSL_ASN1_Template templ = {items, sizeof(items) / sizeof(items[0])};
uint8_t iData[] = {0x01, 0x00};
uint8_t data = 0x12;
BSL_ASN1_Buffer asns[] = {
{BSL_ASN1_TAG_INTEGER, sizeof(iData) / sizeof(uint8_t), iData},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 1, &data},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, NULL},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 1, &data},
{BSL_ASN1_TAG_INTEGER, sizeof(iData) / sizeof(uint8_t), iData},
};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, sizeof(asns) / sizeof(asns[0]), &encode, &encodeLen), BSL_SUCCESS);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode headonly", expect->x, expect->len, encode, encodeLen);
EXIT:
BSL_SAL_Free(encode);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_TEMPLATE_FUNC_TC002(Hex *data, Hex *expect)
{
BSL_ASN1_TemplateItem items[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_INTEGER, 0, 1},
{BSL_ASN1_TAG_INTEGER, BSL_ASN1_FLAG_OPTIONAL, 1},
{BSL_ASN1_TAG_INTEGER, BSL_ASN1_FLAG_DEFAULT, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
{BSL_ASN1_TAG_INTEGER, 0, 2},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_OPTIONAL, 1},
{BSL_ASN1_TAG_INTEGER, 0, 2},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_DEFAULT, 1},
{BSL_ASN1_TAG_INTEGER, 0, 2},
};
BSL_ASN1_Template templ = {items, sizeof(items) / sizeof(items[0])};
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_INTEGER, data->len, data->x};
BSL_ASN1_Buffer asns[] = {asn, asn, asn, asn, asn, asn};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, sizeof(asns) / sizeof(asn), &encode, &encodeLen), BSL_SUCCESS);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode optional|default", expect->x, expect->len, encode, encodeLen);
EXIT:
BSL_SAL_Free(encode);
}
/* END_CASE */
static BSL_ASN1_TemplateItem g_templItem1[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_INTEGER, 0, 1},
{BSL_ASN1_TAG_INTEGER, 0, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
{BSL_ASN1_TAG_INTEGER, 0, 2},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
{BSL_ASN1_TAG_INTEGER, 0, 2},
};
static BSL_ASN1_TemplateItem g_templItem2[] = {
{BSL_ASN1_TAG_INTEGER, 0, 0},
{BSL_ASN1_TAG_INTEGER, 0, 0},
{BSL_ASN1_TAG_INTEGER, 0, 0},
{BSL_ASN1_TAG_INTEGER, 0, 0},
};
static BSL_ASN1_TemplateItem g_templItem3[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_INTEGER, BSL_ASN1_FLAG_OPTIONAL, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
{BSL_ASN1_TAG_INTEGER, 0, 2},
{BSL_ASN1_TAG_INTEGER, 0, 0},
{BSL_ASN1_TAG_INTEGER, BSL_ASN1_FLAG_OPTIONAL, 0},
};
static BSL_ASN1_Template g_templ[] = {
{g_templItem1, sizeof(g_templItem1) / sizeof(g_templItem1[0])},
{g_templItem2, sizeof(g_templItem2) / sizeof(g_templItem2[0])},
{g_templItem3, sizeof(g_templItem3) / sizeof(g_templItem3[0])},
};
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_TEMPLATE_FUNC_TC003(Hex *data, int templIdx, Hex *expect)
{
#define MAX_INT_ASN_NUM 4
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_INTEGER, data->len, data->x};
BSL_ASN1_Buffer asns[MAX_INT_ASN_NUM] = {asn, asn, asn, asn};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
TestMemInit();
ASSERT_EQ(BSL_ASN1_EncodeTemplate(g_templ + templIdx, asns, MAX_INT_ASN_NUM, &encode, &encodeLen), BSL_SUCCESS);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode", expect->x, expect->len, encode, encodeLen);
EXIT:
BSL_SAL_Free(encode);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_LIST_API_TC001(void)
{
BSL_ASN1_TemplateItem item[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_NULL, 0, 1},
{BSL_ASN1_TAG_NULL, 0, 1},
};
BSL_ASN1_Template templ = {item, sizeof(item) / sizeof(item[0])};
BSL_ASN1_Buffer asnArr[] = {
{BSL_ASN1_TAG_NULL, 0, NULL},
{BSL_ASN1_TAG_NULL, 0, NULL},
};
uint32_t arrNum = sizeof(asnArr) / sizeof(asnArr[0]);
BSL_ASN1_Buffer out = {0};
/* tag */
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_TIME, 1, &templ, asnArr, arrNum, &out), BSL_INVALID_ARG);
/* listSize */
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_TIME, 0, &templ, asnArr, arrNum, &out), BSL_INVALID_ARG);
/* templ */
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, NULL, asnArr, arrNum, &out), BSL_INVALID_ARG);
templ.templItems = NULL;
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SEQUENCE, 1, &templ, asnArr, arrNum, &out), BSL_INVALID_ARG);
templ.templItems = item;
templ.templNum = 0;
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, arrNum, &out), BSL_INVALID_ARG);
templ.templNum = sizeof(item) / sizeof(item[0]);
/* asnArr */
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, NULL, arrNum, &out), BSL_INVALID_ARG);
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, 0, &out), BSL_INVALID_ARG);
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, arrNum + 1, &templ, asnArr, arrNum, &out), BSL_INVALID_ARG);
/* out */
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, arrNum, NULL), BSL_INVALID_ARG);
out.buff = (uint8_t *)&arrNum;
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, arrNum, &out), BSL_INVALID_ARG);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_LIST_ERROR_TC001(void)
{
BSL_ASN1_TemplateItem item[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_NULL, 0, 1},
}; /* The expected number of asns in the current template is 1. */
BSL_ASN1_Template templ = {item, sizeof(item) / sizeof(item[0])};
BSL_ASN1_Buffer asnArr[] = {{BSL_ASN1_TAG_INTEGER, 0, NULL}};
BSL_ASN1_Buffer out = {0};
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, 1, &out), BSL_ASN1_ERR_TAG_EXPECTED);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_LIST_ERROR_TC002(void)
{
BSL_ASN1_TemplateItem item[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_NULL, 0, 1},
{BSL_ASN1_TAG_NULL, 0, 1},
}; /* The expected number of asns in the current template is 2. */
BSL_ASN1_Template templ = {item, sizeof(item) / sizeof(item[0])};
BSL_ASN1_Buffer asnArr[] = {
{BSL_ASN1_TAG_NULL, 0, NULL},
{BSL_ASN1_TAG_NULL, 0, NULL},
{BSL_ASN1_TAG_NULL, 0, NULL},
};
uint32_t arrNum = sizeof(asnArr) / sizeof(asnArr[0]);
BSL_ASN1_Buffer out = {0};
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, 1, &out), BSL_ASN1_ERR_ENCODE_ASN_LACK);
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, arrNum, &out),
BSL_ASN1_ERR_ENCODE_ASN_TOO_MUCH);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_LIST_ERROR_TC003(int tag, int ret)
{
BSL_ASN1_TemplateItem item[] = {{tag, 0, 0}};
BSL_ASN1_Template templ = {item, 1};
uint8_t data = 1;
BSL_ASN1_Buffer asn = {tag, 1, &data};
BSL_ASN1_Buffer out = {0};
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, &asn, 1, &out), ret);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_LIST_TC001(int listSize, Hex *encode)
{
#ifndef HITLS_BSL_OBJ
(void)listSize;
(void)encode;
SKIP_TEST();
#else
BSL_ASN1_TemplateItem x509Name[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SET, 0, 0},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
{BSL_ASN1_TAG_OBJECT_ID, 0, 2},
{BSL_ASN1_TAG_ANY, 0, 2}
};
BSL_ASN1_Template templ = {x509Name, sizeof(x509Name) / sizeof(x509Name[0])};
BslOidString *o = BSL_OBJ_GetOID(BSL_CID_AT_ORGANIZATIONNAME);
char *oName = "Energy TEST";
BslOidString *cn = BSL_OBJ_GetOID(BSL_CID_AT_COMMONNAME);
char *cnName = "Energy ECC Equipment Root CA 1";
BSL_ASN1_Buffer in[] = {
{BSL_ASN1_TAG_OBJECT_ID, o->octetLen, (uint8_t *)o->octs},
{BSL_ASN1_TAG_PRINTABLESTRING, strlen(oName), (uint8_t *)oName},
{BSL_ASN1_TAG_OBJECT_ID, cn->octetLen, (uint8_t *)cn->octs},
{BSL_ASN1_TAG_PRINTABLESTRING, strlen(cnName), (uint8_t *)cnName},
};
BSL_ASN1_Buffer out = {0};
ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SEQUENCE, listSize, &templ, in, sizeof(in) / sizeof(in[0]), &out),
BSL_SUCCESS);
ASSERT_EQ(encode->len, out.len);
ASSERT_COMPARE("Encode list", encode->x, encode->len, out.buff, out.len);
EXIT:
BSL_SAL_FREE(out.buff);
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_DECODE_THEN_ENCODE_FUNC_TC001(int testIdx, char *path)
{
#ifndef HITLS_BSL_SAL_FILE
(void)testIdx;
(void)path;
SKIP_TEST();
#else
BSL_ASN1_Template templ = {g_tests[testIdx].items, g_tests[testIdx].itemNum};
uint32_t asnNum = g_tests[testIdx].asnNum;
uint8_t *rawData = NULL;
uint32_t dataLen = 0;
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
BSL_ASN1_Buffer *decodeAsns = (BSL_ASN1_Buffer *)BSL_SAL_Calloc(asnNum, sizeof(BSL_ASN1_Buffer));
ASSERT_TRUE(decodeAsns != NULL);
/* Decode */
ASSERT_EQ(BSL_SAL_ReadFile(path, &rawData, &dataLen), BSL_SUCCESS);
uint8_t *decode = rawData;
uint32_t decodeLen = dataLen;
ASSERT_EQ(BSL_ASN1_DecodeTemplate(&templ, NULL, &decode, &decodeLen, decodeAsns, asnNum),
BSL_SUCCESS);
ASSERT_EQ(decodeLen, 0);
/* Encode */
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, decodeAsns, asnNum, &encode, &encodeLen), BSL_SUCCESS);
ASSERT_EQ(encodeLen, dataLen);
ASSERT_COMPARE("Decode then encode", rawData, dataLen, encode, encodeLen);
EXIT:
BSL_SAL_Free(decodeAsns);
BSL_SAL_Free(rawData);
BSL_SAL_Free(encode);
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_THEN_DECODE_FUNC_TC001(int boolData, int number, Hex *bitString, int unusedBits, Hex *utf8,
int year, int month, int day, int hour, int minute, int second, Hex *headonly, Hex *expect)
{
bool bData = (bool)boolData;
BSL_ASN1_TemplateItem items[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_BOOLEAN, 0, 1},
{BSL_ASN1_TAG_INTEGER, 0, 1},
{BSL_ASN1_TAG_BITSTRING, 0, 1},
{BSL_ASN1_TAG_NULL, BSL_ASN1_FLAG_OPTIONAL, 1},
{BSL_ASN1_TAG_UTF8STRING, 0, 1},
{BSL_ASN1_TAG_UTCTIME, 0, 1},
{BSL_ASN1_TAG_UTCTIME, BSL_ASN1_FLAG_OPTIONAL, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_HEADERONLY, 1},
{BSL_ASN1_TAG_NULL, 0, 2},
};
BSL_ASN1_Buffer integer = {0};
ASSERT_EQ(BSL_ASN1_EncodeLimb(BSL_ASN1_TAG_INTEGER, number, &integer), BSL_SUCCESS);
BSL_ASN1_BitString bs = {bitString->x, bitString->len, unusedBits};
BSL_TIME time = {year, month, day, hour, minute, 0, second, 0};
BSL_ASN1_Buffer asns[] = {
{BSL_ASN1_TAG_BOOLEAN, sizeof(bool), (uint8_t *)&bData}, // 0
integer, // 1
{BSL_ASN1_TAG_BITSTRING, sizeof(BSL_ASN1_BitString), (uint8_t *)&bs}, // 2
{BSL_ASN1_TAG_NULL, 0, NULL}, // 3
{BSL_ASN1_TAG_UTF8STRING, utf8->len, utf8->x}, // 4
{BSL_ASN1_TAG_UTCTIME, sizeof(BSL_TIME), (uint8_t *)&time}, // 5
{BSL_ASN1_TAG_UTCTIME, 0, NULL}, // 6
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, headonly->len, headonly->x}, // 7
};
uint32_t asnNum = sizeof(asns) / sizeof(asns[0]);
BSL_ASN1_Template templ = {items, sizeof(items) / sizeof(items[0])};
uint8_t *encode = NULL;
uint32_t encodeLen = 0;
ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, asnNum, &encode, &encodeLen), BSL_SUCCESS);
ASSERT_EQ(encodeLen, expect->len);
ASSERT_COMPARE("Encode", expect->x, expect->len, encode, encodeLen);
uint8_t *tmp = encode;
uint32_t tmpLen = encodeLen;
BSL_ASN1_Buffer decAns[8] = {0}; // 8 is asnNum
ASSERT_EQ(BSL_ASN1_DecodeTemplate(&templ, NULL, &tmp, &tmpLen, decAns, asnNum), BSL_SUCCESS);
ASSERT_EQ(tmpLen, 0);
bool bRes;
ASSERT_EQ(BSL_ASN1_DecodePrimitiveItem(decAns + 0, &bRes), BSL_SUCCESS); // Check the decoded data with index 0.
ASSERT_EQ(bRes, boolData);
int iRes;
ASSERT_EQ(BSL_ASN1_DecodePrimitiveItem(decAns + 1, &iRes), BSL_SUCCESS); // Check the decoded data with index 1.
ASSERT_EQ(iRes, number);
BSL_ASN1_BitString bs2 = {0};
ASSERT_EQ(BSL_ASN1_DecodePrimitiveItem(decAns + 2, &bs2), BSL_SUCCESS); // Check the decoded data with index 2.
ASSERT_EQ(bs.unusedBits, unusedBits);
BSL_TIME time2 = {0};
ASSERT_EQ(BSL_ASN1_DecodePrimitiveItem(decAns + 5, &time2), BSL_SUCCESS); // Check the decoded data with index 5.
ASSERT_EQ(time2.year, year);
ASSERT_EQ(time2.month, month);
ASSERT_EQ(time2.day, day);
ASSERT_EQ(time2.hour, hour);
ASSERT_EQ(time2.minute, minute);
ASSERT_EQ(time2.second, second);
EXIT:
BSL_SAL_Free(integer.buff);
BSL_SAL_Free(encode);
}
/* END_CASE */
/**
* For test bmpString.
*/
/* BEGIN_CASE */
void SDV_BSL_ASN1_ENCODE_BMPSTRING_TC001(Hex *enc, char *dec)
{
int32_t ret;
BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BMPSTRING, enc->len, enc->x};
BSL_ASN1_Buffer decode = {BSL_ASN1_TAG_BMPSTRING, 0, NULL};
BSL_ASN1_Buffer encode = {0};
uint8_t tmp[10] = {0xff}; // select len 10.
BSL_ASN1_Buffer wrong = {BSL_ASN1_TAG_BMPSTRING, 10, tmp};
TestMemInit();
ret = BSL_ASN1_DecodePrimitiveItem(&asn, &decode);
ASSERT_EQ(ret, BSL_SUCCESS);
uint32_t decLen = (uint32_t)strlen(dec);
ASSERT_COMPARE("Decode String", decode.buff, decode.len, dec, decLen);
BSL_ASN1_TemplateItem testTempl[] = {
{BSL_ASN1_TAG_BMPSTRING, 0, 0}
};
BSL_ASN1_Template templ = {testTempl, sizeof(testTempl) / sizeof(testTempl[0])};
ret = BSL_ASN1_EncodeTemplate(&templ, &decode, 1, &encode.buff, &encode.len);
ASSERT_EQ(ret, BSL_SUCCESS);
ASSERT_COMPARE("Encode String", encode.buff + 2, encode.len - 2, enc->x, enc->len); // skip 2 bytes header
BSL_SAL_FREE(encode.buff);
ret = BSL_ASN1_EncodeTemplate(&templ, &wrong, 1, &encode.buff, &encode.len);
ASSERT_EQ(ret, BSL_INVALID_ARG);
EXIT:
BSL_SAL_FREE(decode.buff);
BSL_SAL_FREE(encode.buff);
return;
}
/* END_CASE */
/**
* @test SDV_BSL_ASN1_GET_ENCODE_LEN_FUNC_TC001
* @title Test BSL_ASN1_GetEncodeLen function
*/
/* BEGIN_CASE */
void SDV_BSL_ASN1_GET_ENCODE_LEN_FUNC_TC001(int contentLen, int expectLen, int ret)
{
uint32_t encodeLen = 0;
ASSERT_EQ(BSL_ASN1_GetEncodeLen(contentLen, &encodeLen), ret);
if (ret == BSL_SUCCESS) {
ASSERT_EQ(encodeLen, expectLen);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_ASN1_GET_ENCODE_LEN_API_TC001
* @title Test BSL_ASN1_GetEncodeLen abnormal input parameter
*/
/* BEGIN_CASE */
void SDV_BSL_ASN1_GET_ENCODE_LEN_API_TC001(void)
{
uint32_t encodeLen = 0;
// Test null pointer
ASSERT_EQ(BSL_ASN1_GetEncodeLen(1, NULL), BSL_NULL_INPUT);
// Test length overflow
ASSERT_EQ(BSL_ASN1_GetEncodeLen(UINT32_MAX, &encodeLen), BSL_ASN1_ERR_LEN_OVERFLOW);
EXIT:
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/bsl/asn1/test_suite_sdv_asn1.c
|
C
|
unknown
| 48,673
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_errno.h"
#include "bsl_base64.h"
#include "bsl_uio.h"
#include "bsl_base64.h"
/* END_HEADER */
static const uint8_t src_01[] = "123";
static const char encodeResult_01[] = "MTIz";
static const uint8_t src_02[] = "a";
static const char encodeResult_02[] = "YQ==";
static const uint8_t src_03[] = " ";
static const char encodeResult_03[] = "IA==";
static const uint8_t src_04[] = "\r";
static const char encodeResult_04[] = "DQ==";
static const uint8_t src_05[] = "\n";
static const char encodeResult_05[] = "Cg==";
static const uint8_t src_06[] = "\r\n";
static const char encodeResult_06[] = "DQo=";
static const uint8_t src_07[] = "bas64eVBFH2 46 JF \n 3274jg891 \n 12974";
static const char encodeResult_07[] = "YmFzNjRlVkJGSDIgNDYgSkYgICAKICAzMjc0amc4OTEgICAgCiAgMTI5NzQ=";
static const uint8_t src_08[] = "EIR234hdi234 0 idd3 12EH9kfhwu0914l 39u14109u4 8214 klhr184yu h "
"0923174 hfweh7e0124W R2342E\nWF9\niofh392 281h236891FHWY1990hf732";
static const char encodeResult_08[] =
"RUlSMjM0aGRpMjM0IDAgIGlkZDMgICAgIDEyRUg5a2Zod3UwOTE0bCAgIDM5dTE0MTA5dTQgICAgICAgIDgyMTQga2xocjE4NHl1IGggICAgMDkyMz"
"E3NCBoZndlaDdlMDEyNFcgIFIyMzQyRQpXRjkKaW9maDM5MiAgIDI4MWgyMzY4OTFGSFdZMTk5MGhmNzMy";
static const char encodeResult_08_withNL[] =
"RUlSMjM0aGRpMjM0IDAgIGlkZDMgICAgIDEyRUg5a2Zod3UwOTE0bCAgIDM5dTE0\nMTA5dTQgICAgICAgIDgyMTQga2xocjE4NHl1IGggICAgMDky"
"MzE3NCBoZndlaDdl\nMDEyNFcgIFIyMzQyRQpXRjkKaW9maDM5MiAgIDI4MWgyMzY4OTFGSFdZMTk5MGhm\nNzMy\n";
static const char encodeResult_09[] =
"YUVJUjIzNGhkaTIzNCAwICBpZGQzICAgICAxMkVIOWtmaHd1MDkxNGwgICAzOXUx\nNDEwOXU0ICAgICAgICA4MjE0IGtsaHIxODR5dSBoICAgIDA5"
"MjMxNzQgaGZ3ZWg3\nZTAxMjRXICBSMjM0MkUKV0Y5CmlvZmgzOTIgICAyODFoMjM2ODkxRkhXWTE5OTBo\nZjczMmJhczY0ZVZCRkgyIDQ2IEpGIC"
"AgCiAgMzI3NGpnODkxICAgIAogIDEyOTc0\n";
static const uint8_t src_09[] = "Base64编码和解码测试ChineseVersion";
static const uint8_t src_10[] = "ZnUzeWU4R0hFNzEzMjY0RU5EUUlZSFI4OWhoODlURjczVUhGRElVSDMyOThZZk5FMzE4aGQyODNlajMwNEg0";
static const uint8_t src_11[] =
"aEVXVURKRFE5MkVVMTkwMzcxMzBSSkkyM1VSMDkyMzIzNEQyMUUxMjhZM0UxODI5NEVZM05SRDMyUjI0MjM0RkdG";
static const uint8_t src_12[] =
"ZnUzeWU4R0hFNzEzMjY0RU5EUUlZSFI4OWhoODlURjczVUhGRElVSDMyOThZZk5FMzE4aGQyODNlajMwNEg0emY=";
static const uint8_t src_13[] = "fu3ye8GHE713264ENDQIYHR89hh89TF73UHFDIUH3298Yf";
static const uint8_t src_14[] = "fu3ye8GHE713264ENDQIYHR89hh89TF73UHFDIUH3298Yf2";
static const uint8_t src_15[] = "fu3ye8GHE713264ENDQIYHR89hh89TF73UHFDIUH3298Yf2k";
static const uint8_t src_16[] = "fu3ye8GHE713264ENDQIYHR89hh89TF73UHFDIUH3298YfNE318hd283ej304H";
static const uint8_t src_17[] = "fu3ye8GHE713264ENDQIYHR89hh89TF73UHFDIUH3298YfNE318hd283ej304Hf";
static const uint8_t src_18[] = "fu3ye8GHE713264ENDQIYHR89hh89TF73UHFDIUH3298YfNE318hd283ej304Hfe";
static const uint8_t src_19[] =
"HD13fdwCr23r2t4UI3QW1t2vs23F432R1FChfu3ye8GHE713264ENDQIYHR89hh89TF73UHFDIUH3298Yf23hoifdh3f9832yf3ihnfdkJM32RE832"
"URDOjdjOWIHFD9832RDJkwmdcOJD38E12U38RDHi3ndewifdh3uiry298398r3843nhrdkncihfhHR2398RE2RFQ32";
typedef struct {
const uint8_t *src;
const uint32_t srcLen;
const char *encodeResult;
const uint32_t encodeResultLen;
} BASE64_TEST_DATA;
static const BASE64_TEST_DATA testData[] = {
{
.src = src_01,
.srcLen = (const uint32_t)sizeof(src_01) - 1,
.encodeResult = encodeResult_01,
.encodeResultLen = (const uint32_t)sizeof(encodeResult_01) - 1,
},
{
.src = src_02,
.srcLen = (const uint32_t)sizeof(src_02) - 1,
.encodeResult = encodeResult_02,
.encodeResultLen = (const uint32_t)sizeof(encodeResult_02) - 1,
},
{
.src = src_03,
.srcLen = (const uint32_t)sizeof(src_03) - 1,
.encodeResult = encodeResult_03,
.encodeResultLen = (const uint32_t)sizeof(encodeResult_03) - 1,
},
{
.src = src_04,
.srcLen = (const uint32_t)sizeof(src_04) - 1,
.encodeResult = encodeResult_04,
.encodeResultLen = (const uint32_t)sizeof(encodeResult_04) - 1,
},
{
.src = src_05,
.srcLen = (const uint32_t)sizeof(src_05) - 1,
.encodeResult = encodeResult_05,
.encodeResultLen = (const uint32_t)sizeof(encodeResult_05) - 1,
},
{
.src = src_06,
.srcLen = (const uint32_t)sizeof(src_06) - 1,
.encodeResult = encodeResult_06,
.encodeResultLen = (const uint32_t)sizeof(encodeResult_06) - 1,
},
{
.src = src_07,
.srcLen = (const uint32_t)sizeof(src_07) - 1,
.encodeResult = encodeResult_07,
.encodeResultLen = (const uint32_t)sizeof(encodeResult_07) - 1,
},
{
.src = src_08,
.srcLen = (const uint32_t)sizeof(src_08) - 1,
.encodeResult = encodeResult_08,
.encodeResultLen = (const uint32_t)sizeof(encodeResult_08) - 1,
},
{
.src = src_09,
.srcLen = (const uint32_t)sizeof(src_09) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
{
.src = src_10,
.srcLen = (const uint32_t)sizeof(src_10) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
{
.src = src_11,
.srcLen = (const uint32_t)sizeof(src_11) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
{
.src = src_12,
.srcLen = (const uint32_t)sizeof(src_12) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
{
.src = src_13,
.srcLen = (const uint32_t)sizeof(src_13) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
{
.src = src_14,
.srcLen = (const uint32_t)sizeof(src_14) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
{
.src = src_15,
.srcLen = (const uint32_t)sizeof(src_15) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
{
.src = src_16,
.srcLen = (const uint32_t)sizeof(src_16) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
{
.src = src_17,
.srcLen = (const uint32_t)sizeof(src_17) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
{
.src = src_18,
.srcLen = (const uint32_t)sizeof(src_18) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
{
.src = src_19,
.srcLen = (const uint32_t)sizeof(src_19) - 1,
.encodeResult = NULL,
.encodeResultLen = 0,
},
};
static const int32_t testCnt = sizeof(testData) / sizeof(testData[0]);
/**
* @test SDV_BSL_BASE64_FUNC_TC001
* @spec -
* @title Block coding/decoding test
* @precon nan
* @brief 1. Call BSL_Base64Encode
2. Check whether the encoded result is correct.
3. Call BSL_Base64Decode
4. Check whether the decoded buffer is the same as the original buffer.
5. Check whether the decoded buffer length is the same as the original buffer length.
* @expect 1. BSL_SUCCESS
2. same
3. BSL_SUCCESS
4. same
5. same
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC001(void)
{
TestMemInit();
for (int32_t i = 0; i < 7; i++) {
const uint8_t *srcBuf = testData[i].src;
const uint32_t srcLen = testData[i].srcLen;
uint32_t encodeBufLen = HITLS_BASE64_ENCODE_LENGTH(srcLen);
char encodeBuf[encodeBufLen];
uint32_t decodeBufLen = HITLS_BASE64_DECODE_LENGTH(encodeBufLen);
uint8_t decodeBuf[decodeBufLen];
ASSERT_TRUE(BSL_BASE64_Encode(srcBuf, srcLen, encodeBuf, &encodeBufLen) == BSL_SUCCESS);
ASSERT_TRUE(memcmp((const char *)encodeBuf, testData[i].encodeResult, testData[i].encodeResultLen) == 0);
ASSERT_TRUE(encodeBufLen == testData[i].encodeResultLen);
ASSERT_TRUE(BSL_BASE64_Decode((const char *)encodeBuf, testData[i].encodeResultLen, decodeBuf,
&decodeBufLen) == BSL_SUCCESS);
ASSERT_TRUE(memcmp((const uint8_t *)decodeBuf, srcBuf, srcLen) == 0);
ASSERT_TRUE(decodeBufLen == srcLen);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_BASE64_FUNC_TC002
* @spec -
* @title Encoding and decoding test for short input streams without line breaks
* @precon nan
* @brief 1. Call BSL_Base64EncodeInit
2. Call BSL_Base64EncodeUpdate
3. Call BSL_Base64EncodeFinal
4. Check whether the encoded result is correct.
5. Check whether the encoded length is correct.
6. Call BSL_Base64DecodeInit
7. Call BSL_Base64DecodeUpdate
8. Call BSL_Base64DecodeFinal
9. Check whether the decoded buffer is the same as the original buffer.
10. Check whether the decoded buffer length is the same as the original buffer length.
* @expect 1. BSL_SUCCESS
2. BSL_SUCCESS
3. handling the tail
4. same
5. same
6. BSL_SUCCESS
7. BSL_SUCCESS
8. BSL_SUCCESS
9. same
10. same
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC002(void)
{
for (int32_t i = 0; i < 6; i++) {
const uint8_t *srcBuf = testData[i].src;
const uint32_t srcLen = testData[i].srcLen;
uint32_t encodeBufLen = HITLS_BASE64_ENCODE_LENGTH(srcLen);
char *encodeBuf = malloc(encodeBufLen);
uint32_t decodeBufLen = HITLS_BASE64_DECODE_LENGTH(encodeBufLen);
uint8_t *decodeBuf = malloc(HITLS_BASE64_DECODE_LENGTH(encodeBufLen));
uint32_t tmpLen = encodeBufLen;
uint32_t total = 0;
BSL_Base64Ctx *ctx = BSL_BASE64_CtxNew();
ASSERT_TRUE(encodeBuf != NULL);
ASSERT_TRUE(decodeBuf != NULL);
BSL_BASE64_EncodeInit(ctx);
BSL_BASE64_SetFlags(ctx, BSL_BASE64_FLAGS_NO_NEWLINE);
ASSERT_TRUE(BSL_BASE64_EncodeUpdate(ctx, srcBuf, srcLen, encodeBuf, &tmpLen) == BSL_SUCCESS);
encodeBufLen -= tmpLen;
total += tmpLen;
tmpLen = encodeBufLen;
ASSERT_TRUE(BSL_BASE64_EncodeFinal(ctx, encodeBuf + total, &tmpLen) == BSL_SUCCESS);
total += tmpLen;
ASSERT_TRUE(total == testData[i].encodeResultLen);
ASSERT_TRUE(memcmp((const char *)encodeBuf, testData[i].encodeResult, testData[i].encodeResultLen) == 0);
BSL_BASE64_CtxClear(ctx);
tmpLen = decodeBufLen;
BSL_BASE64_DecodeInit(ctx);
ASSERT_TRUE(BSL_BASE64_DecodeUpdate(ctx, encodeBuf, (const uint32_t)total, decodeBuf, &tmpLen) == BSL_SUCCESS);
total = 0;
decodeBufLen -= tmpLen;
total += tmpLen;
tmpLen = decodeBufLen;
ASSERT_TRUE(BSL_BASE64_DecodeFinal(ctx, decodeBuf + total, &tmpLen) == BSL_SUCCESS);
total += tmpLen;
ASSERT_TRUE(total == srcLen);
ASSERT_TRUE(memcmp((const uint8_t *)decodeBuf, srcBuf, srcLen) == 0);
free(encodeBuf);
free(decodeBuf);
BSL_BASE64_CtxFree(ctx);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_BASE64_FUNC_TC003
* @spec -
* @title Encoding test for long input streams that require line breaks
* @precon nan
* @brief 1. Call BSL_Base64EncodeInit
2. Call BSL_Base64EncodeUpdate
3. Call BSL_Base64EncodeFinal
4. Check whether the encoded result is correct.
5. Check whether the encoded length is correct.
* @expect 1. BSL_SUCCESS
2. BSL_SUCCESS
3. handling the tail
4. same
5. same
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC003(void)
{
const uint8_t *srcBuf = src_08;
const uint32_t srcLen = (const uint32_t)sizeof(src_08) - 1;
uint32_t encodeBufLen = HITLS_BASE64_ENCODE_LENGTH(srcLen);
char *encodeBuf = malloc(encodeBufLen);
uint32_t tmpLen = encodeBufLen;
uint32_t total = 0;
BSL_Base64Ctx *ctx = BSL_BASE64_CtxNew();
ASSERT_TRUE(encodeBuf != NULL);
BSL_BASE64_EncodeInit(ctx);
ASSERT_TRUE(BSL_BASE64_EncodeUpdate(ctx, srcBuf, srcLen, encodeBuf, &tmpLen) == BSL_SUCCESS);
encodeBufLen -= tmpLen;
total += tmpLen;
tmpLen = encodeBufLen;
// encode and check tail for consistency, encodeBuf tail has\n
ASSERT_TRUE(BSL_BASE64_EncodeFinal(ctx, encodeBuf + total, &tmpLen) == BSL_SUCCESS);
total += tmpLen;
ASSERT_TRUE(total == sizeof(encodeResult_08_withNL) - 1);
ASSERT_TRUE(memcmp((const char *)encodeBuf, encodeResult_08_withNL, total) == 0);
EXIT:
free(encodeBuf);
BSL_BASE64_CtxFree(ctx);
}
/* END_CASE */
/**
* @test SDV_BSL_BASE64_FUNC_TC004
* @spec -
* @title Decoding test for long input streams that require line breaks
* @precon nan
* @brief 1. Call BSL_Base64DecodeInit
2. Call BSL_Base64DecodeUpdate
3. Call BSL_Base64DecodeFinal
4. Check whether the decoded buffer is the same as the original buffer.
5. Check whether the decoded buffer length is the same as the original buffer length.
* @expect 1. BSL_SUCCESS
2. BSL_SUCCESS
3. BSL_SUCCESS
4. same
5. same
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC004(void)
{
const uint8_t *srcBuf = src_08;
const uint32_t srcLen = (const uint32_t)sizeof(src_08) - 1;
uint32_t encodeBufLen = sizeof(encodeResult_08_withNL) - 1;
uint32_t decodeBufLen = HITLS_BASE64_DECODE_LENGTH(encodeBufLen);
uint8_t *decodeBuf = malloc(decodeBufLen);
uint32_t tmpLen = decodeBufLen;
uint32_t total = 0;
BSL_Base64Ctx *ctx = BSL_BASE64_CtxNew();
ASSERT_TRUE(decodeBuf != NULL);
BSL_BASE64_DecodeInit(ctx);
ASSERT_TRUE(BSL_BASE64_DecodeUpdate(ctx, encodeResult_08_withNL, encodeBufLen, decodeBuf, &tmpLen) == BSL_SUCCESS);
encodeBufLen -= tmpLen;
total += tmpLen;
tmpLen = encodeBufLen;
ASSERT_TRUE(BSL_BASE64_DecodeFinal(ctx, decodeBuf + total, &tmpLen) == BSL_SUCCESS);
total += tmpLen;
ASSERT_TRUE(total == srcLen);
ASSERT_TRUE(memcmp((const uint8_t *)decodeBuf, srcBuf, total) == 0);
EXIT:
free(decodeBuf);
BSL_BASE64_CtxFree(ctx);
}
/* END_CASE */
/**
* @test SDV_BSL_BASE64_FUNC_TC005
* @spec -
* @title Encoding and decoding test of the block that generates errors
* @precon nan
* @brief 1. Call BSL_Base64Encode
2. Check whether the encoded result is correct.
3. Call BSL_Base64Decode
4. Check whether the decoded buffer is the same as the original buffer.
5. Check whether the decoded buffer length is the same as the original buffer length.
* @expect 1. BSL_SUCCESS
2. same
3. BSL_SUCCESS
4. same
5. same
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC005(void)
{
const char illEncodeResult[] = "MT-1";
uint8_t decodeBuf[4] = {0};
uint32_t decodeBufLen = HITLS_BASE64_DECODE_LENGTH(4);
ASSERT_TRUE(BSL_BASE64_Decode(illEncodeResult, 4, decodeBuf, &decodeBufLen) != BSL_SUCCESS);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_BASE64_FUNC_TC006
* @spec -
* @title Stream Decoding Test with Errors
* @precon nan
* @brief 1. Call BSL_Base64DecodeInit
2. Call BSL_Base64DecodeUpdate
3. Call BSL_Base64DecodeUpdate
* @expect 1. BSL_SUCCESS
2. data after padding error
3. EOF Error in Middle of Block
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC006(void)
{
const char illEncodeResult_1[] = "MT=1";
const char illEncodeResult_2[] = "MT-1";
const char illEncodeResult_3[] = "MT#1";
uint32_t decodeBufLen = HITLS_BASE64_DECODE_LENGTH(4);
uint8_t *decodeBuf = malloc(decodeBufLen);
ASSERT_TRUE(decodeBuf != NULL);
BSL_Base64Ctx *ctx = BSL_BASE64_CtxNew();
BSL_BASE64_SetFlags(ctx, BSL_BASE64_FLAGS_NO_NEWLINE);
BSL_BASE64_DecodeInit(ctx);
ASSERT_TRUE(BSL_BASE64_DecodeUpdate(ctx, illEncodeResult_1, sizeof(illEncodeResult_1),
decodeBuf, &decodeBufLen) == BSL_BASE64_DATA_AFTER_PADDING);
BSL_BASE64_CtxClear(ctx);
BSL_BASE64_DecodeInit(ctx);
/* If the BSL interface is not invoked to parse the PEM file, the returned value is an error code. */
ASSERT_TRUE(BSL_BASE64_DecodeUpdate(ctx, illEncodeResult_2, sizeof(illEncodeResult_2),
decodeBuf, &decodeBufLen) == BSL_BASE64_HEADER);
BSL_BASE64_CtxClear(ctx);
BSL_BASE64_DecodeInit(ctx);
ASSERT_TRUE(BSL_BASE64_DecodeUpdate(ctx, illEncodeResult_3, sizeof(illEncodeResult_3),
decodeBuf, &decodeBufLen) == BSL_INVALID_ARG);
EXIT:
free(decodeBuf);
BSL_BASE64_CtxFree(ctx);
}
/* END_CASE */
/**
* @test SDV_BSL_BASE64_FUNC_TC007
* @spec -
* @title Empty input test
* @precon nan
* @brief 1. Call BSL_Base64Encode
2. Call BSL_Base64Encode
3. Call BSL_Base64Decode
4. Call BSL_Base64Decode
5. Call BSL_Base64EncodeUpdate
6. Call BSL_Base64EncodeFinal
7. Call BSL_Base64DecodeUpdate
8. Call BSL_Base64DecodeFinal
* @expect 1. BSL_NULL_INPUT
2. dstBufLen is insufficient:BSL_BASE64_BUF_NOT_ENOUGH
3. BSL_NULL_INPUT
4. dstBufLen is insufficient:BSL_BASE64_BUF_NOT_ENOUGH
5. BSL_NULL_INPUT
6. BSL_SUCCESS
7. BSL_NULL_INPUT
8. BSL_SUCCESS
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC007(void)
{
uint32_t zeroLen = 0;
const uint32_t srcLen = (const uint32_t)sizeof(src_01);
uint32_t encodeBufLen = HITLS_BASE64_ENCODE_LENGTH(srcLen);
char *encodeBuf = malloc(encodeBufLen);
uint32_t decodeBufLen = HITLS_BASE64_DECODE_LENGTH(encodeBufLen);
uint8_t *decodeBuf = malloc(decodeBufLen);
ASSERT_TRUE(encodeBuf != NULL);
ASSERT_TRUE(decodeBuf != NULL);
/* Block codec empty input test */
ASSERT_TRUE(BSL_BASE64_Encode(NULL, zeroLen, encodeBuf, &encodeBufLen) == BSL_NULL_INPUT);
ASSERT_TRUE(BSL_BASE64_Encode(src_01, sizeof(src_01) - 1, encodeBuf, &zeroLen) == BSL_BASE64_BUF_NOT_ENOUGH);
ASSERT_TRUE(BSL_BASE64_Decode(NULL, 0, decodeBuf, &decodeBufLen) == BSL_NULL_INPUT);
ASSERT_TRUE(BSL_BASE64_Decode(encodeResult_01, 4, decodeBuf, &zeroLen) == BSL_BASE64_BUF_NOT_ENOUGH);
/* Stream encoding/decoding empty input test */
BSL_Base64Ctx *ctx = BSL_BASE64_CtxNew();
BSL_BASE64_EncodeInit(ctx);
ASSERT_TRUE(BSL_BASE64_EncodeUpdate(ctx, NULL, zeroLen, encodeBuf, &encodeBufLen) == BSL_NULL_INPUT);
ASSERT_TRUE(BSL_BASE64_EncodeFinal(ctx, encodeBuf, &encodeBufLen) == BSL_SUCCESS);
BSL_BASE64_CtxClear(ctx);
BSL_BASE64_DecodeInit(ctx);
ASSERT_TRUE(BSL_BASE64_DecodeUpdate(ctx, NULL, (const uint32_t)encodeBufLen,
decodeBuf, &decodeBufLen) == BSL_NULL_INPUT);
ASSERT_TRUE(BSL_BASE64_DecodeFinal(ctx, decodeBuf, &decodeBufLen) == BSL_SUCCESS);
EXIT:
free(encodeBuf);
free(decodeBuf);
BSL_BASE64_CtxFree(ctx);
}
/* END_CASE */
/**
* @test SDV_BSL_BASE64_FUNC_TC008
* @spec -
* @title Multiple update tests
* @precon nan
* @brief 1. Call BSL_Base64EncodeUpdate
2. Call BSL_Base64EncodeUpdate
3. Call BSL_Base64EncodeUpdate
4. Call BSL_Base64EncodeFinal
5. Call BSL_Base64DecodeUpdate
6. Call BSL_Base64DecodeUpdate
7. Call BSL_Base64DecodeUpdate
8. Call BSL_Base64DecodeFinal
* @expect 1. BSL_SUCCESS -> The data is not encoded and is cached in the buffer. dstBufLen is set to 0.
2. BSL_SUCCESS
3. BSL_SUCCESS -> 3 + 44 < 48, The srcBuf is shorter than the length of a buffer. The data is cached in the
buffer, and dstBufLen is set to 0.
4. BSL_SUCCESS -> Handles 3 + 44 characters
5. BSL_SUCCESS -> Data that is not decoded is stored in the buffer, and dstBufLen is set to 0.
6. BSL_SUCCESS
7. BSL_SUCCESS
8. BSL_SUCCESS
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC008(void)
{
uint32_t srcLen = testData[0].srcLen + testData[7].srcLen + testData[6].srcLen;
uint32_t encodeBufLen = HITLS_BASE64_ENCODE_LENGTH(srcLen);
char *encodeBuf = malloc(encodeBufLen);
uint32_t decodeBufLen = HITLS_BASE64_DECODE_LENGTH(encodeBufLen);
uint8_t *decodeBuf = malloc(HITLS_BASE64_DECODE_LENGTH(encodeBufLen));
/*
* The output parameter dstBufLen needs to be updated in real time when the update operation is performed for
* multiple times.
*/
uint32_t tmpLen = encodeBufLen;
uint32_t total = 0;
ASSERT_TRUE(encodeBuf != NULL);
ASSERT_TRUE(decodeBuf != NULL);
/* encode */
BSL_Base64Ctx *ctx = BSL_BASE64_CtxNew();
BSL_BASE64_EncodeInit(ctx);
ASSERT_TRUE(BSL_BASE64_EncodeUpdate(ctx, testData[1].src, testData[1].srcLen, encodeBuf, &tmpLen) ==
BSL_SUCCESS); /* 1bytes */
encodeBufLen -= tmpLen;
total += tmpLen;
tmpLen = encodeBufLen;
ASSERT_TRUE(BSL_BASE64_EncodeUpdate(ctx, testData[7].src, testData[7].srcLen, encodeBuf + total, &tmpLen) ==
BSL_SUCCESS); /* 147bytes */
encodeBufLen -= tmpLen;
total += tmpLen;
tmpLen = encodeBufLen;
ASSERT_TRUE(BSL_BASE64_EncodeUpdate(ctx, testData[6].src, testData[6].srcLen, encodeBuf + total, &tmpLen) ==
BSL_SUCCESS); /* 44bytes */
encodeBufLen -= tmpLen;
total += tmpLen;
tmpLen = encodeBufLen;
ASSERT_TRUE(BSL_BASE64_EncodeFinal(ctx, encodeBuf + total, &tmpLen) == BSL_SUCCESS);
total += tmpLen;
ASSERT_TRUE((sizeof(encodeResult_09) - 1) == total);
ASSERT_TRUE(memcmp((const char *)encodeBuf, encodeResult_09, total) == 0);
BSL_BASE64_CtxClear(ctx);
/* decode */
tmpLen = decodeBufLen;
total = 0;
BSL_BASE64_DecodeInit(ctx);
ASSERT_TRUE(BSL_BASE64_DecodeUpdate(ctx, testData[0].encodeResult,
(const uint32_t)testData[0].encodeResultLen, decodeBuf, &tmpLen) == BSL_SUCCESS); /* 4bytes */
decodeBufLen -= tmpLen;
total += tmpLen;
tmpLen = decodeBufLen;
ASSERT_TRUE(BSL_BASE64_DecodeUpdate(ctx, testData[7].encodeResult,
(const uint32_t)testData[7].encodeResultLen, decodeBuf + total, &tmpLen) == BSL_SUCCESS); /* 196bytes */
decodeBufLen -= tmpLen;
total += tmpLen;
tmpLen = decodeBufLen;
ASSERT_TRUE(BSL_BASE64_DecodeUpdate(ctx, testData[6].encodeResult,
(const uint32_t)testData[6].encodeResultLen, decodeBuf + total, &tmpLen) == BSL_SUCCESS); /* 60bytes */
decodeBufLen -= tmpLen;
total += tmpLen;
tmpLen = decodeBufLen;
ASSERT_TRUE(BSL_BASE64_DecodeFinal(ctx, decodeBuf + total, &tmpLen) == BSL_SUCCESS);
total += tmpLen;
ASSERT_TRUE(srcLen == total);
EXIT:
free(encodeBuf);
free(decodeBuf);
BSL_BASE64_CtxFree(ctx);
}
/* END_CASE */
void Base64BlockEncDec(const uint8_t *buf, const uint32_t len)
{
const uint8_t *src = buf;
const uint32_t srcLen = len;
uint32_t hitlsEncLen = HITLS_BASE64_ENCODE_LENGTH(len);
char *hitlsEncResult = BSL_SAL_Malloc(hitlsEncLen);
uint32_t hitlsDecLen = HITLS_BASE64_DECODE_LENGTH(hitlsEncLen);
uint8_t *hitlsDecResult = BSL_SAL_Malloc(hitlsDecLen);
TRUE_OR_EXIT(BSL_BASE64_Encode(src, srcLen, hitlsEncResult, &hitlsEncLen) == BSL_SUCCESS);
TRUE_OR_EXIT(BSL_BASE64_Decode(hitlsEncResult, hitlsEncLen, hitlsDecResult, &hitlsDecLen) == BSL_SUCCESS);
TRUE_OR_EXIT(hitlsDecLen == srcLen);
EXIT:
BSL_SAL_Free(hitlsEncResult);
BSL_SAL_Free(hitlsDecResult);
}
/**
* @test SDV_BSL_BASE64_FUNC_TC009
* @spec -
* @title Block coding/decoding test
* @precon nan
* @brief 1. Call BSL_Base64Encode/EVP_EncodeBlock
2. Check whether the encoded result is correct.
3. Call BSL_Base64Decode/EVP_DecodeBlock
4. Check whether the decoded buffer is the same as the original buffer.
5. Check whether the decoded buffer length is the same as the original buffer length.
* @expect 1. Succeeded
2. same
3. Succeeded
4. same
5. same
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC009(void)
{
Base64BlockEncDec(testData[0].src, testData[0].srcLen);
for (int i = 8; i < testCnt; i++) {
Base64BlockEncDec(testData[i].src, testData[i].srcLen);
}
}
/* END_CASE */
void Base64Stream(const uint8_t *buf, const uint32_t len)
{
const uint8_t *src = buf;
const uint32_t srcLen = len;
uint32_t hitlsEncLen = HITLS_BASE64_ENCODE_LENGTH(len);
char *hitlsEncResult = BSL_SAL_Malloc(hitlsEncLen);
uint32_t hitlsDecLen = HITLS_BASE64_DECODE_LENGTH(hitlsEncLen);
uint8_t *hitlsDecResult = BSL_SAL_Malloc(hitlsDecLen);
/* encode */
// hitls stream encoding
uint32_t tmpLen = hitlsEncLen;
uint32_t total = 0;
BSL_Base64Ctx *ctx = BSL_BASE64_CtxNew();
BSL_BASE64_EncodeInit(ctx);
TRUE_OR_EXIT(BSL_BASE64_EncodeUpdate(ctx, src, srcLen, hitlsEncResult, &tmpLen) == BSL_SUCCESS);
hitlsEncLen -= tmpLen;
total += tmpLen;
tmpLen = hitlsEncLen;
TRUE_OR_EXIT(BSL_BASE64_EncodeFinal(ctx, hitlsEncResult + total, &tmpLen) == BSL_SUCCESS);
total += tmpLen;
/* decode */
// hitls stream encoding
BSL_BASE64_CtxClear(ctx);
tmpLen = hitlsDecLen;
BSL_BASE64_DecodeInit(ctx);
TRUE_OR_EXIT(BSL_BASE64_DecodeUpdate(ctx, hitlsEncResult, (const uint32_t)total, hitlsDecResult, &tmpLen) ==
BSL_SUCCESS);
total = 0;
hitlsDecLen -= tmpLen;
total += tmpLen;
tmpLen = hitlsDecLen;
TRUE_OR_EXIT(BSL_BASE64_DecodeFinal(ctx, hitlsDecResult + total, &tmpLen) == BSL_SUCCESS);
total += tmpLen;
EXIT:
BSL_SAL_Free(hitlsEncResult);
BSL_SAL_Free(hitlsDecResult);
BSL_BASE64_CtxFree(ctx);
}
/**
* @test SDV_BSL_BASE64_FUNC_TC010
* @spec -
* @title Single-flow encoding/decoding test
* @precon nan
* @brief 1. Call BSL_Base64EncodeInit/EVP_EncodeInit
2. Call BSL_Base64EncodeUpdate/EVP_EncodeUpdate
3. Call BSL_Base64EncodeFinal/EVP_EncodeFinal
4. Check whether the encoded result is correct.
5. Check whether the encoded length is correct.
6. Call BSL_Base64DecodeInit/EVP_DecodeInit
7. Call BSL_Base64DecodeUpdate/EVP_DecodeUpdate
8. Call BSL_Base64DecodeFinal/EVP_DecodeFinal
9. Check whether the decoded buffer is the same as the original buffer.
10. Check whether the decoded buffer length is the same as the original buffer length.
* @expect 1. Succeeded
2. BSL_SUCCESS
3. handling the tail
4. same
5. same
6. Succeeded
7. BSL_SUCCESS
8. BSL_SUCCESS
9. same
10. same
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC010(void)
{
for (int i = 0; i < testCnt; i++) {
Base64Stream(testData[i].src, testData[i].srcLen);
}
}
/* END_CASE */
void Base64StreamMultiUpdate(const BASE64_TEST_DATA data[])
{
uint32_t hitlsEncLen = HITLS_BASE64_ENCODE_LENGTH(512);
char *hitlsEncResult = malloc(hitlsEncLen);
uint32_t hitlsDecLen = HITLS_BASE64_DECODE_LENGTH(hitlsEncLen);
uint8_t *hitlsDecResult = malloc(hitlsDecLen);
/* encode */
// hitls stream encoding
uint32_t tmpLen = hitlsEncLen;
uint32_t total = 0;
BSL_Base64Ctx *ctx = BSL_BASE64_CtxNew();
ASSERT_TRUE(hitlsEncResult != NULL);
ASSERT_TRUE(hitlsDecResult != NULL);
BSL_BASE64_EncodeInit(ctx);
TRUE_OR_EXIT(BSL_BASE64_EncodeUpdate(ctx, data[12].src, data[12].srcLen, hitlsEncResult, &tmpLen) == BSL_SUCCESS);
hitlsEncLen -= tmpLen;
total += tmpLen;
tmpLen = hitlsEncLen;
TRUE_OR_EXIT(BSL_BASE64_EncodeUpdate(ctx, data[13].src, data[13].srcLen, hitlsEncResult + total, &tmpLen) ==
BSL_SUCCESS);
hitlsEncLen -= tmpLen;
total += tmpLen;
tmpLen = hitlsEncLen;
TRUE_OR_EXIT(BSL_BASE64_EncodeUpdate(ctx, data[14].src, data[14].srcLen, hitlsEncResult + total, &tmpLen) ==
BSL_SUCCESS);
hitlsEncLen -= tmpLen;
total += tmpLen;
tmpLen = hitlsEncLen;
TRUE_OR_EXIT(BSL_BASE64_EncodeFinal(ctx, hitlsEncResult + total, &tmpLen) == BSL_SUCCESS);
total += tmpLen;
/* decode */
// hitls stream encoding
BSL_BASE64_CtxClear(ctx);
total = 0;
tmpLen = hitlsDecLen;
BSL_BASE64_DecodeInit(ctx);
TRUE_OR_EXIT(BSL_BASE64_DecodeUpdate(ctx, (const char *)data[9].src, data[9].srcLen, hitlsDecResult, &tmpLen) ==
BSL_SUCCESS);
hitlsDecLen -= tmpLen;
total += tmpLen;
tmpLen = hitlsDecLen;
TRUE_OR_EXIT(BSL_BASE64_DecodeUpdate(ctx, (const char *)data[10].src, data[10].srcLen, hitlsDecResult + total,
&tmpLen) == BSL_SUCCESS);
hitlsDecLen -= tmpLen;
total += tmpLen;
tmpLen = hitlsDecLen;
TRUE_OR_EXIT(BSL_BASE64_DecodeUpdate(ctx, (const char *)data[11].src, data[11].srcLen, hitlsDecResult + total,
&tmpLen) == BSL_SUCCESS);
hitlsDecLen -= tmpLen;
total += tmpLen;
tmpLen = hitlsDecLen;
TRUE_OR_EXIT(BSL_BASE64_DecodeFinal(ctx, hitlsDecResult + total, &tmpLen) == BSL_SUCCESS);
total += tmpLen;
EXIT:
free(hitlsEncResult);
free(hitlsDecResult);
BSL_BASE64_CtxFree(ctx);
}
/**
* @test SDV_BSL_BASE64_FUNC_TC011
* @spec -
* @title Multiple update tests
* @precon nan
* @brief 1. Call BSL_Base64EncodeUpdate/EVP_EncodeUpdate
2. Call BSL_Base64EncodeUpdate/EVP_EncodeUpdate
3. Call BSL_Base64EncodeUpdate/EVP_EncodeUpdate
4. Call BSL_Base64EncodeFinal/EVP_EncodeFinal
5. memcmp encode result
6. Call BSL_Base64DecodeUpdate/EVP_DecodeUpdate
7. Call BSL_Base64DecodeUpdate/EVP_DecodeUpdate
8. Call BSL_Base64DecodeUpdate/EVP_DecodeUpdate
9. Call BSL_Base64DecodeFinal/EVP_DecodeFinal
10. memcmp decode result
* @expect 1.2.3.4. succeeded
5.same
6.7.8.9. succeeded
10.same
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC011(void)
{
Base64StreamMultiUpdate(testData);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_BASE64_FUNC_TC012(char *src, int expectRes)
{
uint32_t srcBufLen = strlen(src);
uint32_t dstBufLen = HITLS_BASE64_DECODE_LENGTH(srcBufLen);
uint8_t *dst = BSL_SAL_Malloc(dstBufLen);
ASSERT_TRUE(dst != NULL);
ASSERT_EQ(BSL_BASE64_Decode(src, srcBufLen, dst, &dstBufLen), (int32_t)expectRes);
EXIT:
BSL_SAL_Free(dst);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/bsl/base64/test_suite_sdv_base64.c
|
C
|
unknown
| 31,687
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "bsl_buffer.h"
/* END_HEADER */
/* BEGIN_CASE */
void SDV_BSL_BUFFER_FUNC_buffer_new(void)
{
TestMemInit();
// 1. Allocate a buffer.
BSL_BufMem *buf = BSL_BufMemNew();
ASSERT_EQ(buf->length, 0);
ASSERT_EQ(buf->max, 0);
// 2. len=3, len > buf->max
(void)BSL_BufMemGrowClean(buf, 3);
ASSERT_EQ(buf->length, 3);
ASSERT_EQ(buf->max, 8);
// 3. len=2, len < buf->length
(void)BSL_BufMemGrowClean(buf, 2);
ASSERT_EQ(buf->length, 2);
ASSERT_EQ(buf->max, 8);
// 4. len=6, buf->length < len < buf->max
(void)BSL_BufMemGrowClean(buf, 6);
ASSERT_EQ(buf->length, 6);
ASSERT_EQ(buf->max, 8);
EXIT:
BSL_BufMemFree(buf);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/bsl/buffer/test_suite_sdv_buffer.c
|
C
|
unknown
| 1,270
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "bsl_err.h"
#include "avl.h"
#include "bsl_uio.h"
static int32_t PthreadRWLockNew(BSL_SAL_ThreadLockHandle *lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
pthread_rwlock_t *newLock;
newLock = (pthread_rwlock_t *)BSL_SAL_Malloc(sizeof(pthread_rwlock_t));
if (newLock == NULL) {
return BSL_MALLOC_FAIL;
}
if (pthread_rwlock_init(newLock, NULL) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
*lock = newLock;
return BSL_SUCCESS;
}
static void PthreadRWLockFree(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return;
}
pthread_rwlock_destroy((pthread_rwlock_t *)lock);
BSL_SAL_FREE(lock);
}
static int32_t PthreadRWLockReadLock(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
if (pthread_rwlock_rdlock((pthread_rwlock_t *)lock) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
return BSL_SUCCESS;
}
static int32_t PthreadRWLockWriteLock(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
if (pthread_rwlock_wrlock((pthread_rwlock_t *)lock) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
return BSL_SUCCESS;
}
static int32_t PthreadRWLockUnlock(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
if (pthread_rwlock_unlock((pthread_rwlock_t *)lock) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
return BSL_SUCCESS;
}
static uint64_t PthreadGetId(void)
{
return (uint64_t)pthread_self();
}
static void PushErrorFixTimes(int32_t times)
{
while (times) {
BSL_ERR_PUSH_ERROR(times);
times--;
}
}
static void RegThreadFunc(void)
{
BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_NEW_CB_FUNC, PthreadRWLockNew);
BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_FREE_CB_FUNC, PthreadRWLockFree);
BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_READ_LOCK_CB_FUNC, PthreadRWLockReadLock);
BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_WRITE_LOCK_CB_FUNC, PthreadRWLockWriteLock);
BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_UNLOCK_CB_FUNC, PthreadRWLockUnlock);
BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_GET_ID_CB_FUNC, PthreadGetId);
}
/* END_HEADER */
/**
* @test SDV_BSL_ERR_FUNC_TC001
* @title Error code test in single-thread mode
* @precon Set the memory allocation and release functions.
* @brief
* 1. Initializes BSL_ERR. Expected result 1 is obtained.
* 2. Invoke the interface to obtain the error when no error is pushed. Expected result 2 is obtained.
* 3. Push an BSL_UIO_FAIL error when no memory function is registered. Expected result 3 is obtained.
* 4. Push the BSL_UIO_FAIL and BSL_UIO_IO_EXCEPTION error and obtain last error. Expected result 4 is obtained.
* 5. Peek last error file and error line. Expected result 5 is obtained.
* 6. Get last error file and error line. Expected result 6 is obtained.
* 7. Push an error after clear the error stack, and then obtain the error. Expected result 7 is obtained.
* 8. Delete the error stack of the thread. Expected result 8 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2. BSL_SUCCESS
* 3. BSL_UIO_FAIL
* 4. BSL_UIO_IO_EXCEPTION
* 5. BSL_UIO_FAIL
* 6. BSL_UIO_FAIL
* 7. BSL_SUCCESS
* 8. BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_ERR_FUNC_TC001(void)
{
TestMemInit();
int32_t err;
ASSERT_TRUE(BSL_ERR_Init() == BSL_SUCCESS);
/* no error is pushed */
ASSERT_TRUE(BSL_ERR_GetLastError() == BSL_SUCCESS);
/* If no memory function is registered, push an error and allocate an error stack. */
BSL_ERR_PushError(BSL_UIO_FAIL, __FILENAME__, __LINE__);
ASSERT_TRUE(BSL_ERR_GetLastError() == BSL_UIO_FAIL);
/* Push the BSL_UIO_FAIL and BSL_UIO_IO_EXCEPTION error to the error stack. */
BSL_ERR_PushError(BSL_UIO_FAIL, __FILENAME__, __LINE__);
BSL_ERR_PushError(BSL_UIO_IO_EXCEPTION, __FILENAME__, __LINE__);
err = BSL_ERR_GetLastError();
ASSERT_TRUE(err == BSL_UIO_IO_EXCEPTION);
const char *file = NULL;
uint32_t line = 0;
err = BSL_ERR_PeekLastErrorFileLine(&file, &line);
ASSERT_TRUE(err == BSL_UIO_FAIL);
ASSERT_TRUE(strcmp(file, __FILENAME__) == 0);
file = NULL;
line = 0;
err = BSL_ERR_GetLastErrorFileLine(&file, &line);
ASSERT_TRUE(err == BSL_UIO_FAIL);
ASSERT_TRUE(strcmp(file, __FILENAME__) == 0);
ASSERT_TRUE(BSL_ERR_GetLastError() == BSL_SUCCESS);
BSL_ERR_PushError(BSL_UIO_FAIL, __FILENAME__, __LINE__);
BSL_ERR_ClearError();
ASSERT_TRUE(BSL_ERR_GetLastError() == BSL_SUCCESS);
BSL_ERR_RemoveErrorStack(false);
ASSERT_TRUE(BSL_ERR_GetLastError() == BSL_SUCCESS);
EXIT:
BSL_ERR_DeInit();
return;
}
/* END_CASE */
/**
* @test SDV_BSL_ERR_STACK_FUNC_TC001
* @title After stacks are not pushed or cleared, call BSL_ERR_GetLastError to query all error stacks.
* @precon nan
* @brief
* 1. Call BSL_SAL_CallBack_Ctrl to initialize the memory. Expected result 1 is obtained.
* 2. Call BSL_SAL_CallBack_Ctrl to initialize the thread. Expected result 2 is obtained.
* 3. Call BSL_ERR_Init for initialization. Expected result 3 is obtained.
* 4. Call BSL_ERR_GetLastError to obtain stack information. Expected result 4 is obtained.
* 5. Call ERR_PUSH_ERROR to push stack layer 5. Expected result 5 is obtained.
* 6. Call BSL_ERR_ClearError to clear the stack. Expected result 6 is obtained.
* 7. Call BSL_ERR_GetLastError to obtain stack information. Expected result 7 is obtained.
* 8. Call BSL_ERR_RemoveErrorStack to delete the stack. Expected result 8 is obtained.
* 9. Call BSL_ERR_GetLastError to obtain stack information. Expected result 9 is obtained.
* 10. Call BSL_ERR_DeInit to deinitialize. Expected result 10 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2. BSL_SUCCESS
* 3. BSL_SUCCESS
* 4. BSL_SUCCESS is returned when the error code is obtained.
* 5. BSL_SUCCESS
* 6. BSL_SUCCESS
* 7. BSL_SUCCESS is returned when the error code is obtained.
* 8. BSL_SUCCESS
* 9. BSL_SUCCESS is returned when the error code is obtained.
* 10. BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_ERR_STACK_FUNC_TC001(int isRemoveAll)
{
TestMemInit();
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_NEW_CB_FUNC, PthreadRWLockNew) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_FREE_CB_FUNC, PthreadRWLockFree) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_READ_LOCK_CB_FUNC, PthreadRWLockReadLock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_WRITE_LOCK_CB_FUNC, PthreadRWLockWriteLock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_UNLOCK_CB_FUNC, PthreadRWLockUnlock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_GET_ID_CB_FUNC, PthreadGetId) == BSL_SUCCESS);
ASSERT_TRUE(BSL_ERR_Init() == BSL_SUCCESS);
ASSERT_TRUE(BSL_ERR_GetLastError() == BSL_SUCCESS);
PushErrorFixTimes(5);
ASSERT_TRUE(BSL_ERR_PeekLastErrorFileLine(NULL, NULL) == 1);
ASSERT_TRUE(BSL_ERR_GetLastErrorFileLine(NULL, NULL) == 1);
ASSERT_TRUE(BSL_ERR_GetErrorFileLine(NULL, NULL) == 5);
BSL_ERR_ClearError();
ASSERT_TRUE(BSL_ERR_GetLastError() == BSL_SUCCESS);
BSL_ERR_RemoveErrorStack((isRemoveAll == 1) ? true : false);
ASSERT_TRUE(BSL_ERR_GetLastError() == BSL_SUCCESS);
BSL_ERR_PushError(1, "2", 3);
uint32_t lineNo = 0;
char *file = NULL;
ASSERT_TRUE(BSL_ERR_PeekLastErrorFileLine(NULL, &lineNo) == 1);
ASSERT_TRUE(lineNo == 0);
ASSERT_TRUE(BSL_ERR_PeekErrorFileLine(NULL, &lineNo) == 1);
ASSERT_TRUE(lineNo == 0);
ASSERT_TRUE(BSL_ERR_PeekLastErrorFileLine((const char **)&file, &lineNo) == 1);
ASSERT_TRUE(strcmp(file, "2") == 0);
ASSERT_TRUE(lineNo == 3);
lineNo = 0;
ASSERT_TRUE(BSL_ERR_PeekErrorFileLine((const char **)&file, &lineNo) == 1);
ASSERT_TRUE(strcmp(file, "2") == 0);
ASSERT_TRUE(lineNo == 3);
ASSERT_TRUE(BSL_ERR_GetError() == 1);
BSL_ERR_PUSH_ERROR(BSL_SUCCESS);
lineNo = 0;
BSL_ERR_PushError(1, NULL, 3);
ASSERT_TRUE(BSL_ERR_PeekLastErrorFileLine(NULL, &lineNo) == 1);
ASSERT_TRUE(lineNo == 0);
ASSERT_TRUE(BSL_ERR_PeekErrorFileLine(NULL, &lineNo) == 1);
ASSERT_TRUE(lineNo == 0);
ASSERT_TRUE(BSL_ERR_PeekLastErrorFileLine((const char **)&file, &lineNo) == 1);
ASSERT_TRUE(strcmp(file, "NA") == 0);
ASSERT_TRUE(lineNo == 0);
ASSERT_TRUE(BSL_ERR_PeekErrorFileLine((const char **)&file, &lineNo) == 1);
ASSERT_TRUE(strcmp(file, "NA") == 0);
ASSERT_TRUE(lineNo == 0);
EXIT:
BSL_ERR_ClearError();
BSL_ERR_DeInit();
}
/* END_CASE */
/**
* @test SDV_BSL_ERR_COMPATIBILITY_FUNC_TC001
* @title Test the compatibility of the err module in different CMake versions.
* @precon Set the memory allocation and release functions.
* @brief
* 1. Initializes BSL_ERR. Expected result 1 is obtained.
* 2. Construct an exception to trigger the ERR module to push the stack. Expected result 2 is obtained.
* 3. Obtains the push-stack information, Expected result 3 and 4 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2. BSL_NULL_INPUT
* 3. "uio_abstraction.c"
* 4. BSL_NULL_INPUT
*/
/* BEGIN_CASE */
void SDV_BSL_ERR_COMPATIBILITY_FUNC_TC001(void)
{
#ifndef HITLS_BSL_UIO_PLT
SKIP_TEST();
#else
TestMemInit();
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_NEW_CB_FUNC, PthreadRWLockNew) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_FREE_CB_FUNC, PthreadRWLockFree) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_READ_LOCK_CB_FUNC, PthreadRWLockReadLock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_WRITE_LOCK_CB_FUNC, PthreadRWLockWriteLock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_UNLOCK_CB_FUNC, PthreadRWLockUnlock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_GET_ID_CB_FUNC, PthreadGetId) == BSL_SUCCESS);
ASSERT_TRUE(BSL_ERR_Init() == BSL_SUCCESS);
// Construct an exception to trigger the error code module to push the stack.
ASSERT_TRUE(BSL_UIO_SetMethodType(NULL, 1) == BSL_NULL_INPUT);
char *file = NULL;
uint32_t line = 0;
int32_t err = BSL_ERR_GetLastErrorFileLine((const char **)&file, &line);
ASSERT_TRUE(strcmp(file, "uio_abstraction.c") == 0);
ASSERT_TRUE(err == BSL_NULL_INPUT);
EXIT:
BSL_ERR_ClearError();
BSL_ERR_DeInit();
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_ERR_STACK_API_TC001
* @title BSL_ERR_ClearError interface testing
* @precon nan
* @brief
* 1.Call BSL_ERR_RemoveErrorStack to delete the stack. Expected result 2 is obtained.
* 2.Call BSL_ERR_ClearError to clear the stack. Expected result 3 is obtained.
* 3.Call BSL_ERR_ClearError repeatedly to clear the stack. Expected result 4 is obtained.
* @expect
* 1.BSL_SUCCESS
* 2.SUCCESS
* 3.SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_ERR_STACK_API_TC001(int isRemoveAll)
{
TestMemInit();
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_NEW_CB_FUNC, PthreadRWLockNew) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_FREE_CB_FUNC, PthreadRWLockFree) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_READ_LOCK_CB_FUNC, PthreadRWLockReadLock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_WRITE_LOCK_CB_FUNC, PthreadRWLockWriteLock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_UNLOCK_CB_FUNC, PthreadRWLockUnlock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_GET_ID_CB_FUNC, PthreadGetId) == BSL_SUCCESS);
ASSERT_TRUE(BSL_ERR_Init() == BSL_SUCCESS);
BSL_ERR_RemoveErrorStack((isRemoveAll == 1) ? true : false);
BSL_ERR_ClearError();
BSL_ERR_ClearError();
EXIT:
BSL_ERR_DeInit();
}
/* END_CASE */
/**
* @test SDV_BSL_ERR_MARK_FUNC_TC001
* @title Registering and Obtaining Error Descriptions
* @precon nan
* @brief
* 1. Set flags. Expected result 1 is obtained.
* 2. Push the error code on the stack. If no flag is set, invoke the pop to mark interface
* and obtain the latest error code. Expected result 2 is obtained.
* 3. Push three error codes into the stack and set a flag for the second error code. Expected result 3 is obtained.
* 4. Push three error codes into the stack, set flags for the second and third error codes, clear the latest flag,
* and invoke pop to mark to obtain the latest error code. Expected result 4 is obtained.
* @expect
* 1. Return BSL_ERR_ERR_NO_ERROR.
* 2. Return BSL_ERR_ERR_NO_MARK, and the error code is 0.
* 3. The flag is set successfully. The second error code is returned
* when the latest error code is obtained for the first time.
* The first error code is returned when the latest error code is obtained for the second time.
* 4. The latest error code is the second error code.
*/
/* BEGIN_CASE */
void SDV_BSL_ERR_MARK_FUNC_TC001(void)
{
ASSERT_TRUE(BSL_ERR_Init() == BSL_SUCCESS);
int32_t ret;
ret = BSL_ERR_SetMark();
ASSERT_TRUE(ret == BSL_ERR_ERR_NO_STACK);
BSL_ERR_PUSH_ERROR(BSL_UIO_FAIL);
BSL_ERR_PUSH_ERROR(BSL_UIO_IO_BUSY);
BSL_ERR_PUSH_ERROR(BSL_UIO_IO_EXCEPTION);
ret = BSL_ERR_PopToMark();
ASSERT_TRUE(ret == BSL_ERR_ERR_NO_MARK);
ret = BSL_ERR_GetLastError();
ASSERT_TRUE(ret == BSL_SUCCESS);
BSL_ERR_PUSH_ERROR(BSL_UIO_FAIL);
BSL_ERR_PUSH_ERROR(BSL_UIO_IO_BUSY);
ret = BSL_ERR_SetMark();
ASSERT_TRUE(ret == BSL_SUCCESS);
BSL_ERR_PUSH_ERROR(BSL_UIO_IO_EXCEPTION);
ret = BSL_ERR_PopToMark();
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_ERR_GetLastError();
ASSERT_TRUE(ret == BSL_UIO_IO_BUSY);
ret = BSL_ERR_GetLastError();
ASSERT_TRUE(ret == BSL_UIO_FAIL);
ret = BSL_ERR_GetLastError();
ASSERT_TRUE(ret == BSL_SUCCESS);
BSL_ERR_PUSH_ERROR(BSL_UIO_FAIL);
BSL_ERR_PUSH_ERROR(BSL_UIO_IO_BUSY);
ret = BSL_ERR_SetMark();
ASSERT_TRUE(ret == BSL_SUCCESS);
BSL_ERR_PUSH_ERROR(BSL_UIO_IO_EXCEPTION);
ret = BSL_ERR_SetMark();
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_ERR_ClearLastMark();
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_ERR_PopToMark();
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_ERR_GetLastError();
ASSERT_TRUE(ret == BSL_UIO_IO_BUSY);
EXIT:
BSL_ERR_DeInit();
}
/* END_CASE */
/**
* @test SDV_BSL_ERR_STRING_FUNC_TC001
* @title Registering and Obtaining Error Descriptions
* @precon nan
* @brief
* 1. The registration list is empty. Expected result 1 is obtained.
* 2. The registration list is not empty. The number of registrations is 0. Expected result 2 is obtained.
* 3. The registration list is not empty, and the number of registrations is 2. Expected result 3 is obtained.
* 4. Obtains the first error description. Expected result 4 is obtained.
* 5. Obtains the second error description. Expected result 5 is obtained.
* @expect
* 1. Return BSL_NULL_INPUT.
* 2. Return BSL_NULL_INPUT.
* 3. Return BSL_SUCCESS.
* 4. The result is the first error description.
* 5. The result is the second error description.
*/
/* BEGIN_CASE */
void SDV_BSL_ERR_STRING_FUNC_TC001(void)
{
RegThreadFunc();
ASSERT_TRUE(BSL_ERR_Init() == BSL_SUCCESS);
ASSERT_TRUE(BSL_ERR_AddErrStringBatch(NULL, 0) == BSL_NULL_INPUT);
ASSERT_TRUE(BSL_ERR_AddErrStringBatch((void *)-1, 0) == BSL_NULL_INPUT);
const char *uioFail = "uio is failed";
const char *tlvFail = "tlv needed type";
const BSL_ERR_Desc descList[] = {
{BSL_UIO_FAIL, uioFail},
{BSL_TLV_ERR_NO_WANT_TYPE, tlvFail},
};
ASSERT_TRUE(BSL_ERR_AddErrStringBatch(descList, 2) == BSL_SUCCESS);
ASSERT_TRUE(BSL_ERR_GetString(BSL_UIO_FAIL) == uioFail);
ASSERT_TRUE(BSL_ERR_GetString(BSL_TLV_ERR_NO_WANT_TYPE) == tlvFail);
EXIT:
BSL_ERR_RemoveErrStringBatch();
BSL_ERR_DeInit();
}
/* END_CASE */
/**
* @test SDV_BSL_ERR_AVLLR_FUNC_TC001
* @title A balanced binary tree is unbalanced due to insertion of nodes into the right subtree of the left subtree, and thus rotated to balance the test.
* @brief
* 1. insert 100
* 2. insert 120
* 3. insert 80
* 4. insert 70
* 5. insert 90
* 6. insert 85
* 7. delete 90
* 8. delete 200
* 9. delete 100
* 10. delete 120
* @expect
* 1. root node is 100
* 2. root node is 100
* 3. root node is 100
* 4. root node is 100
* 5. root node is 100
* 6. root node is 90
* 7. root node is 85
* 8. root node is 85
* 9. root node is 85
* 10. root node is 80
*/
/* BEGIN_CASE */
void SDV_BSL_ERR_AVLLR_FUNC_TC001(void)
{
TestMemInit();
ASSERT_TRUE(BSL_ERR_Init() == BSL_SUCCESS);
BSL_AvlTree *root = NULL;
root = BSL_AVL_InsertNode(root, 100, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 120, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 80, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 70, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 90, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 85, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 90);
root = BSL_AVL_DeleteNode(root, 90, NULL);
ASSERT_TRUE(root->nodeId == 85);
root = BSL_AVL_DeleteNode(root, 200, NULL);
ASSERT_TRUE(root->nodeId == 85);
root = BSL_AVL_DeleteNode(root, 100, NULL);
ASSERT_TRUE(root->nodeId == 85);
root = BSL_AVL_DeleteNode(root, 120, NULL);
ASSERT_TRUE(root->nodeId == 80);
BSL_AVL_DeleteTree(root, NULL);
EXIT:
BSL_ERR_DeInit();
}
/* END_CASE */
/**
* @test SDV_BSL_ERR_AVLLL_FUNC_TC001
* @title A balanced binary tree is unbalanced due to insertion of nodes into the left subtree of the left subtree, and thus rotated to balance the test.
* @brief
* 1. insert 100
* 2. insert 120
* 3. insert 80
* 4. insert 70
* 5. insert 90
* 6. insert 65
* 7. find 90
* 8. find 67
* 9. delete 70
* 10. delete 65
* @expect
* 1. root node is 100
* 2. root node is 100
* 3. root node is 100
* 4. root node is 100
* 5. root node is 100, the structure of the tree is
100
/ \
/ \
80 120
/ \
70 90
* 6. root node is 80, the structure of the tree is
80
/ \
/ \
70 100
/ / \
65 90 120
* 7. find
* 8. Couldn't find
* 9. root node is 80
* 10. root node is 100
*/
/* BEGIN_CASE */
void SDV_BSL_ERR_AVLLL_FUNC_TC001(void)
{
TestMemInit();
ASSERT_TRUE(BSL_ERR_Init() == BSL_SUCCESS);
BSL_AvlTree *root = NULL;
root = BSL_AVL_InsertNode(root, 100, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 120, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 80, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 70, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 90, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 65, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 80);
ASSERT_TRUE(BSL_AVL_SearchNode(root, 90) != NULL);
ASSERT_TRUE(BSL_AVL_SearchNode(root, 67) == NULL);
root = BSL_AVL_DeleteNode(root, 70, NULL);
ASSERT_TRUE(root->nodeId == 80);
root = BSL_AVL_DeleteNode(root, 65, NULL);
ASSERT_TRUE(root->nodeId == 100);
BSL_AVL_DeleteTree(root, NULL);
EXIT:
BSL_ERR_DeInit();
}
/* END_CASE */
/**
* @test SDV_BSL_ERR_AVLRL_FUNC_TC001
* @title A balanced binary tree is unbalanced due to insertion of nodes into the left subtree of the right subtree, and thus rotated to balance the test.
* @brief
* 1. insert 100
* 2. insert 80
* 3. insert 120
* 4. insert 110
* 5. insert 130
* 6. insert 105
* @expect
* 1. root node is 100
* 2. root node is 100
* 3. root node is 100
* 4. root node is 100
* 5. root node is 100
* 6. root node is 110
*/
/* BEGIN_CASE */
void SDV_BSL_ERR_AVLRL_FUNC_TC001(void)
{
TestMemInit();
ASSERT_TRUE(BSL_ERR_Init() == BSL_SUCCESS);
BSL_AvlTree *root = NULL;
root = BSL_AVL_InsertNode(root, 100, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 80, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 120, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 110, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 130, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 100);
root = BSL_AVL_InsertNode(root, 105, BSL_AVL_MakeLeafNode(NULL));
ASSERT_TRUE(root->nodeId == 110);
BSL_AVL_DeleteTree(root, NULL);
EXIT:
BSL_ERR_DeInit();
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/bsl/err/test_suite_sdv_err.c
|
C
|
unknown
| 22,292
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <string.h>
#include "securec.h"
#include "bsl_errno.h"
#include "list_base.h"
#include "bsl_hash.h"
#include "bsl_hash_list.h"
#include "bsl_sal.h"
#define BACKET_SIZE 64
#define MAX_NAME_LEN 64
typedef struct userData {
int id;
const char name[MAX_NAME_LEN];
} UserData;
void *UserHashKeyDupFunc(void *src, size_t size)
{
char *retKey;
char *tmpKey = (char *)src;
if (size > MAX_NAME_LEN) {
return NULL;
}
retKey = (char *)BSL_SAL_Calloc(1, size);
ASSERT_TRUE((char *)retKey != (char *)NULL);
ASSERT_TRUE(strcpy_s(retKey, size, tmpKey) == EOK);
EXIT:
return (void *)retKey;
}
void *UserHashDataDupFunc(void *src, size_t size)
{
UserData *ret = NULL;
UserData *tmpSrc = (UserData *)src;
ret = (UserData *)BSL_SAL_Calloc(1, sizeof(UserData));
ASSERT_TRUE(ret != (UserData *)NULL);
ASSERT_TRUE(memcpy_s(ret, size + 1, tmpSrc, size) == EOK);
EXIT:
return ret;
}
int UserDataCmpFunc(uintptr_t data1, uintptr_t data2)
{
return strcmp((const char*)data1, (const char*)data2);
}
void BslListFreeFunc(void *data)
{
if (data != NULL) {
BSL_SAL_Free(data);
}
}
bool ListNodeCmpFunc(const void *node, uintptr_t data)
{
const ListRawNode *t = (ListRawNode *)node;
return (uintptr_t)(t->prev) == data;
}
/* END_HEADER */
/**
* @test SDV_BSL_HASH_LIST_FUNC_TC001
* @title Hash list normal capability test
* @precon nan
* @brief
* 1. Call BSL_HASH_Create to create a hash list header. Expected result 1 is obtained.
* 2. Call BSL_HASH_Insert to add data to the hash list. Expected result 2 is obtained.
* 3. Call BSL_HASH_Size get list size. Expected result 3 is obtained.
* 4. Call BSL_CstlHashErase BSL_CstlHashClear BSL_CstlHashDestory delete data,
* Expected result 4 is obtained.
* @expect
* 1. success
* 2. BSL_SUCCESS
* 3. size is 6
* 4. success
*/
/* BEGIN_CASE */
void SDV_BSL_HASH_LIST_FUNC_TC001(void)
{
int i;
BSL_HASH_Hash *hash;
uintptr_t tmpValue;
UserData *userValue;
BSL_HASH_Iterator it;
uintptr_t tmpKey;
uint8_t key[6] = {28, 29, 30, 31, 32, 33};
UserData value[6] = {{16, "bsl_cstl001"},
{18, "bsl_cstl002"},
{15, "bsl_cstl003"},
{17, "bsl_cstl004"},
{17, "bsl_cstl005"},
{16, "bsl_cstl001"}};
ListDupFreeFuncPair valueFunc = {UserHashDataDupFunc, BSL_SAL_Free};
TestMemInit();
hash = BSL_HASH_Create(BACKET_SIZE, NULL, NULL, NULL, &valueFunc);
ASSERT_TRUE(hash != (BSL_HASH_Hash *)NULL);
for (i = 0; i < 5; i++) {
ASSERT_TRUE(BSL_HASH_Insert(hash, key[i], 0, (uintptr_t)&value[i], sizeof(UserData)) == BSL_SUCCESS);
}
ASSERT_TRUE(BSL_HASH_Put(hash, key[i], 0, (uintptr_t)&value[i], sizeof(UserData), NULL) == BSL_SUCCESS);
ASSERT_TRUE(BSL_HASH_Size(hash) == (size_t)6);
ASSERT_TRUE(BSL_HASH_At(hash, key[4], &tmpValue) == BSL_SUCCESS);
userValue = (UserData *)tmpValue;
ASSERT_TRUE(userValue->id == value[4].id);
ASSERT_TRUE(strcmp(userValue->name, value[4].name) == 0);
it = BSL_HASH_Find(hash, key[4]);
ASSERT_TRUE(it != BSL_HASH_IterEnd(hash));
ASSERT_TRUE(BSL_HASH_HashIterKey(hash, it) == (uintptr_t)key[4]);
userValue = (UserData *)BSL_HASH_IterValue(hash, it);
ASSERT_TRUE(userValue != (UserData *)NULL);
ASSERT_TRUE(userValue->id == value[4].id);
ASSERT_TRUE(strcmp(userValue->name, value[4].name) == 0);
(void)BSL_HASH_Erase(hash, key[4]);
ASSERT_TRUE(BSL_HASH_Size(hash) == (size_t)5);
for (it = BSL_HASH_IterBegin(hash); it != BSL_HASH_IterEnd(hash);) {
tmpKey = BSL_HASH_HashIterKey(hash, it);
it = BSL_HASH_Erase(hash, tmpKey);
}
ASSERT_TRUE(BSL_HASH_Size(hash) == (size_t)0);
BSL_HASH_Destory(hash);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_HASH_LIST_FUNC_TC002
* @title Hash list normal capability test, key type is string.
* @precon nan
* @brief
* 1. Call BSL_HASH_Create to create a hash list header. Expected result 1 is obtained.
* 2. Call BSL_HASH_Insert to add data to the hash list. Expected result 2 is obtained.
* 3. Call BSL_HASH_Size get list size. Expected result 3 is obtained.
* 4. Call BSL_CstlHashErase BSL_CstlHashClear BSL_CstlHashDestory delete data,
* Expected result 4 is obtained.
* @expect
* 1. success
* 2. BSL_SUCCESS
* 3. size is 6
* 4. success
*/
/* BEGIN_CASE */
void SDV_BSL_HASH_LIST_FUNC_TC002(void)
{
uint32_t i;
BSL_HASH_Hash *hash;
const char *key[6] = {"7201028", "7201029", "7201030", "7201031", "7201032", "7201033"};
UserData value[6] = {{16, "bsl_cstl001"},
{18, "bsl_cstl002"},
{15, "bsl_cstl003"},
{17, "bsl_cstl004"},
{17, "bsl_cstl005"},
{16, "bsl_cstl001"}};
char *tmpKey;
uintptr_t tmpValue;
UserData *userValue;
BSL_HASH_Iterator it;
ListDupFreeFuncPair keyFunc = {UserHashKeyDupFunc, BSL_SAL_Free};
ListDupFreeFuncPair valueFunc = {UserHashDataDupFunc, BSL_SAL_Free};
hash = BSL_HASH_Create(BACKET_SIZE, BSL_HASH_CodeCalcStr, BSL_HASH_MatchStr, &keyFunc, &valueFunc);
ASSERT_TRUE(hash != (BSL_HASH_Hash *)NULL);
for (i = 0; i < 6; i++) {
ASSERT_TRUE(
BSL_HASH_Insert(hash, (uintptr_t)key[i], strlen(key[i]) + 1, (uintptr_t)&value[i], sizeof(UserData)) ==
BSL_SUCCESS);
}
ASSERT_TRUE(BSL_HASH_Put(hash, (uintptr_t)key[1], strlen(key[1]) + 1, (uintptr_t)&value[1], sizeof(UserData), NULL)
== BSL_SUCCESS);
ASSERT_TRUE(BSL_HASH_Empty(hash) == false);
ASSERT_TRUE(BSL_HASH_Size(hash) == (size_t)6);
ASSERT_TRUE(BSL_HASH_At(hash, (uintptr_t)key[4], &tmpValue) == BSL_SUCCESS);
userValue = (UserData *)tmpValue;
ASSERT_TRUE(userValue->id == value[4].id);
ASSERT_TRUE(strcmp(userValue->name, value[4].name) == 0);
it = BSL_HASH_Find(hash, (uintptr_t)key[4]);
ASSERT_TRUE(it != BSL_HASH_IterEnd(hash));
ASSERT_TRUE(strcmp((const char *)BSL_HASH_HashIterKey(hash, it), key[4]) == 0);
userValue = (UserData *)BSL_HASH_IterValue(hash, it);
ASSERT_TRUE(userValue != (UserData *)NULL);
ASSERT_TRUE(userValue->id == value[4].id);
ASSERT_TRUE(strcmp(userValue->name, value[4].name) == 0);
(void)BSL_HASH_Erase(hash, (uintptr_t)key[4]);
ASSERT_TRUE(BSL_HASH_Size(hash) == (size_t)5);
for (it = BSL_HASH_IterBegin(hash); it != BSL_HASH_IterEnd(hash);) {
tmpKey = (char *)BSL_HASH_HashIterKey(hash, it);
it = BSL_HASH_Erase(hash, (uintptr_t)tmpKey);
}
ASSERT_TRUE(BSL_HASH_Size(hash) == (size_t)0);
BSL_HASH_Destory(hash);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_HASH_LIST_FUNC_TC003
* @title bsl list normal capability test, key type is string.
* @precon nan
* @brief
* 1. Call BSL_ListInit to create a hash list header. Expected result 1 is obtained.
* 2. Call BSL_ListPushFront and BSL_ListPushBack to add data to the hash list. Expected result 2 is obtained.
* 3. Perform find and delete. Expected result 3 is obtained.
* 4. Call BSL_ListIterErase delete data. Expected result 4 is obtained.
* @expect
* 1. success
* 2. BSL_SUCCESS
* 3. success
* 4. success
*/
/* BEGIN_CASE */
void SDV_BSL_HASH_LIST_FUNC_TC003(void)
{
uint32_t i;
BSL_List *list = BSL_SAL_Calloc(1, sizeof(BSL_List));
ASSERT_TRUE(list != NULL);
const char *data[7] = {"7201028", "7201029", "7201030", "7201031", "7201032", "7201033", "777888"};
BSL_ListIterator it = NULL;
ListDupFreeFuncPair valueFunc = {UserHashKeyDupFunc, BSL_SAL_Free};
ASSERT_EQ(BSL_ListInit(list, &valueFunc), BSL_SUCCESS);
for (i = 0; i < 5; i++) {
ASSERT_EQ( BSL_ListPushFront(list, (uintptr_t)data[i], strlen(data[i]) + 1), BSL_SUCCESS);
}
ASSERT_EQ(BSL_ListPushBack(list, (uintptr_t)data[i], strlen(data[i]) + 1), BSL_SUCCESS);
ASSERT_TRUE(BSL_ListSize(list) == (size_t)i + 1);
ASSERT_TRUE(strcmp((const char* )BSL_ListFront(list), data[4]) == 0);
ASSERT_TRUE(strcmp((const char* )BSL_ListBack(list), data[5]) == 0);
it = BSL_ListIterFind(list, UserDataCmpFunc, (uintptr_t)data[1]);
ASSERT_TRUE(it != BSL_ListIterEnd(list));
ASSERT_TRUE(strcmp((const char* )BSL_ListIterData(it), data[1]) == 0);
ASSERT_TRUE(BSL_ListInsert(list, it, (uintptr_t)data[6], strlen(data[6]) + 1) == BSL_SUCCESS);
ASSERT_TRUE(BSL_ListIterPrev(list, it) != NULL);
ASSERT_TRUE(BSL_ListIterNext(list, it) != NULL);
ASSERT_TRUE(BSL_ListIterBegin(list) != NULL);
ASSERT_TRUE(BSL_ListIterEnd(list) != NULL);
ASSERT_TRUE(BSL_ListPopFront(list) == BSL_SUCCESS);
ASSERT_TRUE(BSL_ListPopBack(list) == BSL_SUCCESS);
ASSERT_TRUE(BSL_ListIterErase(list, it) != NULL);
EXIT:
BSL_ListDeinit(list);
BSL_SAL_Free(list);
return;
}
/* END_CASE */
/**
* @test SDV_BSL_HASH_LIST_FUNC_TC004
* @title raw list normal capability test.
* @precon nan
* @brief
* 1. Call ListRawInit to create a raw list header. Expected result 1 is obtained.
* 2. Call ListRawPushFront to add node to the list. Expected result 2 is obtained.
* 3. Perform find and delete. Expected result 3 is obtained.
* 4. Call ListRawDeinit delete list. Expected result 4 is obtained.
* @expect
* 1. create success
* 2. add success
* 3. success
* 4. success
*/
/* BEGIN_CASE */
void SDV_BSL_HASH_LIST_FUNC_TC004(void)
{
uint32_t i;
ListRawNode *node = BSL_SAL_Calloc(6, sizeof(ListRawNode));
ASSERT_TRUE(node != NULL);
RawList *list = BSL_SAL_Calloc(1, sizeof(RawList));
ASSERT_TRUE(list != NULL);
ASSERT_EQ(ListRawInit(list, NULL), BSL_SUCCESS);
for (i = 0; i < 6; i++) {
ASSERT_EQ(ListRawPushFront(list, &node[i]), BSL_SUCCESS);
}
ListRawNode *it = ListRawBack(list);
ASSERT_TRUE(it != NULL);
ASSERT_TRUE(it->prev != NULL);
it = ListRawGetPrev(list, &node[1]);
ASSERT_TRUE(it != NULL);
ASSERT_TRUE(it->next != NULL);
it = ListRawFindNode(list, ListNodeCmpFunc, (uintptr_t)&node[1]);
ASSERT_TRUE(it != NULL);
ASSERT_EQ(ListRawPopFront(list), BSL_SUCCESS);
ASSERT_EQ(ListRawPopBack(list), BSL_SUCCESS);
ASSERT_EQ(ListRawDeinit(list), BSL_SUCCESS);
EXIT:
BSL_SAL_Free(list);
BSL_SAL_Free(node);
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/bsl/hash/test_suite_sdv_hash.c
|
C
|
unknown
| 11,088
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "securec.h"
#include "bsl_errno.h"
#include "bsl_list.h"
#include "bsl_list_internal.h"
/* END_HEADER */
typedef struct {
int value;
int key;
} LIST_NODE;
#define MAX_NAME_LEN 64
/* User Structure Definition */
typedef struct userListData {
int id;
char name[MAX_NAME_LEN];
} UserData;
static void EmptyFree(void *data)
{
(void)data;
}
void UserDataFree(void *data)
{
(void)data;
return;
}
static int Compare(const void *data1, const void *data2)
{
return **(int **)data1 > **(int **)data2;
}
static int32_t UserDataCompare(const void *data1, const void *data2)
{
if (data1 == NULL || data2 == NULL) {
return 1;
}
UserData *tmp1 = (UserData *)data1;
UserData *tmp2 = (UserData *)data2;
if (tmp1->id != tmp2->id) {
return -1;
}
if (strlen(tmp1->name) != strlen(tmp2->name)) {
return -1;
}
if (memcmp(tmp1->name, tmp2->name, strlen(tmp1->name)) != 0) {
return -1;
}
return 0;
}
// data1:(pList)->curr->data, data2:pSearchFor
static int32_t UserDataCompareByName(const void *data1, const void *data2)
{
if (data1 == NULL || data2 == NULL) {
return 1;
}
UserData *tmp1 = (UserData *)data1;
char *tmp2 = (char *)data2;
if (strlen(tmp1->name) != strlen(tmp2)) {
return -1;
}
if (memcmp(tmp1->name, tmp2, strlen(tmp2)) != 0) {
return -1;
}
return 0;
}
static int32_t UserDataSort(const void *a, const void *b)
{
if (a == NULL || b == NULL) {
return -1;
}
UserData *tmp1 = *(UserData **)a;
UserData *tmp2 = *(UserData **)b;
return (tmp1->id - tmp2->id);
}
static void *UserDataCopy(const void *a)
{
if (a == NULL) {
return NULL;
}
UserData *src = (UserData *)a;
UserData *dest = (UserData *)BSL_SAL_Malloc(sizeof(UserData));
if (dest == NULL) {
return NULL;
}
(void)memset_s(dest, sizeof(UserData), 0, sizeof(UserData));
dest->id = src->id;
if (memcpy_s(dest->name, MAX_NAME_LEN, src->name, strlen(src->name)) != EOK) {
BSL_SAL_FREE(dest);
return NULL;
}
return dest;
}
/**
* @test SDV_BSL_LIST_FUNC_TC001
* @title Linked list normal capability test
* @precon nan
* @brief
* 1. Call BSL_LIST_New to create a linked list header. Expected result 1 is obtained.
* 2. Call BSL_LIST_AddElement to add data to the linked list. Expected result 2 is obtained.
* 3. Repeat step 2 twice. Expected result 2 is obtained.
* 4. Call BSL_LIST_COUNT to obtain the number of data records in the current linked list.
* Expected result 3 is obtained.
* 5. Get the number of nodes in the list after delete the current element of list. Expected result 4 is obtained.
* 6. Call BSL_LIST_Copy to copy data to the new linked list. Expected result 5 is obtained.
* @expect
* 1. success
* 2. BSL_SUCCESS
* 3. 3
* 4. 2
* 5. success
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_FUNC_TC001(void)
{
TestMemInit();
BslList *listHeader = BSL_LIST_New(sizeof(LIST_NODE));
ASSERT_TRUE(listHeader != NULL);
LIST_NODE *node1 = (LIST_NODE *)BSL_SAL_Malloc(sizeof(LIST_NODE));
ASSERT_TRUE(node1 != NULL);
node1->key = 1;
node1->value = 2;
int ret = BSL_LIST_AddElement(listHeader, node1, BSL_LIST_POS_END);
ASSERT_TRUE(ret == BSL_SUCCESS);
LIST_NODE *node2 = (LIST_NODE *)BSL_SAL_Malloc(sizeof(LIST_NODE));
ASSERT_TRUE(node2 != NULL);
node2->key = 1;
node2->value = 2;
ret = BSL_LIST_AddElement(listHeader, node2, BSL_LIST_POS_END);
ASSERT_TRUE(ret == BSL_SUCCESS);
LIST_NODE *node3 = (LIST_NODE *)BSL_SAL_Malloc(sizeof(LIST_NODE));
ASSERT_TRUE(node3 != NULL);
node3->key = 1;
node3->value = 2;
ret = BSL_LIST_AddElement(listHeader, node3, BSL_LIST_POS_END);
ASSERT_TRUE(ret == BSL_SUCCESS);
int num = BSL_LIST_COUNT(listHeader);
ASSERT_TRUE(num == 3);
BSL_LIST_DeleteCurrent(listHeader, NULL);
num = BSL_LIST_COUNT(listHeader);
ASSERT_TRUE(num == 2);
BslList *destHeader = BSL_LIST_Copy(listHeader, NULL, NULL);
ASSERT_TRUE(destHeader != NULL);
num = BSL_LIST_COUNT(destHeader);
ASSERT_TRUE(num == 2);
BSL_LIST_FREE(destHeader, NULL);
BSL_LIST_FREE(listHeader, NULL);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_FUNC_TC002
* @title SDV_BSL_LIST_FUNC_TC002
* @precon None
* @brief List maximum element test.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_FUNC_TC002(void)
{
int arr[] = {0};
BslList *list = NULL;
list = BSL_LIST_New(sizeof(int));
ASSERT_TRUE(list != NULL);
ASSERT_EQ(BSL_LIST_SetMaxElements(65535), BSL_SUCCESS);
for (int i = 0; i < 65535; i++) {
ASSERT_EQ(BSL_LIST_AddElement(list, arr, BSL_LIST_POS_AFTER), BSL_SUCCESS);
}
ASSERT_EQ(BSL_LIST_COUNT(list), 65535);
ASSERT_EQ(BSL_LIST_AddElement(list, arr, BSL_LIST_POS_AFTER), BSL_LIST_FULL);
EXIT:
BSL_LIST_FREE(list, EmptyFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_MAX_ELEMENTS_FUNC_TC001
* @title list max elements test
* @precon nan
* @brief
* 1. Call BSL_LIST_New to create the head node of the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_SetMaxElements to set the maximum number of data records stored in the linked list to 65535.
* Expected result 2 is obtained.
* 3. Add 65535 records to the linked list. Expected result 3 is obtained.
* 4. Obtain the maximum data volume supported by the current linked list. Expected result 4 is obtained.
* 5. Obtain the number of data records in the current linked list. Expected result 5 is obtained.
* 6. Add data to the linked list again. Expected result 6 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2. BSL_SUCCESS
* 3. BSL_SUCCESS
* 4. 65535
* 5. 65535
* 6. BSL_LIST_FULL
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_MAX_ELEMENTS_FUNC_TC001(void)
{
int arr[] = {0};
BslList *list = NULL;
list = BSL_LIST_New(-1);
ASSERT_TRUE(list == NULL);
list = BSL_LIST_New(sizeof(int));
ASSERT_TRUE(list != NULL);
ASSERT_EQ(BSL_LIST_SetMaxElements(65535), BSL_SUCCESS);
for (int i = 0; i < 65535; i++) {
ASSERT_EQ(BSL_LIST_AddElement(list, arr, BSL_LIST_POS_AFTER), BSL_SUCCESS);
}
ASSERT_EQ(BSL_LIST_GetMaxElements(), 65535);
ASSERT_EQ(BSL_LIST_COUNT(list), 65535);
ASSERT_EQ(BSL_LIST_AddElement(list, arr, BSL_LIST_POS_AFTER), BSL_LIST_FULL);
EXIT:
BSL_LIST_FREE(list, EmptyFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_DETACH_FUNC_TC001
* @title list detach test
* @precon nan
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_DetachCurrent to detach the current. Expected result 2 is obtained.
* 3. Call BSL_LIST_DetachNode to detach a node. Expected result 3 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2. success
* 3. success
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_DETACH_FUNC_TC001(void)
{
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
UserData data[9] = {
{1, "Alice"},
{2, "Bob"},
{3, "Celina"},
{4, "Dave"},
{5, "Emma"},
{6, "Frank"},
{7, "Grace"},
{8, "Helen"},
{9, "Iris"}
};
// Linked list IDs range from 1 to 9.
for (int i = 0; i < 9; i++) {
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[i], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
}
/*
* The curr is the last node. After the node is detached and released,
* last is the last but one node in the original linked list.
*/
BSL_LIST_DetachCurrent(testList);
ASSERT_TRUE(BSL_LIST_COUNT(testList) == 8);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_LAST(testList), &data[7]) == 0);
// Delete Dave.
BslListNode *detachNode = testList->first->next->next->next;
BSL_LIST_DetachNode(testList, &detachNode);
ASSERT_TRUE(UserDataCompare(detachNode->data, &data[4]) == 0); // Dave's position became Emma.
/* When the deleted node is the current node, the current node will be
* updated to the next node first; otherwise, it will be updated to the previous node.
*/
testList->curr = testList->last->prev;
ASSERT_TRUE(UserDataCompare(BSL_LIST_CURR_ELMT(testList), &data[6]) == 0);
ASSERT_TRUE(UserDataCompare(testList->curr->next->data, &data[7]) == 0);
BSL_LIST_DetachNode(testList, &testList->curr);
ASSERT_TRUE(UserDataCompare(BSL_LIST_CURR_ELMT(testList), &data[7]) == 0);
ASSERT_TRUE(UserDataCompare(testList->curr->prev->data, &data[5]) == 0);
BSL_LIST_DetachNode(testList, &testList->curr);
ASSERT_TRUE(UserDataCompare(BSL_LIST_CURR_ELMT(testList), &data[5]) == 0);
EXIT:
BSL_LIST_FREE(testList, UserDataFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_SEARCH_FUNC_TC001
* @title list search test
* @precon nan
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_Search to search for specified data. Expected result 2 is obtained.
* 3. Call BSL_LIST_Search to search for specified data. Expected result 3 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2. Data search succeeded.
* 3. Data search succeeded.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_SEARCH_FUNC_TC001(void)
{
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
UserData data[5] = {
{1, "Alice"},
{2, "Bob"},
{3, "Celina"},
{4, "Dave"},
{5, "Emma"}
};
// The sequence of linked list IDs is 1 - 2 - 3 - 4 - 5.
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[2], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[1], BSL_LIST_POS_BEFORE) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[0], BSL_LIST_POS_BEGIN) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[4], BSL_LIST_POS_END) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[3], BSL_LIST_POS_BEFORE) == BSL_SUCCESS);
int errNum = 0;
UserData *tmp1 = BSL_LIST_Search(testList, "Celina", UserDataCompareByName, NULL);
ASSERT_TRUE(UserDataCompare(tmp1, &data[2]) == 0);
UserData *tmp2 = BSL_LIST_Search(testList, "Dave", UserDataCompareByName, &errNum);
ASSERT_TRUE(UserDataCompare(tmp2, &data[3]) == 0);
EXIT:
BSL_LIST_FREE(testList, UserDataFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_GET_NODE_FUNC_TC001
* @title list GET NODE interface testing
* @precon nan
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_FirstNode to get the first node in the linked list. Expected result 2 is obtained.
* 3. Call BSL_LIST_GetData to get data from the node. Expected result 3 is obtained.
* 4. Call BSL_LIST_GetNextNode to get the next node. Expected result 4 is obtained.
* 5. Call BSL_LIST_GetData to get data from the node. Expected result 5 is obtained.
* 6. Call BSL_LIST_GetNextNode to get the next node. Expected result 6 is obtained.
* 7. Call BSL_LIST_GetData to get data from the node. Expected result 7 is obtained.
* 8. Call BSL_LIST_GetNextNode to get the prev node. Expected result 8 is obtained.
* 9. Call BSL_LIST_GetData to get data from the node. Expected result 9 is obtained.
* 10. Call BSL_LIST_Curr to get the current element in the list. Expected result 10 is obtained.
* 11. Call BSL_LIST_GetIndexNode to get the node at the given index in the list.
* Expected result 11 is obtained.
* 12. Call BSL_LIST_Curr to get the current element in the list. Expected result 12 is obtained.
* @expect
* 1. Data added successfully. return BSL_SUCCESS.
* 2. The first node is obtained successfully.
* 3. Succeeded in obtaining data from the node, which is the same as the original data.
* 4. The next node is obtained successfully.
* 5. Succeeded in obtaining data from the node, which is the same as the original data.
* 6. The next node is obtained successfully.
* 7. Succeeded in obtaining data from the node, which is the same as the original data.
* 8. The prev node is obtained successfully.
* 9. Succeeded in obtaining data from the node, which is the same as the original data.
* 10. The current node is obtained successfully, which is the same as the original data.
* 11. The index node is obtained successfully, which is the same as the original data.
* 12. The current node is obtained successfully, which is the same as the original data.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_GET_NODE_FUNC_TC001(void)
{
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
UserData data[5] = {
{1, "Alice"},
{2, "Bob"},
{3, "Celina"},
{4, "Dave"},
{5, "Emma"}
};
for (int i = 0; i < 5; i++) {
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[i], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
}
BslListNode *tmp = BSL_LIST_FirstNode(NULL);
ASSERT_TRUE(tmp == NULL);
tmp = BSL_LIST_FirstNode(testList);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GetData(tmp), &data[0]) == 0);
tmp = BSL_LIST_GetNextNode(NULL, (const BslListNode *)BSL_LIST_FirstNode(testList));
ASSERT_TRUE(tmp == NULL);
tmp = BSL_LIST_GetNextNode(testList, (const BslListNode *)BSL_LIST_FirstNode(testList));
ASSERT_TRUE(UserDataCompare(BSL_LIST_GetData(tmp), &data[1]) == 0);
tmp = BSL_LIST_GetNextNode(testList, (const BslListNode *)tmp);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GetData(tmp), &data[2]) == 0);
tmp = BSL_LIST_GetPrevNode(tmp);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GetData(tmp), &data[1]) == 0);
// curr points to 4.
UserData *curTmp = *(UserData **)BSL_LIST_Curr(testList);
ASSERT_TRUE(UserDataCompare(curTmp, &data[4]) == 0);
// The subscript of the list starts from 0.
UserData *getTmp = BSL_LIST_GetIndexNode(3, testList);
ASSERT_TRUE(UserDataCompare(&data[3], getTmp) == 0);
// BSL_LIST_GetIndexNode changes the curr point to 3.
curTmp = *(UserData **)BSL_LIST_Curr(testList);
ASSERT_TRUE(UserDataCompare(curTmp, &data[3]) == 0);
EXIT:
BSL_LIST_FREE(testList, UserDataFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_COPY_FUNC_TC001
* @title list Copy test
* @precon nan
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_Copy to copy the linked list to the new linked list
* and check whether the data in the two linked lists is the same. Expected result 2 is obtained.
* @expect
* 1. Data added successfully. return BSL_SUCCESS.
* 2. The data in the two linked lists is the same.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_COPY_FUNC_TC001(void)
{
BslList *srcList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(srcList != NULL);
UserData data[3] = { {1, "Alice"}, {2, "Bob"}, {3, "Celina"} };
for (int i = 0; i < 3; i++) {
ASSERT_TRUE(BSL_LIST_AddElement(srcList, &data[i], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
}
BslList *destList = BSL_LIST_Copy(srcList, UserDataCopy, UserDataFree);
UserData *srcTmp = BSL_LIST_GET_FIRST(srcList);
UserData *destTmp = BSL_LIST_GET_FIRST(destList);
ASSERT_TRUE(UserDataCompare((const void *)srcTmp, (const void *)destTmp) == 0);
srcTmp = BSL_LIST_GET_LAST(srcList);
destTmp = BSL_LIST_GET_LAST(destList);
ASSERT_TRUE(UserDataCompare((const void *)srcTmp, (const void *)destTmp) == 0);
ASSERT_TRUE(UserDataCompare(destList->first->next->data, srcList->first->next->data) == 0);
EXIT:
BSL_LIST_FREE(destList, NULL);
BSL_LIST_FREE(srcList, UserDataFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_SORT_FUNC_TC001
* @title list sort test
* @precon nan
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_Sort to sort the linked list and view the sorting result. Expected result 2 is obtained.
* @expect
* 1. Data added successfully. return BSL_SUCCESS.
* 2. Linked list sorting succeeded.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_SORT_FUNC_TC001(void)
{
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
UserData data[6] = { {3, "Celina"}, {2, "Bob"}, {1, "Alice"}, {6, "Frank"}, {4, "Dave"}, {5, "Emma"} };
for (int i = 0; i < 6; i++) {
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[i], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
}
BSL_LIST_Sort(testList, UserDataSort);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_FIRST(testList), &data[2]) == 0);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_LAST(testList), &data[3]) == 0);
ASSERT_TRUE(UserDataCompare(testList->first->next->next->next->data, &data[4]) == 0);
EXIT:
BSL_LIST_FREE(testList, UserDataFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_SORT_FUNC_TC002
* @title list sort test
* @precon nan
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_GetMaxQsortCount to get max qsort count. Expected result 2 is obtained.
* 3. Call BSL_LIST_SetMaxQsortCount to set max qsort count. Expected result 3 is obtained.
* 4. Call BSL_LIST_GetMaxQsortCount to get max qsort count. Expected result 4 is obtained.
* 5. Call BSL_LIST_Sort to sort the linked list and view the sorting result. Expected result 5 is obtained.
* @expect
* 1. Data added successfully. return BSL_SUCCESS.
* 2. The obtained count is the same as the default count.
* 3. Succeeded in setting the max qsort count.
* 4. The obtained count is the same as the count.
* 5. Linked list sorting succeeded.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_SORT_FUNC_TC002(void)
{
int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
BslList *list1 = NULL;
list1 = BSL_LIST_New(sizeof(int));
ASSERT_TRUE(list1 != NULL);
ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 4, BSL_LIST_POS_AFTER), BSL_SUCCESS);
ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 3, BSL_LIST_POS_AFTER), BSL_SUCCESS);
ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 2, BSL_LIST_POS_AFTER), BSL_SUCCESS);
ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 1, BSL_LIST_POS_AFTER), BSL_SUCCESS);
ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 7, BSL_LIST_POS_AFTER), BSL_SUCCESS);
ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 5, BSL_LIST_POS_AFTER), BSL_SUCCESS);
ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 8, BSL_LIST_POS_AFTER), BSL_SUCCESS);
ASSERT_EQ(BSL_LIST_AddElement(list1, arr + 6, BSL_LIST_POS_AFTER), BSL_SUCCESS);
ASSERT_EQ(BSL_LIST_GetMaxQsortCount(), 100000);
ASSERT_EQ(BSL_LIST_SetMaxQsortCount(67108865), BSL_INVALID_ARG);
ASSERT_EQ(BSL_LIST_SetMaxQsortCount(10000), BSL_SUCCESS);
ASSERT_EQ(BSL_LIST_GetMaxQsortCount(), 10000);
list1 = BSL_LIST_Sort(list1, Compare);
ASSERT_TRUE(list1 != NULL);
int *p = BSL_LIST_GET_FIRST(list1);
ASSERT_TRUE(p != NULL && *p == 1);
p = BSL_LIST_GET_NEXT(list1);
ASSERT_TRUE(p != NULL && *p == 2);
p = BSL_LIST_GET_NEXT(list1);
ASSERT_TRUE(p != NULL && *p == 3);
p = BSL_LIST_GET_NEXT(list1);
ASSERT_TRUE(p != NULL && *p == 4);
p = BSL_LIST_GET_NEXT(list1);
ASSERT_TRUE(p != NULL && *p == 5);
p = BSL_LIST_GET_NEXT(list1);
ASSERT_TRUE(p != NULL && *p == 6);
p = BSL_LIST_GET_NEXT(list1);
ASSERT_TRUE(p != NULL && *p == 7);
p = BSL_LIST_GET_NEXT(list1);
ASSERT_TRUE(p != NULL && *p == 8);
EXIT:
BSL_LIST_FREE(list1, EmptyFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_ADD_GET_FUNC_TC001
* @title The list add and GET* interfaces testing.
* @precon nan
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_CURR_ELMT. Expected result 2 is obtained.
* 3. Call BSL_LIST_NEXT_ELMT. Expected result 3 is obtained.
* 4. Call BSL_LIST_PREV_ELMT. Expected result 4 is obtained.
* 5. Call BSL_LIST_LAST_ELMT. Expected result 5 is obtained.
* 6. Call BSL_LIST_FIRST_ELMT. Expected result 6 is obtained.
* 7. Call BSL_LIST_GET_FIRST. Expected result 7 is obtained.
* 8. Call BSL_LIST_GET_LAST. Expected result 8 is obtained.
* 9. Call BSL_LIST_GET_CURRENT. Expected result 9 is obtained.
* 10. Call BSL_LIST_GET_NEXT. Expected result 10 is obtained.
* 11. Call BSL_LIST_GET_PREV. Expected result 11 is obtained.
* 12. Call BSL_LIST_GetIndexNode. Expected result 12 is obtained.
* 13. Call BSL_LIST_GetElmtIndex. Expected result 13 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2~13. SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_ADD_GET_FUNC_TC001(void)
{
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
ASSERT_TRUE(BSL_LIST_COUNT(testList) == 0);
UserData data[4] = {
{1, "bsl_list_001"},
{2, "bsl_list_002"},
{3, "bsl_list_003"},
{4, "bsl_list_004"},
};
// The sequence of linked list IDs is 3 - 2 - 1 - 4.
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[0], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[1], BSL_LIST_POS_BEFORE) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[2], BSL_LIST_POS_BEGIN) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[3], BSL_LIST_POS_END) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_COUNT(testList) == 4);
// Obtaining the macro of a node does not change the value of curr.
ASSERT_TRUE(UserDataCompare(BSL_LIST_CURR_ELMT(testList), &data[3]) == 0);
ASSERT_TRUE(BSL_LIST_NEXT_ELMT(testList) == NULL);
ASSERT_TRUE(UserDataCompare(BSL_LIST_PREV_ELMT(testList), &data[0]) == 0);
ASSERT_TRUE(UserDataCompare(BSL_LIST_LAST_ELMT(testList), &data[3]) == 0);
ASSERT_TRUE(UserDataCompare(BSL_LIST_FIRST_ELMT(testList), &data[2]) == 0);
// Note that the Get function changes the value of curr.
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_FIRST(testList), &data[2]) == 0);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_LAST(testList), &data[3]) == 0);
UserData *curTmp = *(UserData **)BSL_LIST_Curr(testList);
ASSERT_TRUE(UserDataCompare(curTmp, &data[3]) == 0);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_PREV(testList), &data[0]) == 0);
// Therefore, this is the next of curr->prev.
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_NEXT(testList), &data[3]) == 0);
// The curr points to 3
curTmp = *(UserData **)BSL_LIST_Curr(testList);
ASSERT_TRUE(UserDataCompare(curTmp, &data[3]) == 0);
// The subscript of the list starts from 0.
UserData *tmp = BSL_LIST_GetIndexNode(2, testList);
ASSERT_TRUE(UserDataCompare(&data[0], tmp) == 0);
// BSL_LIST_GetIndexNode changes curr to 2.
curTmp = *(UserData **)BSL_LIST_Curr(testList);
ASSERT_TRUE(UserDataCompare(curTmp, &data[0]) == 0);
ASSERT_TRUE(BSL_LIST_GetElmtIndex(&data[1], testList) == 1);
EXIT:
BSL_LIST_FREE(testList, UserDataFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_CONCAT_FUNC_TC001
* @title list concat test
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_Concat to combine two linked lists and compare whether the data in the linked lists is correct.
* Expected result 2 is obtained.
* @expect
* 1. Data added successfully. return BSL_SUCCESS.
* 2. Linked list combination succeeded.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_CONCAT_FUNC_TC001(void)
{
BslList *destList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(destList != NULL);
BslList *srcList1 = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(srcList1 != NULL);
BslList *srcList2 = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(srcList2 != NULL);
UserData data[6] = { {1, "Alice"}, {2, "Bob"}, {3, "Celina"}, {4, "Dave"}, {5, "Emma"}, {6, "Frank"} };
for (int i = 0; i < 3; i++) {
ASSERT_TRUE(BSL_LIST_AddElement(srcList1, &data[i], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
}
for (int i = 3; i < 6; i++) {
ASSERT_TRUE(BSL_LIST_AddElement(srcList2, &data[i], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
}
// Add to an empty linked list
destList = BSL_LIST_Concat(destList, srcList1);
// Add to non-empty linked list
destList = BSL_LIST_Concat(destList, srcList2);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_FIRST(destList), &data[0]) == 0);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_LAST(destList), &data[5]) == 0);
ASSERT_TRUE(UserDataCompare(destList->first->next->next->next->data, &data[3]) == 0);
EXIT:
BSL_LIST_FREE(destList, UserDataFree);
BSL_SAL_FREE(srcList1);
BSL_SAL_FREE(srcList2); // The nodes are free, so just use the free linked list itself.
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_REVERSE_FUNC_TC001
* @title list reverse test
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_RevList to reverse the linked list. Expected result 2 is obtained.
* @expect
* 1. Data added successfully. return BSL_SUCCESS.
* 2. Succeeded in reversing the linked list.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_REVERSE_FUNC_TC001(void)
{
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
UserData data[3] = { {1, "Alice"}, {2, "Bob"}, {3, "Celina"} };
for (int i = 0; i < 3; i++) {
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data[i], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
}
BSL_LIST_RevList(testList);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_FIRST(testList), &data[2]) == 0);
ASSERT_TRUE(UserDataCompare(BSL_LIST_GET_LAST(testList), &data[0]) == 0);
EXIT:
BSL_LIST_FREE(testList, UserDataFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_DETELE_NODE_FUNC_TC001
* @title list delete test
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_FirstNode to get the first node in the linked list. Expected result 2 is obtained.
* 3. Call BSL_LIST_DeleteNode to delete the first node. Expected result 3 is obtained.
* 4. Call BSL_LIST_DeleteAll to delete all node. Expected result 4 is obtained.
* @expect
* 1. Data added successfully. return BSL_SUCCESS.
* 2. Succeeded in reversing the linked list.
* 3. The deletion is successful, and the number of nodes decreases by 1.
* 4. The deletion is successful. The number of nodes is 0.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_DELETE_NODE_FUNC_TC001(void)
{
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
UserData data[3] = { {1, "Alice"}, {2, "Bob"}, {3, "Celina"} };
UserData *data1 = BSL_SAL_Malloc(sizeof(UserData) * 3);
ASSERT_TRUE(data1 != NULL);
memcpy_s(data1, sizeof(UserData) * 3, data, sizeof(UserData) *3);
for (int i = 0; i < 3; i++) {
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data1[i], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
}
BslListNode *tmp = BSL_LIST_FirstNode(testList);
BSL_LIST_DeleteNode(testList, tmp, UserDataFree);
ASSERT_TRUE(BSL_LIST_COUNT(testList) == 2);
BSL_LIST_DeleteAll(testList, UserDataFree);
ASSERT_TRUE(BSL_LIST_COUNT(testList) == 0);
EXIT:
free(data1);
BSL_LIST_FREE(testList, UserDataFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_DETELE_NODE_FUNC_TC002
* @title list delete test
* @brief
* 1. Call BSL_LIST_AddElement to add data to the linked list. Expected result 1 is obtained.
* 2. Call BSL_LIST_DeleteAllAfterSort to delete all node. Expected result 2 is obtained.
* @expect
* 1. Data added successfully. return BSL_SUCCESS.
* 2. The deletion is successful. The number of nodes is 0.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_DELETE_NODE_FUNC_TC002(void)
{
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
UserData data[3] = { {1, "Alice"}, {2, "Bob"}, {3, "Celina"} };
UserData *data1 = BSL_SAL_Malloc(sizeof(UserData) * 3);
ASSERT_TRUE(data1 != NULL);
memcpy_s(data1, sizeof(UserData) * 3, data, sizeof(UserData) *3);
for (int i = 0; i < 3; i++) {
ASSERT_TRUE(BSL_LIST_AddElement(testList, &data1[i], BSL_LIST_POS_AFTER) == BSL_SUCCESS);
}
BSL_LIST_DeleteAllAfterSort(testList);
ASSERT_TRUE(BSL_LIST_COUNT(testList) == 0);
EXIT:
free(data1);
BSL_LIST_FREE(testList, UserDataFree);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_LIST_API_TC001
* @title list previous node test
* @brief
* 1. Check if previous element is NULL. Expected result 1 is obtained.
* 2. Call BSL_LIST_AddElement to add data to the linked list. Expected result 2 is obtained.
* 3. Check if previous element is NULL. Expected result 3 is obtained.
* @expect
* 1. The previous node is NULL.
* 2. Data added successfully. return BSL_SUCCESS.
* 3. The previous node is not NULL.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_LIST_Pre_API_TC001()
{
int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
/* when list is NULL */
int **prv = BSL_LIST_Prev(NULL);
ASSERT_EQ(prv, NULL);
/* pstList->curr == NULL */
BslList *list = BSL_LIST_New(sizeof(int));
ASSERT_TRUE(list != NULL);
prv = BSL_LIST_Prev(list);
ASSERT_EQ(prv, NULL);
/* pstList->curr != NULL, pstList->curr->prev == NULL */
ASSERT_EQ(BSL_LIST_AddElement(list, arr + 0, BSL_LIST_POS_AFTER), BSL_SUCCESS);
prv = BSL_LIST_Prev(list);
ASSERT_EQ(prv, NULL);
/* pstList->curr != NULL, pstList->curr->prev != NULL */
ASSERT_EQ(BSL_LIST_AddElement(list, arr + 1, BSL_LIST_POS_AFTER), BSL_SUCCESS);
prv = BSL_LIST_Prev(list);
ASSERT_TRUE(prv != NULL && **prv == 0);
/* pstList->curr == NULL, pstList->last != NULL */
prv = BSL_LIST_Prev(list);
ASSERT_EQ(prv, NULL);
prv = BSL_LIST_Prev(list);
ASSERT_TRUE(prv != NULL && **prv == 1);
EXIT:
BSL_LIST_FREE(list, EmptyFree);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_LIST_Next_API_TC002
* @title list next node test
* @brief
* 1. Check if next node is NULL. Expected result 1 is obtained.
* 2. Call BSL_LIST_AddElement to add data to the linked list. Expected result 2 is obtained.
* 3. Check if next node is NULL. Expected result 3 is obtained.
* @expect
* 1. The next node is NULL.
* 2. Data added successfully. return BSL_SUCCESS.
* 3. The next node is not NULL.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_LIST_Next_API_TC002()
{
int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
/* when list is NULL */
int **next = BSL_LIST_Prev(NULL);
ASSERT_EQ(next, NULL);
/* pstList->curr == NULL */
BslList *list = BSL_LIST_New(sizeof(int));
ASSERT_TRUE(list != NULL);
next = BSL_LIST_Next(list);
ASSERT_EQ(next, NULL);
/* pstList->curr != NULL, pstList->curr->next == NULL */
ASSERT_EQ(BSL_LIST_AddElement(list, arr + 0, BSL_LIST_POS_BEFORE), BSL_SUCCESS);
next = BSL_LIST_Next(list);
ASSERT_EQ(next, NULL);
/* pstList->curr != NULL, pstList->curr->next != NULL */
ASSERT_EQ(BSL_LIST_AddElement(list, arr + 1, BSL_LIST_POS_BEFORE), BSL_SUCCESS);
next = BSL_LIST_Next(list);
ASSERT_TRUE(next != NULL && **next == 0);
/* pstList->curr == NULL, pstList->first != NULL */
next = BSL_LIST_Next(list);
ASSERT_EQ(next, NULL);
next = BSL_LIST_Next(list);
ASSERT_TRUE(next != NULL && **next == 1);
EXIT:
BSL_LIST_FREE(list, EmptyFree);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_SET_MAX_FUNC_TC001
* @title list is* Interface test
* @brief 1. BSL_LIST_SetMaxQsortCount
2. BSL_LIST_GetMaxQsortCount
3. BSL_LIST_SetMaxElements
4. BSL_LIST_GetMaxElements
* @expect 1. BSL_SUCCESS
2. g_maxQsortElem = 100001
3. BSL_SUCCESS
4. g_maxListCount = 65536
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_SET_MAX_FUNC_TC001(void)
{
ASSERT_TRUE(BSL_LIST_SetMaxQsortCount(100001) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_GetMaxQsortCount() == 100001);
ASSERT_TRUE(BSL_LIST_SetMaxElements((1 << 16)) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_GetMaxElements() == (1 << 16));
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_INVALID_INPUT_FUNC_TC001
* @title list invalid or empty input parameter value test
* @brief 0. BSL_LIST_AddElement
1. BSL_LIST_AddElement
2. BSL_LIST_Search
3. BSL_LIST_Concat
4. BSL_LIST_Sort
5. BSL_LIST_Copy
6. BSL_LIST_Copy
7. BSL_LIST_GetData
8. BSL_LIST_FirstNode
9. BSL_LIST_GetNextNode
10. BSL_LIST_GetPrevNode
11. BSL_LIST_SetMaxQsortCount
12. BSL_LIST_SetMaxElements
* @expect 0. BSL_INVALID_ARG
1. BSL_LIST_DATA_NOT_AVAILABLE
2. NULL
3. NULL
4. NULL
5. NULL
6. NULL
7. NULL
8. NULL
9. NULL
10. BSL_LIST_GetPrevNode
11. BSL_INVALID_ARG
12. BSL_INVALID_ARG
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_INVALID_INPUT_FUNC_TC001(void)
{
ASSERT_TRUE(BSL_LIST_AddElement(NULL, NULL, BSL_LIST_POS_BEFORE) == BSL_INVALID_ARG);
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
ASSERT_TRUE(BSL_LIST_AddElement(testList, NULL, BSL_LIST_POS_BEFORE) == BSL_LIST_DATA_NOT_AVAILABLE);
ASSERT_TRUE(BSL_LIST_Search(NULL, NULL, UserDataCompare, NULL) == NULL);
ASSERT_TRUE(BSL_LIST_Concat(NULL, NULL) == NULL);
ASSERT_TRUE(BSL_LIST_Sort(NULL, NULL) == NULL);
ASSERT_TRUE(BSL_LIST_Copy(NULL, UserDataCopy, UserDataFree) == NULL);
ASSERT_TRUE(BSL_LIST_Copy(testList, UserDataCopy, UserDataFree) == NULL);
ASSERT_TRUE(BSL_LIST_GetData(NULL) == NULL);
ASSERT_TRUE(BSL_LIST_FirstNode(NULL) == NULL);
ASSERT_TRUE(BSL_LIST_GetNextNode(NULL, NULL) == NULL);
ASSERT_TRUE(BSL_LIST_GetPrevNode(NULL) == NULL);
ASSERT_TRUE(BSL_LIST_SearchEx(NULL, NULL, NULL) == NULL);
ASSERT_TRUE(BSL_LIST_GetIndexNodeEx(0, NULL, NULL) == NULL);
ASSERT_TRUE(BSL_LIST_SetMaxQsortCount(10) == BSL_INVALID_ARG);
ASSERT_TRUE(BSL_LIST_SetMaxElements(10) == BSL_INVALID_ARG);
EXIT:
BSL_SAL_FREE(testList);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_DELETE_FUNC_TC001
* @title test the function of deleting a node.
* @brief
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_DELETE_FUNC_TC001(void)
{
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
ASSERT_TRUE(BSL_LIST_AddElement(testList, "aaaa", BSL_LIST_POS_BEFORE) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_AddElement(testList, "bbbb", BSL_LIST_POS_BEFORE) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_COUNT(testList) == 2);
BslListNode *tmpNode = NULL;
for (BslListNode *node = BSL_LIST_FirstNode(testList); node != NULL;) {
tmpNode = node;
char *name = BSL_LIST_GetData(tmpNode);
if (name == NULL) {
continue;
}
node = BSL_LIST_GetNextNode(testList, tmpNode);
if (strcmp(name, "aaaa") == 0) {
BSL_LIST_DeleteNode(testList, (const BslListNode *)tmpNode, UserDataFree);
continue;
}
if (strcmp(name, "bbbb") == 0) {
BSL_LIST_DeleteNode(testList, (const BslListNode *)tmpNode, UserDataFree);
continue;
}
}
ASSERT_TRUE(BSL_LIST_COUNT(testList) == 0);
ASSERT_TRUE(BSL_LIST_AddElement(testList, "cccc", BSL_LIST_POS_BEFORE) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LIST_COUNT(testList) == 1);
BSL_LIST_DeleteCurrent(testList, UserDataFree);
EXIT:
BSL_SAL_FREE(testList);
}
/* END_CASE */
/**
* @test SDV_BSL_LIST_FREE_WITHOUT_FUNC_TC001
* @title test BSL_LIST_FreeWithoutData functions
* @precon nan
* @brief
* 1.Call BSL_LIST_New create a list, Expected result 1 is obtained.
* 2.Call BSL_LIST_FreeWithoutData free normal list, Expected result 2 is obtained.
* 3.Call BSL_LIST_FreeWithoutData free empty list, Expected result 2 is obtained.
* @expect
* 1. The list is created successfully.
* 2. The list is free successfully.
*/
/* BEGIN_CASE */
void SDV_BSL_LIST_FREE_WITHOUT_FUNC_TC001(void)
{
BslList *testList = BSL_LIST_New(MAX_NAME_LEN);
ASSERT_TRUE(testList != NULL);
BSL_LIST_FreeWithoutData(testList);
testList = NULL;
EXIT:
BSL_LIST_FreeWithoutData(testList);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/bsl/list/test_suite_sdv_list.c
|
C
|
unknown
| 37,411
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include "bsl_sal.h"
#include "bsl_errno.h"
#include "bsl_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
static uintptr_t g_binlogFlag = 0;
// Binlog fixed-length callback
static void BinLogFix(uint32_t logId, uint32_t logLevel, uint32_t logType,
void *format, void *para1, void *para2, void *para3, void *para4)
{
(void)logId;
(void)logLevel;
(void)logType;
(void)format;
(void)para2;
(void)para3;
(void)para4;
g_binlogFlag = (uintptr_t)para1;
}
// Binlog variable-length callback
static void BinLogVar(uint32_t logId, uint32_t logLevel, uint32_t logType, void *format, void *para)
{
(void)logId;
(void)logLevel;
(void)logType;
(void)format;
g_binlogFlag = (uintptr_t)para;
}
void BinLogFixLenFunc(uint32_t logId, uint32_t logLevel, uint32_t logType,
void *format, void *para1, void *para2, void *para3, void *para4)
{
(void)logId;
(void)logLevel;
(void)logType;
(void)format;
(void)para1;
(void)para2;
(void)para3;
(void)para4;
}
void BinLogVarLenFunc(uint32_t logId, uint32_t logLevel, uint32_t logType,
void *format, void *para)
{
(void)logId;
(void)logLevel;
(void)logType;
(void)format;
(void)para;
}
static FILE *g_LogOutput = NULL;
// Binlog fixed-length callback, output to a file
static void BinLogFixFunc(uint32_t logId, uint32_t logLevel, uint32_t logType,
void *format, void *para1, void *para2, void *para3, void *para4)
{
uint8_t *pucFormat = (uint8_t *)format;
uint8_t ucTemp;
uint8_t ucNo = 0;
fprintf(g_LogOutput, "HITLS_BIN_LOG[FIXLEN]: logId=%u, logLevel=%u, logType=%u.\n", logId, logLevel, logType);
/* Search for all format specifiers */
while (*pucFormat != '\0') {
if (*pucFormat == '%') {
/* Get the second character */
ucTemp = *(pucFormat + 1);
if ((ucTemp == 'd') || (ucTemp == 'l') || (ucTemp == 'p') || (ucTemp == 'u') || (ucTemp == 'x')) {
ucNo++;
}
}
pucFormat++;
}
switch(ucNo) {
case 0: // Pure character strings are not output.
break;
case 1: // Output parameters only
fprintf(g_LogOutput, "0x%lX\n", (uint64_t)para1);
break;
case 2: // Output parameters only
fprintf(g_LogOutput, "0x%lX 0x%lX\n", (uint64_t)para1, (uint64_t)para2);
break;
case 3: // Output parameters only
fprintf(g_LogOutput, "0x%lX 0x%lX 0x%lX\n", (uint64_t)para1, (uint64_t)para2, (uint64_t)para3);
break;
case 4: // Output parameters only
fprintf(g_LogOutput, "0x%lX 0x%lX 0x%lX 0x%lX\n", (uint64_t)para1, (uint64_t)para2, (uint64_t)para3,
(uint64_t)para4);
break;
default: // The number of parameters is incorrect.
fprintf(g_LogOutput, "Invalid Number of Format Specifiers in LOG\n");
return;
}
}
// Binlog variable-length callback, output to a file
static void BinLogVarFunc(uint32_t logId, uint32_t logLevel, uint32_t logType, void *format, void *para)
{
uint8_t *pucFormat = (uint8_t *)format;
uint8_t ucTemp;
uint8_t ucValidNo = 0;
fprintf(g_LogOutput, "HITLS_BIN_LOG[VARLEN]: logId=%u, logLevel=%u, logType=%u.\n", logId, logLevel, logType);
while (*pucFormat != '\0') {
if (*pucFormat == '%') {
/* Get the second character */
ucTemp = *(pucFormat + 1);
if (ucTemp == 's') { // Only the %s parameter can be contained.
ucValidNo++;
}
}
pucFormat++;
}
if (ucValidNo != 1) {
fprintf(g_LogOutput, "Invalid Number of %%s present in Var Len LOG\n");
}
fprintf(g_LogOutput, "%s\n", (const char *)para);
}
/* END_HEADER */
/**
* @test SDV_BSL_LOG_VERSION_API_TC001
* @title Obtaining the HiTLS version number of the log submodule of the BSL module
* @precon nan
* @brief
* 1. The buffer of the received version string is empty
* or the buffer length of the received version string is empty. Expected result 1 is obtained.
* 2. The buffer length of the received version string is less than the minimum length.
* Expected result 2 is obtained.
* 3. Received version and length of memory application. Expected result 3 is obtained.
* @expect
* 1. Return BSL_LOG_ERR_BAD_PARAM
* 2. Return BSL_LOG_ERR_BAD_PARAM
* 3. Succeeded. The version length is equal to the current version length,
* and the version string content is equal to the current version string content.
*/
/* BEGIN_CASE */
void SDV_BSL_LOG_VERSION_API_TC001(void)
{
char version[200];
uint32_t versionLen = 100;
ASSERT_TRUE(BSL_LOG_GetVersion(NULL, NULL) == BSL_LOG_ERR_BAD_PARAM);
ASSERT_TRUE(BSL_LOG_GetVersion((char *)version, &versionLen) == BSL_LOG_ERR_BAD_PARAM);
versionLen = 200;
ASSERT_TRUE(BSL_LOG_GetVersion((char *)version, &versionLen) == BSL_SUCCESS);
ASSERT_TRUE(versionLen == strlen("openHiTLS 0.2.0 15 May 2025"));
ASSERT_TRUE(memcmp(version, "openHiTLS 0.2.0 15 May 2025", versionLen) == 0);
uint64_t versionNum = BSL_LOG_GetVersionNum();
ASSERT_EQ(versionNum, 0x00200000ULL);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_REG_BIN_LOG_FUNC_TC001
* @title Setting the Log Callback Hook
* @precon nan
* @brief
* 1. Call the BSL_LOG_RegBinLogFunc interface and leave the input parameter empty. Expected result 1 is obtained.
* 2. Call BSL_LOG_RegBinLogFunc. If funcs is not empty, fixLenFunc is empty,
* and varLenFunc is empty, expected result 2 is obtained.
* 3. Call BSL_LOG_RegBinLogFunc. If funcs is not empty, fixLenFunc is empty,
* and varLenFunc is not empty, expected result 3 is obtained.
* 4. Call BSL_LOG_RegBinLogFunc. If funcs, fixLenFunc, and varLenFunc are not empty, expected result 4 is obtained.
* 5. Call BSL_LOG_RegBinLogFunc. Ensure that funcs and fixLenFunc are not empty,
* and varLenFunc are empty. Expected result 5 is obtained.
* 6. Call BSL_LOG_RegBinLogFunc repeatedly. If funcs, fixLenFunc, and varLenFunc are not empty.
* Expected result 6 is obtained.
* @expect
* 1.BSL_NULL_INPUT
* 2.BSL_NULL_INPUT
* 3.BSL_NULL_INPUT
* 4.BSL_SUCCESS
* 5.BSL_NULL_INPUT
* 6.BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_REG_BIN_LOG_FUNC_TC001(void)
{
TestMemInit();
BSL_LOG_BinLogFuncs func = {0};
ASSERT_TRUE(BSL_LOG_RegBinLogFunc(NULL) == BSL_NULL_INPUT);
func.fixLenFunc = NULL;
func.varLenFunc = NULL;
ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_NULL_INPUT);
func.fixLenFunc = NULL;
func.varLenFunc = BinLogVarLenFunc;
ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_NULL_INPUT);
func.fixLenFunc = BinLogFixLenFunc;
func.varLenFunc = BinLogVarLenFunc;
ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_SUCCESS);
func.fixLenFunc = BinLogFixLenFunc;
func.varLenFunc = NULL;
ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_NULL_INPUT);
func.fixLenFunc = BinLogFixLenFunc;
func.varLenFunc = BinLogVarLenFunc;
ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_SUCCESS);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_BIN_LOG_API_TC001
* @title Testing the Log Recording of the Log Submodule of the BSL Module
* @precon
* @brief
* 1. Setting an invalid dotting log level. Expected result 1 is obtained.
* 2. Set a valid dotting log level and obtain the dotting log level. Expected result 2 is obtained.
* 3. Set the parameter of the dotting log callback function to NULL. Expected result 3 is obtained.
* 4. The parameter and member of the callback function for setting dotting logs are not NULL.
* Expected result 4 is obtained.
* 5. The parameter of the callback function for setting dotting logs is not NULL.
* The callback function for four parameters is not NULL, and the callback function for one parameter is NULL.
* Expected result 5 is obtained.
* 6. The parameter of the callback function for setting dotting logs is not NULL.
* The value 1 of the callback function is not NULL. The value 4 of the callback function is NULL.
* Expected result 6 is obtained.
* 7. The parameter and member of the callback function for setting dotting logs are not NULL.
* Expected result 7 is obtained.
* 8. Overwrite the callback function for setting dotting logs. Expected result 8 is obtained.
* 9. Invoke the 4 parameter dotting to filter logs by log level. Expected result 9 is obtained.
* 10. Invoke the 4 parameter dotting, and the log level is not filtered. Expected result 10 is obtained.
* 11. Invoke variable parameter dotting and log level filtering. Expected result 11 is obtained.
* 12. Invoke variable parameter dotting, and log level filtering is not performed. Expected result 12 is obtained.
* @expect
* 1. BSL_LOG_ERR_BAD_PARAM
* 2. BSL_LOG_LEVEL_ERR
* 3. BSL_LOG_LEVEL_ERR
* 4. BSL_LOG_ERR_BAD_PARAM
* 5. BSL_LOG_LEVEL_ERR
* 6. BSL_NULL_INPUT
* 7. BSL_SUCCESS
* 8. BSL_SUCCESS
* 9. The global return value is not modified.
* 10. The global return value is changed to para1.
* 11. The global return value is not modified.
* 12. The global return value is changed to para.
*/
/* BEGIN_CASE */
void SDV_BSL_BIN_LOG_API_TC001(void)
{
int32_t ret;
int32_t retlevel;
ret = BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_DEBUG + 1);
ASSERT_TRUE(ret != BSL_SUCCESS);
/*
* The get loglevel command is used to obtain the default value
* when the loglevel command fails to be set for the first time.
*/
retlevel = BSL_LOG_GetBinLogLevel();
ASSERT_TRUE(retlevel == BSL_LOG_LEVEL_ERR);
ret = BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_ERR);
ASSERT_TRUE(ret == BSL_SUCCESS);
// The BSL_LOG_GetBinLogLevel function is replaced.
retlevel = BSL_LOG_GetBinLogLevel();
ASSERT_TRUE(retlevel == BSL_LOG_LEVEL_ERR);
// If the set loglevel operation fails, get loglevel to obtain the original value.
ret = BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_DEBUG + 1);
ASSERT_TRUE(ret != BSL_SUCCESS);
retlevel = BSL_LOG_GetBinLogLevel();
ASSERT_TRUE(retlevel == BSL_LOG_LEVEL_ERR);
ret = BSL_LOG_RegBinLogFunc(NULL);
ASSERT_TRUE(ret != BSL_SUCCESS);
BSL_LOG_BinLogFuncs funcs = {NULL, NULL};
ret = BSL_LOG_RegBinLogFunc(&funcs);
ASSERT_TRUE(ret != BSL_SUCCESS);
funcs.fixLenFunc = BinLogFix;
funcs.varLenFunc = NULL;
ret = BSL_LOG_RegBinLogFunc(&funcs);
ASSERT_TRUE(ret != BSL_SUCCESS);
funcs.fixLenFunc = NULL;
funcs.varLenFunc = BinLogVar;
ret = BSL_LOG_RegBinLogFunc(&funcs);
ASSERT_TRUE(ret != BSL_SUCCESS);
funcs.fixLenFunc = BinLogFix;
funcs.varLenFunc = BinLogVar;
ret = BSL_LOG_RegBinLogFunc(&funcs);
ASSERT_TRUE(ret == BSL_SUCCESS);
g_binlogFlag = 0;
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID05001, BSL_LOG_LEVEL_DEBUG, BSL_LOG_BINLOG_TYPE_RUN, "this is test %d %d", 1, 2, 0, 0);
ASSERT_TRUE(g_binlogFlag == 0);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID05001, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "this is test %d %d", 1, 2, 0, 0);
ASSERT_TRUE(g_binlogFlag == 1);
const char *s = "abc";
g_binlogFlag = 0;
BSL_LOG_BINLOG_VARLEN(BINLOG_ID05001, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN, "this is test %s", s);
ASSERT_TRUE(g_binlogFlag == 0);
BSL_LOG_BINLOG_VARLEN(BINLOG_ID05001, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "this is test %s", s);
ASSERT_TRUE(g_binlogFlag == (uintptr_t)s);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_SET_BIN_LOG_LEVEL_API_TC001
* @title Setting the log level
* @precon nan
* @brief
* 1. Call the BSL_LOG_SetBinLogLevel interface with the input parameter BSL_LOG_LEVEL_SEC - 1.
* Expected result 1 is obtained.
* 2. Call the BSL_LOG_SetBinLogLevel interface with the input parameter BSL_LOG_LEVEL_SEC.
* Expected result 2 is obtained.
* 3. Call the BSL_LOG_SetBinLogLevel interface with the input parameter BSL_LOG_LEVEL_FATAL.
* Expected result 3 is obtained.
* 4. Call the BSL_LOG_SetBinLogLevel interface with the input parameter BSL_LOG_LEVEL_ERR.
* Expected result 4 is obtained.
* 5. Call the BSL_LOG_SetBinLogLevel interface with the input parameter BSL_LOG_LEVEL_WARN.
* Expected result 5 is obtained.
* 6. Call the BSL_LOG_SetBinLogLevel interface with the input parameter BSL_LOG_LEVEL_INFO.
* Expected result 6 is obtained.
* 7. Call the BSL_LOG_SetBinLogLevel interface with the input parameter BSL_LOG_LEVEL_DEBUG.
* Expected result 7 is obtained.
* 8. Call the BSL_LOG_SetBinLogLevel interface with the input parameter BSL_LOG_LEVEL_DEBUG + 1.
* Expected result 8 is obtained.
* @expect
* 1.BSL_LOG_ERR_BAD_PARAM
* 2.BSL_SUCCESS
* 3.BSL_SUCCESS
* 4.BSL_SUCCESS
* 5.BSL_SUCCESS
* 6.BSL_SUCCESS
* 7.BSL_SUCCESS
* 8.BSL_LOG_ERR_BAD_PARAM
*/
/* BEGIN_CASE */
void SDV_BSL_SET_BIN_LOG_LEVEL_API_TC001(void)
{
TestMemInit();
ASSERT_TRUE(BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_SEC - 1) == BSL_LOG_ERR_BAD_PARAM);
ASSERT_TRUE(BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_SEC) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_FATAL) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_ERR) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_WARN) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_INFO) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_DEBUG) == BSL_SUCCESS);
ASSERT_TRUE(BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_DEBUG + 1) == BSL_LOG_ERR_BAD_PARAM);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_BIN_LOG_FUNC_TC001
* @title Demo of dotting logs of the BSL module. The log file is /tmp/HITLS_binlog_test.log.
* @precon nan
* @brief
* 1. Clean up and reopen the file. Expected result 1 is obtained.
* 2. Setting the log level. Expected result 2 is obtained.
* 3. Registering the Dotting Log Function. Expected result 3 is obtained.
* 4. Invoke the 4 parameter dotting to filter logs by log level. Expected result 4 is obtained.
* 5. Invoke the four-parameter dot. Expected result 5 is obtained.
* 6. Invoke the 1 parameter measurement point.
* @expect
* 1. Succeeded in clearing the remaining log files.
* 2. BSL_SUCCESS
* 3. BSL_SUCCESS
* 4. No output is generated in the log file.
* 5. The log file has output.
* 6. The log file has output.
*/
/* BEGIN_CASE */
void SDV_BSL_BIN_LOG_FUNC_TC001(void)
{
int32_t ret;
const char *filename = "./HITLS_binlog_test.log";
remove(filename);
g_LogOutput = fopen(filename, "w");
ASSERT_TRUE(g_LogOutput != NULL);
ret = BSL_LOG_SetBinLogLevel(BSL_LOG_LEVEL_ERR);
ASSERT_TRUE(ret == BSL_SUCCESS);
BSL_LOG_BinLogFuncs funcs = {BinLogFixFunc, BinLogVarFunc};
ret = BSL_LOG_RegBinLogFunc(&funcs);
ASSERT_TRUE(ret == BSL_SUCCESS);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID05001, BSL_LOG_LEVEL_DEBUG, BSL_LOG_BINLOG_TYPE_RUN,
"this is test %d %d", 1, 2, 0, 0);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID05002, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"this is test %d %d", 1, 2, 2147483647, 4294967295);
BSL_LOG_BINLOG_VARLEN(BINLOG_ID05003, BSL_LOG_LEVEL_FATAL, BSL_LOG_BINLOG_TYPE_RUN,
"this is test msg: %s", "hello world");
EXIT:
fclose(g_LogOutput); // flush and close
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/bsl/log/test_suite_sdv_log.c
|
C
|
unknown
| 16,340
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include "securec.h"
#include "bsl_errno.h"
#include "bsl_obj.h"
#include "bsl_obj_internal.h"
/* END_HEADER */
extern BslOidInfo g_oidTable[];
extern uint32_t g_tableSize;
/**
* @test SDV_BSL_OBJ_CID_OID_FUNC_TC001
* @title check whether the relative sequence of cid and oid tables is corrent
* @expect success
*/
/* BEGIN_CASE */
void SDV_BSL_OBJ_CID_OID_FUNC_TC001()
{
int32_t cidIndex = 0;
int32_t oidIndex = 0;
int32_t ret = 0;
while (cidIndex < BSL_CID_MAX && oidIndex < (int32_t)g_tableSize) {
if ((int32_t)g_oidTable[oidIndex].cid == cidIndex) {
ret++;
cidIndex++;
oidIndex++;
continue;
}
if ((int32_t)g_oidTable[oidIndex].cid > cidIndex) {
cidIndex++;
continue;
}
oidIndex++;
}
ASSERT_TRUE(ret == (int32_t)g_tableSize);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_OBJ_CREATE_SIGN_ID_TC001
* @title Test BSL_OBJ_CreateSignId functionality
* @expect success
*/
/* BEGIN_CASE */
void SDV_BSL_OBJ_CREATE_SIGN_ID_TC001(void)
{
#ifndef HITLS_BSL_HASH
SKIP_TEST();
#else
BslCid signId = BSL_CID_MAX - 1;
BslCid asymId = BSL_CID_RSA;
BslCid hashId = BSL_CID_MAX - 2;
TestMemInit();
ASSERT_EQ(BSL_OBJ_CreateSignId(signId, asymId, hashId), BSL_SUCCESS);
BslCid retrievedAsymId = BSL_OBJ_GetAsymAlgIdFromSignId(signId);
ASSERT_EQ(asymId, retrievedAsymId);
BslCid retrievedHashId = BSL_OBJ_GetHashIdFromSignId(signId);
ASSERT_EQ(hashId, retrievedHashId);
BslCid retrievedSignId = BSL_OBJ_GetSignIdFromHashAndAsymId(asymId, hashId);
ASSERT_EQ(signId, retrievedSignId);
ASSERT_EQ(BSL_OBJ_CreateSignId(signId, asymId, hashId), BSL_SUCCESS);
signId = BSL_CID_SHA256WITHRSAENCRYPTION;
ASSERT_EQ(BSL_OBJ_CreateSignId(signId, asymId, hashId), BSL_SUCCESS);
ASSERT_EQ(BSL_OBJ_CreateSignId(BSL_CID_UNKNOWN, asymId, hashId), BSL_INVALID_ARG);
ASSERT_EQ(BSL_OBJ_CreateSignId(signId, BSL_CID_UNKNOWN, hashId), BSL_INVALID_ARG);
ASSERT_EQ(BSL_OBJ_CreateSignId(signId, asymId, BSL_CID_UNKNOWN), BSL_INVALID_ARG);
BSL_OBJ_FreeSignHashTable();
EXIT:
return;
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_OBJ_CREATE_TC001
* @title Test BSL_OBJ_Create functionality
* @expect success
*/
/* BEGIN_CASE */
void SDV_BSL_OBJ_CREATE_TC001()
{
#ifndef HITLS_BSL_HASH
SKIP_TEST();
#else
char *testOidName = "TEST-OID";
BslCid testCid = BSL_CID_MAX + 1;
char testOidData[] = "\52\206\110\206\367\15\1\11\30";
BslOidString testOid = {9, testOidData, BSL_OID_GLOBAL};
const char *aesOidName = "AES128-CBC";
BslCid aesCid = BSL_CID_AES128_CBC;
char aesOidData[] = "\140\206\110\1\145\3\4\1\2";
TestMemInit();
ASSERT_EQ(BSL_OBJ_Create(aesOidData, 9, aesOidName, aesCid), BSL_SUCCESS);
ASSERT_EQ(BSL_OBJ_Create(testOidData, 9, testOidName, testCid), BSL_SUCCESS);
BslCid retrievedCid = BSL_OBJ_GetCID(&testOid);
ASSERT_EQ(testCid, retrievedCid);
BslOidString *retrievedOid = BSL_OBJ_GetOID(testCid);
ASSERT_TRUE(retrievedOid != NULL);
ASSERT_EQ(testOid.octetLen, retrievedOid->octetLen);
ASSERT_EQ(memcmp(testOid.octs, retrievedOid->octs, testOid.octetLen), 0);
const char *retrievedName = BSL_OBJ_GetOidNameFromOid(&testOid);
ASSERT_TRUE(retrievedName != NULL);
ASSERT_EQ(strcmp(testOidName, retrievedName), 0);
ASSERT_EQ(BSL_OBJ_Create(testOidData, 9, testOidName, testCid), BSL_SUCCESS);
ASSERT_EQ(BSL_OBJ_Create(NULL, 9, testOidName, testCid), BSL_INVALID_ARG);
ASSERT_EQ(BSL_OBJ_Create(testOidData, 9, NULL, testCid), BSL_INVALID_ARG);
ASSERT_EQ(BSL_OBJ_Create(testOidData, 9, testOidName, BSL_CID_UNKNOWN), BSL_INVALID_ARG);
BSL_OBJ_FreeHashTable();
EXIT:
return;
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_OBJ_HASH_TABLE_LOOKUP_TC001
* @title Test hash table lookup functionality for OIDs and CIDs
* @expect success
*/
/* BEGIN_CASE */
void SDV_BSL_OBJ_HASH_TABLE_LOOKUP_TC001()
{
#ifndef HITLS_BSL_HASH
SKIP_TEST();
#else
int32_t ret;
BslOidString testOid1, testOid2;
const char *testOidName1 = "TEST-OID-1";
const char *testOidName2 = "TEST-OID-2";
BslCid testCid1 = BSL_CID_MAX + 1;
BslCid testCid2 = BSL_CID_MAX + 2;
char testOidData1[] = "\52\206\110\206\367\15\1\11\31";
char testOidData2[] = "\52\206\110\206\367\15\1\11\32";
testOid1.octetLen = sizeof(testOidData1);
testOid1.octs = testOidData1;
testOid1.flags = BSL_OID_GLOBAL;
testOid2.octetLen = sizeof(testOidData2);
testOid2.octs = testOidData2;
testOid2.flags = BSL_OID_GLOBAL;
TestMemInit();
ret = BSL_OBJ_Create(testOidData1, sizeof(testOidData1), testOidName1, testCid1);
ASSERT_EQ(BSL_SUCCESS, ret);
ret = BSL_OBJ_Create(testOidData2, sizeof(testOidData2), testOidName2, testCid2);
ASSERT_EQ(BSL_SUCCESS, ret);
BslCid retrievedCid1 = BSL_OBJ_GetCID(&testOid1);
ASSERT_EQ(testCid1, retrievedCid1);
BslCid retrievedCid2 = BSL_OBJ_GetCID(&testOid2);
ASSERT_EQ(testCid2, retrievedCid2);
BslOidString *retrievedOid1 = BSL_OBJ_GetOID(testCid1);
ASSERT_TRUE(retrievedOid1 != NULL);
ASSERT_EQ(testOid1.octetLen, retrievedOid1->octetLen);
ASSERT_EQ(memcmp(testOid1.octs, retrievedOid1->octs, testOid1.octetLen), 0);
BslOidString *retrievedOid2 = BSL_OBJ_GetOID(testCid2);
ASSERT_TRUE(retrievedOid2 != NULL);
ASSERT_EQ(testOid2.octetLen, retrievedOid2->octetLen);
ASSERT_EQ(memcmp(testOid2.octs, retrievedOid2->octs, testOid2.octetLen), 0);
const char *retrievedName1 = BSL_OBJ_GetOidNameFromOid(&testOid1);
ASSERT_TRUE(retrievedName1 != NULL);
ASSERT_EQ(strcmp(testOidName1, retrievedName1), 0);
const char *retrievedName2 = BSL_OBJ_GetOidNameFromOid(&testOid2);
ASSERT_TRUE(retrievedName2 != NULL);
ASSERT_EQ(strcmp(testOidName2, retrievedName2), 0);
BSL_OBJ_FreeHashTable();
EXIT:
return;
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_OBJ_GetOIDNUMBERICSTRING_FUNC_TC001
* @title Test converting an ASN.1 OID to its numeric representation
* @expect success
*/
/* BEGIN_CASE */
void SDV_BSL_OBJ_GetOIDNUMBERICSTRING_FUNC_TC001(Hex *str, char *expect)
{
char *oid = NULL;
uint8_t *hexOid = NULL;
TestMemInit();
oid = BSL_OBJ_GetOidNumericString(str->x, str->len);
ASSERT_TRUE(oid != NULL);
ASSERT_EQ(memcmp(oid, expect, strlen(expect)), 0);
uint32_t outLen = 0;
hexOid = BSL_OBJ_GetOidFromNumericString(expect, strlen(expect), &outLen);
ASSERT_TRUE(hexOid != NULL);
ASSERT_EQ(outLen, str->len);
ASSERT_COMPARE("test obj", hexOid, outLen, str->x, str->len);
EXIT:
if (oid != NULL) {
free(oid);
}
BSL_SAL_Free(hexOid);
return;
}
/* END_CASE */
/**
* @test SDV_BSL_OBJ_GetOIDNUMBERICSTRING_FUNC_TC002
* @title Test converting an ASN.1 OID to its numeric representation (Counterexample)
* @expect success
*/
/* BEGIN_CASE */
void SDV_BSL_OBJ_GetOIDNUMBERICSTRING_FUNC_TC002(Hex *str)
{
ASSERT_TRUE(BSL_OBJ_GetOidNumericString(str->x, str->len) == NULL);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_OBJ_GetOIDNUMBERICSTRING_FUNC_TC001
* @title Exception Parameter Testing for the BSL_OBJ_GetOidFromNumericString Function.
* @expect success
*/
/* BEGIN_CASE */
void SDV_BSL_OBJ_GETOID_FROM_NUMBERIC_FUNC_TC001(char *expect)
{
TestMemInit();
uint32_t outLen = 0;
uint8_t *hexOid = NULL;
ASSERT_TRUE(BSL_OBJ_GetOidFromNumericString(NULL, 0, &outLen) == NULL);
ASSERT_TRUE(BSL_OBJ_GetOidFromNumericString(expect, strlen(expect), NULL) == NULL);
hexOid = BSL_OBJ_GetOidFromNumericString(expect, strlen(expect), &outLen);
ASSERT_TRUE(hexOid == NULL);
EXIT:
BSL_SAL_FREE(hexOid);
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/bsl/obj/test_suite_sdv_obj.c
|
C
|
unknown
| 8,453
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include "bsl_sal.h"
#include "bsl_params.h"
#include "bsl_err.h"
#include "bsl_log.h"
/* END_HEADER */
/* BEGIN_CASE */
void SDV_BSL_BSL_PARAM_InitValue_API_TC001()
{
BSL_Param param = {0};
int32_t val = 1;
bool valBool = true;
int32_t *valPtr = &val;
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 0, BSL_PARAM_TYPE_UINT32,
&val, sizeof(val)), BSL_PARAMS_INVALID_KEY);
ASSERT_EQ(BSL_PARAM_InitValue(NULL, 1, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_INVALID_ARG);
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 1, BSL_PARAM_TYPE_UINT32, NULL, sizeof(val)), BSL_INVALID_ARG);
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 1, 100, &val, sizeof(val)), BSL_PARAMS_INVALID_TYPE);
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 1, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 1, BSL_PARAM_TYPE_BOOL, &valBool, sizeof(valBool)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 1, BSL_PARAM_TYPE_FUNC_PTR, valPtr, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 1, BSL_PARAM_TYPE_CTX_PTR, valPtr, 0), BSL_SUCCESS);
valPtr = NULL;
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 1, BSL_PARAM_TYPE_FUNC_PTR, valPtr, 0), BSL_SUCCESS);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_BSL_PARAM_SetValue_API_TC001()
{
BSL_Param param = {0};
int32_t val = 1;
bool valBool = true;
int32_t *valPtr = &val;
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 1, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_SetValue(¶m, 0, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_PARAMS_INVALID_KEY);
ASSERT_EQ(BSL_PARAM_SetValue(NULL, 1, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_INVALID_ARG);
ASSERT_EQ(BSL_PARAM_SetValue(¶m, 2, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_PARAMS_MISMATCH);
ASSERT_EQ(BSL_PARAM_SetValue(¶m, 1, BSL_PARAM_TYPE_UINT32, &val, 5), BSL_INVALID_ARG);
ASSERT_EQ(BSL_PARAM_SetValue(¶m, 1, BSL_PARAM_TYPE_UINT32, NULL, sizeof(val)), BSL_INVALID_ARG);
val = 4;
ASSERT_EQ(BSL_PARAM_SetValue(¶m, 1, BSL_PARAM_TYPE_OCTETS_PTR, &val, sizeof(val)), BSL_PARAMS_MISMATCH);
ASSERT_EQ(BSL_PARAM_SetValue(¶m, 1, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_SUCCESS);
int32_t retVal = 0;
uint32_t retValLen = sizeof(retVal);
ASSERT_EQ(BSL_PARAM_GetValue(¶m, 1, BSL_PARAM_TYPE_UINT32, &retVal, &retValLen), BSL_SUCCESS);
ASSERT_EQ(retVal, val);
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 1, BSL_PARAM_TYPE_BOOL, &valBool, sizeof(valBool)), BSL_SUCCESS);
valBool = false;
ASSERT_EQ(BSL_PARAM_SetValue(¶m, 1, BSL_PARAM_TYPE_BOOL, &valBool, sizeof(valBool)), BSL_SUCCESS);
uint32_t boolSize = sizeof(valBool);
ASSERT_EQ(BSL_PARAM_GetValue(¶m, 1, BSL_PARAM_TYPE_BOOL, &valBool, &boolSize), BSL_SUCCESS);
ASSERT_EQ(valBool, false);
ASSERT_EQ(BSL_PARAM_InitValue(¶m, 1, BSL_PARAM_TYPE_FUNC_PTR, valPtr, 0), BSL_SUCCESS);
*valPtr = 0;
ASSERT_EQ(BSL_PARAM_SetValue(¶m, 1, BSL_PARAM_TYPE_FUNC_PTR, valPtr, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_GetPtrValue(¶m, 1, BSL_PARAM_TYPE_FUNC_PTR, (void **)&valPtr, NULL), BSL_SUCCESS);
ASSERT_EQ(*valPtr, 0);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_BSL_PARAM_FindParam_API_TC001()
{
BSL_Param param[6] = {0};
int32_t val = 1;
bool valBool = true;
int32_t *valPtr = &val;
ASSERT_EQ(BSL_PARAM_InitValue(¶m[0], 1, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[1], 2, BSL_PARAM_TYPE_BOOL, &valBool, sizeof(valBool)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[2], 3, BSL_PARAM_TYPE_FUNC_PTR, valPtr, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_InitValue(¶m[3], 4, BSL_PARAM_TYPE_CTX_PTR, valPtr, 0), BSL_SUCCESS);
BSL_Param *temp = NULL;
temp = BSL_PARAM_FindParam(param, 1);
ASSERT_EQ(temp, ¶m[0]);
temp = BSL_PARAM_FindParam(param, 2);
ASSERT_EQ(temp, ¶m[1]);
temp = BSL_PARAM_FindParam(param, 5);
ASSERT_EQ(temp, NULL);
EXIT:
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/bsl/params/test_suite_sdv_params.c
|
C
|
unknown
| 4,766
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "bsl_sal.h"
#include "bsl_params.h"
#include "bsl_err.h"
#include "bsl_list.h"
#include "crypt_eal_cipher.h"
/* END_HEADER */
/* BEGIN_CASE */
void SDV_BSL_BSL_PARAM_MAKER_New_API_TC001()
{
BSL_ParamMaker *maker = BSL_PARAM_MAKER_New();
ASSERT_TRUE(maker != NULL);
EXIT:
if (maker) {
BSL_PARAM_MAKER_Free(maker);
}
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_BSL_PARAM_MAKER_Push_Value_API_TC001()
{
int32_t val = 1;
bool valBool = true;
int32_t *valPtr = &val;
int32_t key = 1;
BSL_ParamMaker *maker = BSL_PARAM_MAKER_New();
ASSERT_TRUE(maker != NULL);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(NULL, key, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_NULL_INPUT);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_UINT32, NULL, sizeof(val)), BSL_NULL_INPUT);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_UINT32, &val, sizeof(val)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_BOOL, &valBool, sizeof(valBool)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_FUNC_PTR, valPtr, sizeof(valPtr)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_CTX_PTR, valPtr, sizeof(valPtr)), BSL_SUCCESS);
valPtr = NULL;
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_FUNC_PTR, valPtr, 0), BSL_SUCCESS);
EXIT:
if (maker) {
BSL_PARAM_MAKER_Free(maker);
}
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_BSL_PARAM_MAKER_ToParam_API_TC001()
{
int32_t val = 1;
uint8_t u8 = 10;
uint16_t u16 = 20;
uint32_t u32 = 100;
bool valBool = true;
int32_t key = 1;
int32_t index = 1;
BSL_ParamMaker *maker = BSL_PARAM_MAKER_New();
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_UINT32, &u32, sizeof(u32)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_BOOL, &valBool, sizeof(valBool)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_INT32, &val, sizeof(val)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_UINT8, &u8, sizeof(u8)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_UINT16, &u16, sizeof(u16)), BSL_SUCCESS);
BSL_Param *params = BSL_PARAM_MAKER_ToParam(maker);
ASSERT_TRUE(params != NULL);
BSL_Param *temp = NULL;
key = 1;
temp = BSL_PARAM_FindParam(params, key++);
ASSERT_EQ(temp->value, params->value);
ASSERT_EQ(*((uint32_t *)temp->value), u32);
temp = BSL_PARAM_FindParam(params, key++);
ASSERT_EQ(temp->value, (¶ms[index++])->value);
ASSERT_EQ(*((bool *)temp->value), valBool);
temp = BSL_PARAM_FindParam(params, key++);
ASSERT_EQ(temp->value, (¶ms[index++])->value);
ASSERT_EQ(*((int32_t *)temp->value), val);
temp = BSL_PARAM_FindParam(params, key++);
ASSERT_EQ(temp->value, (¶ms[index++])->value);
ASSERT_EQ(*((uint8_t *)temp->value), u8);
temp = BSL_PARAM_FindParam(params, key++);
ASSERT_EQ(temp->value, (¶ms[index++])->value);
ASSERT_EQ(*((uint16_t *)temp->value), u16);
EXIT:
if (maker) {
BSL_PARAM_MAKER_Free(maker);
}
if (params) {
BSL_PARAM_Free(params);
}
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_BSL_PARAM_MAKER_ToParam_API_TC002()
{
char str[] = "aaa";
uint32_t u32 = 100;
uint32_t *ptr = &u32;
unsigned char OCTETS[1];
OCTETS[0] = 'a';
int32_t key = 1;
int32_t index = 1;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
BSL_ParamMaker *maker = BSL_PARAM_MAKER_New();
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_UTF8_STR, &str, sizeof(str)), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_CTX_PTR, ctx, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_UINT32_PTR, ptr, 0), BSL_SUCCESS);
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key++, BSL_PARAM_TYPE_OCTETS, &OCTETS, sizeof(OCTETS)), BSL_SUCCESS);
BSL_Param *params = BSL_PARAM_MAKER_ToParam(maker);
BSL_Param *temp = NULL;
key = 1;
temp = BSL_PARAM_FindParam(params, key++);
ASSERT_EQ(temp->value, params->value);
ASSERT_TRUE(memcmp((char *)temp->value, str, sizeof(str)) == 0);
temp = BSL_PARAM_FindParam(params, key++);
ASSERT_EQ(temp->value, (¶ms[index++])->value);
ASSERT_TRUE(memcmp((CRYPT_EAL_CipherCtx *)temp->value, ctx, 0) == 0);
temp = BSL_PARAM_FindParam(params, key++);
ASSERT_EQ(temp->value, (¶ms[index++])->value);
ASSERT_EQ(*((uint32_t *)temp->value), u32);
temp = BSL_PARAM_FindParam(params, key++);
ASSERT_EQ(temp->value, (¶ms[index++])->value);
ASSERT_TRUE(memcmp((unsigned char *)temp->value, &OCTETS, sizeof(OCTETS)) == 0);
BSL_PARAM_Free(params);
params = NULL;
key = 1;
ASSERT_EQ(BSL_PARAM_MAKER_PushValue(maker, key, BSL_PARAM_TYPE_UTF8_STR, &str, sizeof(str) - 2), BSL_SUCCESS);
params = BSL_PARAM_MAKER_ToParam(maker);
temp = BSL_PARAM_FindParam(params, key);
ASSERT_EQ(temp->value, params->value);
ASSERT_TRUE(memcmp((char *)temp->value, str, sizeof(str) - 2) == 0);
ASSERT_TRUE(memcmp((char *)temp->value, str, sizeof(str)) == 0);
EXIT:
if (maker) {
BSL_PARAM_MAKER_Free(maker);
}
if (params) {
BSL_PARAM_Free(params);
}
if (ctx) {
CRYPT_EAL_CipherFreeCtx(ctx);
}
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/bsl/params/test_suite_sdv_params_maker.c
|
C
|
unknown
| 6,184
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "securec.h"
#include "bsl_errno.h"
#include "bsl_sal.h"
#include "bsl_pem_internal.h"
/* END_HEADER */
/* BEGIN_CASE */
void SDV_BSL_PEM_ISPEM_FUNC_TC001(char *data, int expflag)
{
char *encode = data;
uint32_t encodeLen = strlen(data);
bool isPem = BSL_PEM_IsPemFormat(encode, encodeLen);
ASSERT_TRUE(isPem == (bool)expflag);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_PEM_ISPEM_FUNC_TC002(void)
{
char *aa = "aaaaaaaa";
ASSERT_TRUE(BSL_PEM_IsPemFormat(NULL, 0) == false);
ASSERT_TRUE(BSL_PEM_IsPemFormat(aa, strlen(aa)) == false);
EXIT:
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_PEM_PARSE_FUNC_TC001(char *encode, char *head, char *tail, int expRes)
{
BSL_PEM_Symbol sym = {head, tail};
char *pemdata = encode;
uint32_t len = strlen(encode);
uint8_t *asn1Encode = NULL;
uint32_t asn1Len;
TestMemInit();
ASSERT_EQ(BSL_PEM_DecodePemToAsn1(&pemdata, &len, &sym, &asn1Encode, &asn1Len), expRes);
EXIT:
BSL_SAL_Free(asn1Encode);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_PEM_PARSE_FUNC_TC002(void)
{
BSL_PEM_Symbol sym = {BSL_PEM_EC_PRI_KEY_BEGIN_STR, BSL_PEM_EC_PRI_KEY_END_STR};
char *pemdata = "-----BEGIN EC PRIVATE KEY-----\n"
"MHcCAQEEIAadtjyegBKXLH9xvNDvH24j7cn3PsaNSXSMIVmvJZM7oAoGCCqGSM49\n"
"AwEHoUQDQgAEPFKNDGyE7HES1hPd8mXydX4QunGvk37ISPOhXJStzxTt8sWdcEtV\n"
"gaXhArNx9Dz8pKIhoGcviy8xML3wPICv9Q==\n"
"-----END EC PRIVATE KEY-----\n"
"-----BEGIN EC PRIVATE KEY-----\n"
"MHcCAQEEIAadtjyegBKXLH9xvNDvH24j7cn3PsaNSXSMIVmvJZM7oAoGCCqGSM49\n"
"AwEHoUQDQgAEPFKNDGyE7HES1hPd8mXydX4QunGvk37ISPOhXJStzxTt8sWdcEtV\n"
"gaXhArNx9Dz8pKIhoGcviy8xML3wPICv9Q==\n"
"-----END EC PRIVATE KEY-----\n";
int32_t len = strlen(pemdata);
char *next = pemdata;
uint32_t nextLen = len;
uint8_t *asn1Encode = NULL;
uint32_t asn1Len;
TestMemInit();
ASSERT_TRUE(BSL_PEM_DecodePemToAsn1(&next, &nextLen, &sym, &asn1Encode, &asn1Len) == BSL_SUCCESS);
BSL_SAL_Free(asn1Encode);
ASSERT_TRUE(BSL_PEM_DecodePemToAsn1(&next, &nextLen, &sym, &asn1Encode, &asn1Len) == BSL_SUCCESS);
EXIT:
BSL_SAL_Free(asn1Encode);
return;
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_PEM_PARSE_FUNC_TC003(void)
{
BSL_PEM_Symbol sym = {BSL_PEM_EC_PRI_KEY_BEGIN_STR, BSL_PEM_EC_PRI_KEY_END_STR};
char *pemdata = "-----BEGIN EC PRIVATE KEY-----END EC PRIVATE KEY------------------END-----\n";
int32_t len = strlen(pemdata);
char *next = pemdata;
uint32_t nextLen = len;
uint8_t *asn1Encode = NULL;
uint32_t asn1Len;
ASSERT_TRUE(BSL_PEM_DecodePemToAsn1(&next, &nextLen, &sym, &asn1Encode, &asn1Len) == BSL_PEM_SYMBOL_NOT_FOUND);
EXIT:
BSL_SAL_Free(asn1Encode);
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/bsl/pem/test_suite_sdv_pem.c
|
C
|
unknown
| 3,581
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_errno.h"
#include "sal_atomic.h"
#define TEST_THREAD_DEFAULT_TC001_WRITE_CNT 100000
#define TEST_WRITE_PID_CNT 2
#define TEST_READ_PID_CNT 2
int g_threadDefaultWrite001 = 0;
int g_threadDefaultRead001 = 0;
uint64_t g_threadDefaultId001 = 0;
static void *StdMalloc(uint32_t len)
{
return malloc((size_t)len);
}
static int32_t pthreadRWLockNew(BSL_SAL_ThreadLockHandle *lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
pthread_rwlock_t *newLock;
newLock = (pthread_rwlock_t *)BSL_SAL_Malloc(sizeof(pthread_rwlock_t));
if (newLock == NULL) {
return BSL_MALLOC_FAIL;
}
if (pthread_rwlock_init(newLock, NULL) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
*lock = newLock;
return BSL_SUCCESS;
}
static void pthreadRWLockFree(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return;
}
pthread_rwlock_destroy((pthread_rwlock_t *)lock);
BSL_SAL_FREE(lock);
}
static int32_t pthreadRWLockReadLock(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
if (pthread_rwlock_rdlock((pthread_rwlock_t *)lock) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
return BSL_SUCCESS;
}
static int32_t pthreadRWLockWriteLock(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
if (pthread_rwlock_wrlock((pthread_rwlock_t *)lock) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
return BSL_SUCCESS;
}
static int32_t pthreadRWLockUnlock(BSL_SAL_ThreadLockHandle lock)
{
if (lock == NULL) {
return BSL_SAL_ERR_BAD_PARAM;
}
if (pthread_rwlock_unlock((pthread_rwlock_t *)lock) != 0) {
return BSL_SAL_ERR_UNKNOWN;
}
return BSL_SUCCESS;
}
static uint64_t pthreadGetId(void)
{
return (uint64_t)pthread_self();
}
#ifdef HITLS_BSL_SAL_THREAD
static void *TEST_Read(void *arg)
{
BSL_SAL_ThreadLockHandle lock = (BSL_SAL_ThreadLockHandle)arg;
int32_t ret = BSL_SAL_ThreadReadLock(lock);
g_threadDefaultRead001 = g_threadDefaultWrite001;
BSL_SAL_ThreadUnlock(lock);
ASSERT_TRUE(ret == BSL_SUCCESS);
EXIT:
return NULL;
}
static void *TEST_Write(void *arg)
{
BSL_SAL_ThreadLockHandle lock = (BSL_SAL_ThreadLockHandle)arg;
int32_t ret = BSL_SUCCESS;
for (size_t i = 0; i < TEST_THREAD_DEFAULT_TC001_WRITE_CNT; i++) {
if (BSL_SAL_ThreadWriteLock(lock) != BSL_SUCCESS) {
ret = BSL_SAL_ERR_UNKNOWN;
}
g_threadDefaultWrite001++;
g_threadDefaultId001 = BSL_SAL_ThreadGetId();
BSL_SAL_ThreadUnlock(lock);
}
ASSERT_TRUE(ret == BSL_SUCCESS);
EXIT:
return NULL;
}
#endif
/* END_HEADER */
/**
* @test SDV_BSL_SAL_REGMEM_API_TC001
* @title Registering memory-related functions
* @precon nan
* @brief
* 1. Call BSL_SAL_Malloc to allocate 0-byte space. Expected result 1 is obtained.
* 2. Call BSL_SAL_Malloc to allocate 1-byte space. Expected result 2 is obtained.
* 3. Call BSL_SAL_Calloc to allocate a large memory space. Expected result 3 is obtained.
* 4. Call BSL_SAL_CallBack_Ctrl to transfer an exception parameter. Expected result 4 is obtained.
* 5. Call BSL_SAL_CallBack_Ctrl to transfer an normal parameter. Expected result 5 is obtained.
* 6. Call BSL_SAL_Malloc to allocate 8-byte space. Expected result 6 is obtained.
* 7. Call BSL_SAL_FREE to free 8-byte space. Expected result 7 is obtained.
* @expect
* 1. Failed to apply for the memory. NULL is returned.
* 2. Memory application succeeded.
* 3. Failed to apply for the memory. NULL is returned.
* 4. Failed to register the callback, return BSL_SAL_ERR_BAD_PARAM
* 5. Registration callback succeeded, return BSL_SUCCESS.
* 6. Memory application succeeded.
* 7. The memory is released successfully.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_REGMEM_API_TC001(void)
{
void *ptr = NULL;
ptr = BSL_SAL_Malloc(0);
ASSERT_TRUE(ptr == NULL);
#ifdef HITLS_BSL_SAL_MEM
ptr = BSL_SAL_Malloc(1);
ASSERT_TRUE(ptr != NULL);
BSL_SAL_FREE(ptr);
#endif
ptr = BSL_SAL_Calloc(0xFFFFFFFF, 0xFFFFFFFF);
ASSERT_TRUE(ptr == NULL);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(0, NULL) == BSL_SAL_ERR_BAD_PARAM);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_MALLOC, NULL) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_MALLOC, StdMalloc) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_FREE, free) == BSL_SUCCESS);
ptr = BSL_SAL_Malloc(0);
ASSERT_TRUE(ptr != NULL);
BSL_SAL_FREE(ptr);
ASSERT_TRUE(ptr == NULL);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_REG_THREAD_API_TC001
* @title Register thread-related functions.
* @precon nan
* @brief
* 1. Call BSL_SAL_CallBack_Ctrl to transfer an exception parameter. Expected result 1 is obtained.
* 2. Call BSL_SAL_CallBack_Ctrl to transfer an normal parameter. Expected result 2 is obtained.
* 3. Call BSL_SAL_ThreadLockNew to transfer an exception parameter. Expected result 3 is obtained.
* 4. Call BSL_SAL_ThreadReadLock to transfer an exception parameter. Expected result 4 is obtained.
* 5. Call BSL_SAL_ThreadWriteLock to transfer an exception parameter. Expected result 5 is obtained.
* 6. Call BSL_SAL_ThreadUnlock to transfer an exception parameter. Expected result 6 is obtained.
* 7. Call BSL_SAL_ThreadLockFree to transfer an exception parameter. Expected result 7 is obtained.
* @expect
* 1. Failed to register the callback, return BSL_SAL_ERR_BAD_PARAM
* 2. Registration callback succeeded, return BSL_SUCCESS.
* 9. Failed to create the new lock, return BSL_SAL_ERR_BAD_PARAM
* 10. Failed to create the read lock, return BSL_SAL_ERR_BAD_PARAM
* 11. Failed to create the write lock, return BSL_SAL_ERR_BAD_PARAM
* 12. Failed to unlock, return BSL_SAL_ERR_BAD_PARAM
* 13. No return value
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_REG_THREAD_API_TC001(void)
{
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(0, NULL) == BSL_SAL_ERR_BAD_PARAM);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(0, NULL) == BSL_SAL_ERR_BAD_PARAM);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_NEW_CB_FUNC, pthreadRWLockNew) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_FREE_CB_FUNC, pthreadRWLockFree) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_READ_LOCK_CB_FUNC, pthreadRWLockReadLock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_WRITE_LOCK_CB_FUNC, pthreadRWLockWriteLock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_LOCK_UNLOCK_CB_FUNC, pthreadRWLockUnlock) == BSL_SUCCESS);
ASSERT_TRUE(BSL_SAL_CallBack_Ctrl(BSL_SAL_THREAD_GET_ID_CB_FUNC, pthreadGetId) == BSL_SUCCESS);
// Cannot create a lock handle because the pointer of the pointer is NULL.
ASSERT_TRUE(BSL_SAL_ThreadLockNew(NULL) == BSL_SAL_ERR_BAD_PARAM);
ASSERT_TRUE(BSL_SAL_ThreadReadLock(NULL) == BSL_SAL_ERR_BAD_PARAM);
ASSERT_TRUE(BSL_SAL_ThreadWriteLock(NULL) == BSL_SAL_ERR_BAD_PARAM);
ASSERT_TRUE(BSL_SAL_ThreadUnlock(NULL) == BSL_SAL_ERR_BAD_PARAM);
BSL_SAL_ThreadLockFree(NULL);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_MEM_API_TC001
* @title Test the memory application function when the memory registration callback function is not invoked.
* @precon nan
* @brief
* 1. Call BSL_SAL_Malloc to allocate 100-byte space. Expected result 1 is obtained.
* 2. Call BSL_SAL_ClearFree to free 100-byte space. Expected result 2 is obtained.
* @expect
* 1. Memory application succeeded.
* 2. The memory is released successfully.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_MEM_API_TC001(void)
{
#ifndef HITLS_BSL_SAL_MEM
SKIP_TEST();
#else
// 1
void *obj = BSL_SAL_Malloc(100);
ASSERT_TRUE(obj != NULL);
memset_s(obj, 100, 0x1, 100);
BSL_SAL_ClearFree(obj, 100);
EXIT:
return;
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_MEM_API_TC001
* @title Test the memory application function when the memory registration callback function is not invoked.
* @precon nan
* @brief
* 1. Call BSL_SAL_Malloc to allocate 1-byte space. Expected result 1 is obtained.
* 2. Call BSL_SAL_Calloc to allocate 1000-byte space. Expected result 2 is obtained.
* @expect
* 1. Memory application succeeded.
* 2. Memory application succeeded.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_MEM_API_TC002(void)
{
#ifndef HITLS_BSL_SAL_MEM
SKIP_TEST();
#else
// 1
void *obj = BSL_SAL_Malloc(1);
ASSERT_TRUE(obj != NULL);
BSL_SAL_FREE(obj);
uint8_t objZero3[1000] = {0};
uint8_t *obj3 = (uint8_t *)BSL_SAL_Calloc(1000, sizeof(uint8_t));
ASSERT_TRUE(obj3 != NULL);
ASSERT_TRUE(memcmp(objZero3, obj3, 1000) == 0);
BSL_SAL_FREE(obj3);
EXIT:
return;
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_DUMP_API_TC001
* @title Test the function of the dump interface when the memory-related callback is not registered.
* @precon nan
* @brief
* 1. Call BSL_SAL_Dump with the source memory address set to NULL. Expected result 1 is obtained.
* 2. Call BSL_SAL_Dump to set the total memory size to 0. Expected result 2 is obtained.
* 3. Call BSL_SAL_Dump interface to transfer normal parameters. Expected result 3 is obtained.
* @expect
* 1. Failed to duplicate the memory space. Return NULL.
* 2. Failed to duplicate the memory space. Return NULL.
* 3. Succeeded in duplicate the memory space.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_DUMP_API_TC001(void)
{
#ifndef HITLS_BSL_SAL_MEM
SKIP_TEST();
#else
uint32_t memLen = 1024U;
void *testPtr = NULL;
void *srcPtr = BSL_SAL_Malloc(memLen);
ASSERT_TRUE(srcPtr != NULL);
// 1
ASSERT_TRUE(BSL_SAL_Dump(NULL, memLen) == NULL);
// 2
ASSERT_TRUE(BSL_SAL_Dump(srcPtr, 0) == NULL);
// 3
testPtr = BSL_SAL_Dump(srcPtr, memLen);
ASSERT_TRUE(testPtr != NULL);
ASSERT_TRUE(memcmp(testPtr, srcPtr, memLen) == 0);
EXIT:
BSL_SAL_FREE(srcPtr);
BSL_SAL_FREE(testPtr);
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_REALLOC_API_TC001
* @title Test functions related to reallocation when the memory-related callback is not registered.
* @precon nan
* @brief
* 1. The size of the extended memory is smaller than the original size. Expected result 1 is obtained.
* 2. The size of the extended memory is smaller than the original size. Expected result 2 is obtained.
* @expect
* 1. Success. The extended memory address is returned.
* 2. Success. The extended memory address is returned. No ASAN alarm is generated for realloc memory read/write.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_REALLOC_API_TC001(void)
{
#ifndef HITLS_BSL_SAL_MEM
SKIP_TEST();
#else
uint32_t originSize = 2000u;
uint32_t biggerSize = 3000u;
uint32_t smallerSize = 1000u;
void *obj = BSL_SAL_Malloc(originSize);
ASSERT_TRUE(obj != NULL);
// 1
void *obj2 = BSL_SAL_Realloc(obj, smallerSize, originSize);
// 2
uint8_t *obj3 = (uint8_t *)BSL_SAL_Realloc(obj2, biggerSize, smallerSize);
ASSERT_TRUE(obj3 != NULL);
ASSERT_TRUE(memset_s(obj3, biggerSize, 1, biggerSize) == EOK);
ASSERT_TRUE(obj3[biggerSize - 1] == 1);
// The realloc releases the obj. Therefore, the obj does not need to be released.
// The value of realloc size to 0 is an implementation definition. Therefore, the test is not performed.
EXIT:
BSL_SAL_FREE(obj3);
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_THREAD_CREATE_FUNC_TC001
* @title Creating and Closing Threads test
* @precon nan
* @brief
* 1. Unregistered thread-related callback and create a thread lock. Expected result 1 is obtained.
* 2. Call BSL_SAL_ThreadCreate to transfer abnormal parameters. Expected result 2 is obtained.
* 3. Call BSL_SAL_ThreadCreate to transfer normal parameters. Expected result 3 is obtained.
* 4. Call BSL_SAL_ThreadClose to transfer normal parameters. Expected result 4 is obtained.
* 5. Call BSL_SAL_ThreadClose to transfer abnormal parameters. Expected result 5 is obtained.
* 6. Release the lock. Expected result 6 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2. BSL_SAL_ERR_BAD_PARAM
* 3. BSL_SUCCESS
* 4. The thread is closed successfully.
* 5. No return value
* 6. Lock released successfully.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_THREAD_CREATE_FUNC_TC001(void)
{
#ifndef HITLS_BSL_SAL_THREAD
SKIP_TEST();
#else
BSL_SAL_ThreadLockHandle lock = NULL;
ASSERT_TRUE(BSL_SAL_ThreadLockNew(&lock) == BSL_SUCCESS);
BSL_SAL_ThreadId thread = NULL;
int32_t ret = BSL_SAL_ThreadCreate(&thread, NULL, NULL);
ASSERT_TRUE(ret == BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_ThreadCreate(NULL, TEST_Read, NULL);
ASSERT_TRUE(ret == BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_ThreadCreate(&thread, TEST_Read, lock);
ASSERT_TRUE(ret == BSL_SUCCESS);
BSL_SAL_ThreadClose(thread);
BSL_SAL_ThreadClose(NULL);
BSL_SAL_ThreadLockFree(lock);
EXIT:
return;
#endif
}
/* END_CASE */
static void TestRunOnce(void)
{
return;
}
/**
* @test SDV_BSL_SAL_THREAD_API_TC001
* @title Creating and Disabling Condition Variable Test
* @precon nan
* @brief
* 1. Call BSL_SAL_ThreadRunOnce to transfer abnormal parameters. Expected result 1 is obtained.
* 2. Call BSL_SAL_ThreadRunOnce to transfer normal parameters. Expected result 2 is obtained.
* @expect
* 1. BSL_SAL_ERR_BAD_PARAM
* 2. BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_THREAD_API_TC001(void)
{
uint32_t isErrInit = 0;
ASSERT_EQ(BSL_SAL_ThreadRunOnce(NULL, TestRunOnce), BSL_SAL_ERR_BAD_PARAM);
ASSERT_EQ(BSL_SAL_ThreadRunOnce(&isErrInit, NULL), BSL_SAL_ERR_BAD_PARAM);
ASSERT_EQ(BSL_SAL_ThreadRunOnce(&isErrInit, TestRunOnce), BSL_SUCCESS);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_CONDVAR_CREATE_FUNC_TC001
* @title Creating and Disabling Condition Variable Test
* @precon nan
* @brief
* 1. Call BSL_SAL_CreateCondVar to transfer abnormal parameters. Expected result 1 is obtained.
* 2. Call BSL_SAL_CreateCondVar to transfer normal parameters. Expected result 2 is obtained.
* 3. Call BSL_SAL_CondSignal to transfer abnormal parameters. Expected result 3 is obtained.
* 4. Call BSL_SAL_CondSignal to transfer normal parameters. Expected result 4 is obtained.
* 5. Call BSL_SAL_DeleteCondVar to transfer abnormal parameters. Expected result 5 is obtained.
* 6. Call BSL_SAL_DeleteCondVar to transfer normal parameters. Expected result 6 is obtained.
* 7. Call BSL_SAL_DeleteCondVar to delete the deleted condVar. Expected result 7 is obtained.
* @expect
* 1. BSL_SAL_ERR_BAD_PARAM
* 2. BSL_SUCCESS
* 3. BSL_SAL_ERR_BAD_PARAM
* 4. BSL_SUCCESS
* 5. BSL_SAL_ERR_BAD_PARAM
* 6. BSL_SUCCESS
* 7. BSL_SAL_ERR_UNKNOWN
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_CONDVAR_CREATE_FUNC_TC001(void)
{
#ifndef HITLS_BSL_SAL_THREAD
SKIP_TEST();
#else
BSL_SAL_CondVar condVar = NULL;
int32_t ret = BSL_SAL_CreateCondVar(NULL);
ASSERT_TRUE(ret == BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_CreateCondVar(&condVar);
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_SAL_CondSignal(NULL);
ASSERT_TRUE(ret == BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_CondSignal(condVar);
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_SAL_DeleteCondVar(NULL);
ASSERT_TRUE(ret == BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_DeleteCondVar(condVar);
ASSERT_TRUE(ret == BSL_SUCCESS);
EXIT:
return;
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_CONDVAR_WAIT_API_TC001
* @title Creating and Disabling Condition Variable Test
* @precon nan
* @brief
* 1. Call BSL_SAL_CreateCondVar to create a condition variable. Expected result 1 is obtained.
* 2. Unregistered thread-related callback and create a thread lock. Expected result 2 is obtained.
* 3. Call BSL_SAL_CondTimedwaitMs to transfer abnormal parameters. Expected result 3 is obtained.
* 4. Call BSL_SAL_CondTimedwaitMs to transfer normal parameters. Expected result 4 is obtained.
* 5. Release the lock. Expected result 5 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2. BSL_SUCCESS
* 3. BSL_SAL_ERR_BAD_PARAM
* 4. BSL_SUCCESS
* 5. Lock released successfully.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_CONDVAR_WAIT_API_TC001(void)
{
#ifndef HITLS_BSL_SAL_THREAD
SKIP_TEST();
#else
BSL_SAL_ThreadLockHandle lock = NULL;
ASSERT_TRUE(BSL_SAL_ThreadLockNew(&lock) == BSL_SUCCESS);
BSL_SAL_CondVar condVar = NULL;
int32_t ret = BSL_SAL_CreateCondVar(&condVar);
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_SAL_CondTimedwaitMs(NULL, condVar, 10);
ASSERT_TRUE(ret == BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_CondTimedwaitMs(lock, condVar, 1);
ASSERT_TRUE(ret == BSL_SAL_ERR_UNKNOWN);
ret = BSL_SAL_DeleteCondVar(condVar);
ASSERT_TRUE(ret == BSL_SUCCESS);
BSL_SAL_ThreadLockFree(lock);
EXIT:
return;
#endif
}
/* END_CASE */
#ifdef HITLS_BSL_SAL_THREAD
static BSL_SAL_CondVar g_condVar = NULL;
static pthread_mutex_t g_lock;
static void *ThreadTest(void *arg)
{
(void)arg;
int32_t ret1 = BSL_SAL_CondTimedwaitMs(&g_lock, g_condVar, 10000000);
ASSERT_TRUE(ret1 == BSL_SUCCESS);
EXIT:
return NULL;
}
#endif
/**
* @test SDV_BSL_SAL_CONDVAR_WAIT_FUNC_TC001
* @title Creating and Disabling Condition Variable Test
* @precon nan
* @brief
* 1. Call BSL_SAL_CreateCondVar to create a condition variable. Expected result 1 is obtained.
* 2. Call BSL_SAL_ThreadCreate to create the timedwait thread. Expected result 2 is obtained.
* 3. Call BSL_SAL_CondSignal to transfer normal parameters. Expected result 3 is obtained.
* 4. Call BSL_SAL_DeleteCondVar to transfer normal parameters. Expected result 4 is obtained.
* 5. Release the lock. Expected result 5 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2. BSL_SUCCESS
* 3. BSL_SUCCESS
* 4. BSL_SUCCESS
* 5. Lock released successfully.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_CONDVAR_WAIT_FUNC_TC001(void)
{
#ifndef HITLS_BSL_SAL_THREAD
SKIP_TEST();
#else
int32_t ret = BSL_SAL_CreateCondVar(&g_condVar);
ASSERT_TRUE(ret == BSL_SUCCESS);
pthread_mutex_init(&g_lock, NULL);
BSL_SAL_ThreadId thread = NULL;
ret = BSL_SAL_ThreadCreate(&thread, ThreadTest, NULL);
ASSERT_TRUE(ret == BSL_SUCCESS);
sleep(1); // Wait one seconds to send the signal
pthread_mutex_lock(&g_lock);
ret = BSL_SAL_CondSignal(g_condVar);
ASSERT_TRUE(ret == BSL_SUCCESS);
pthread_mutex_unlock(&g_lock);
BSL_SAL_ThreadClose(thread);
ret = BSL_SAL_DeleteCondVar(g_condVar);
ASSERT_TRUE(ret == BSL_SUCCESS);
pthread_mutex_destroy(&g_lock);
EXIT:
return;
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_STR_API_TC001
* @title Test on the function of inputting abnormal parameters for character string processing of the BSL module
* @precon nan
* @brief
* 1. Call BSL_SAL_StrcaseCmp to transfer abnormal parameters. Expected result 1 is obtained.
* 2. Call BSL_SAL_Memchr to transfer abnormal parameters. Expected result 2 is obtained.
* 3. Call BSL_SAL_Atoi to transfer abnormal parameters. Expected result 3 is obtained.
* 4. Call BSL_SAL_Strnlen to transfer abnormal parameters. Expected result 4 is obtained.
* @expect
* 1. BSL_NULL_INPUT
* 2. NULL
* 3. 0
* 4. 0
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_STR_API_TC001(void)
{
#ifndef HITLS_BSL_SAL_STR
SKIP_TEST();
#else
char *str1 = "aaastr1";
char *str2 = "aaastr2";
ASSERT_TRUE(BSL_SAL_StrcaseCmp(str1, NULL) == BSL_NULL_INPUT);
ASSERT_TRUE(BSL_SAL_StrcaseCmp(NULL, str2) == BSL_NULL_INPUT);
ASSERT_TRUE(BSL_SAL_Memchr(NULL, 's', 10) == NULL);
ASSERT_TRUE(BSL_SAL_Atoi(NULL) == 0);
ASSERT_TRUE(BSL_SAL_Strnlen(NULL, 0) == 0);
EXIT:
return;
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_STR_FUNC_TC001
* @title Character string processing function of the BSL module
* @precon nan
* @brief
* 1. Call BSL_SAL_StrcaseCmp to transfer normal parameters. Expected result 1 is obtained.
* 2. Call BSL_SAL_Memchr to transfer normal parameters. Expected result 2 is obtained.
* 3. Call BSL_SAL_Atoi to transfer normal parameters. Expected result 3 is obtained.
* 4. Call BSL_SAL_Strnlen to transfer normal parameters. Expected result 4 is obtained.
* @expect
* 1. String comparison succeeded.
* 2. Searching for the corresponding character succeeded.
* 3. Succeeded in converting a character string to a number.
* 4. Obtaining the length of the given string succeeded.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_STR_FUNC_TC001(void)
{
#ifndef HITLS_BSL_SAL_STR
SKIP_TEST();
#else
char *str1 = "aaastr1";
char *str2 = "aaastr2";
char *str3 = " aaastr3";
ASSERT_TRUE(BSL_SAL_StrcaseCmp(str1, str1) == 0);
ASSERT_TRUE(BSL_SAL_StrcaseCmp(str1, str2) == -1);
ASSERT_TRUE(BSL_SAL_StrcaseCmp(str2, str1) == 1);
ASSERT_TRUE(BSL_SAL_Memchr(str1, 's', strlen(str1)) != NULL);
ASSERT_TRUE(BSL_SAL_Memchr(str1, '1', 5) == NULL);
ASSERT_TRUE(BSL_SAL_Memchr(str1, '1', strlen(str1)) != NULL);
ASSERT_TRUE(BSL_SAL_Memchr(str1, 'b', strlen(str1)) == NULL);
ASSERT_TRUE(BSL_SAL_Memchr(str3, ' ', strlen(str3)) != NULL);
ASSERT_TRUE(BSL_SAL_Atoi("-100") == -100);
ASSERT_TRUE(BSL_SAL_Atoi("123") == 123);
ASSERT_TRUE(BSL_SAL_Atoi("123.456") == 123);
ASSERT_TRUE(BSL_SAL_Atoi(" 123 ") == 123);
ASSERT_TRUE(BSL_SAL_Atoi("000123") == 123);
ASSERT_TRUE(BSL_SAL_Atoi(" 1 23") == 1);
ASSERT_TRUE(BSL_SAL_Atoi("\n1 23") == 1);
ASSERT_TRUE(BSL_SAL_Atoi("1\n23") == 1);
ASSERT_TRUE(BSL_SAL_Atoi("0\n23") == 0);
ASSERT_TRUE(BSL_SAL_Strnlen(str1, strlen(str1)) == 7);
ASSERT_TRUE(BSL_SAL_Strnlen(str1, 100) == 7);
ASSERT_TRUE(BSL_SAL_Strnlen(str1, 3) == 3);
EXIT:
return;
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_THREAD_DEFAULT_FUNC_TC001
* @title Default Thread Related Functions
* @precon nan
* @brief
* 1. Unregistered thread-related callback and create a thread lock. Expected result 1 is obtained.
* 2. Create two read threads and two write threads, read and write concurrent threads,
* and obtain IDs from the threads. Expected result 2 is obtained.
* 3. Obtain the process ID and compare it with the subthread ID. Expected result 3 is obtained.
* 4. Obtain the subprocess ID and compare it with the current process ID. Expected result 4 is obtained.
* 5. Release the lock. Expected result 5 is obtained.
* @expect
* 1. Thread lock created successfully.
* 2. The read thread and write thread are successfully created.
* 3. The process ID and subthread ID are different.
* 4. The current subprocess ID is the same as the current process ID.
* 5. Lock released successfully.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_THREAD_DEFAULT_FUNC_TC001(void)
{
#ifndef HITLS_BSL_SAL_THREAD
SKIP_TEST();
#else
g_threadDefaultWrite001 = 0;
g_threadDefaultRead001 = 0;
g_threadDefaultId001 = 0;
// 1
BSL_SAL_ThreadLockHandle lock = NULL;
ASSERT_TRUE(BSL_SAL_ThreadLockNew(&lock) == BSL_SUCCESS);
// 2
BSL_SAL_ThreadId pid[TEST_WRITE_PID_CNT];
BSL_SAL_ThreadId pid2[TEST_READ_PID_CNT];
size_t i = 0;
size_t m = 0;
for (i = 0u; i < TEST_WRITE_PID_CNT; i++) {
ASSERT_TRUE(BSL_SAL_ThreadCreate(&pid[i], TEST_Write, (void *)lock) == BSL_SUCCESS);
}
for (m = 0u; m < TEST_READ_PID_CNT; m++) {
ASSERT_TRUE(BSL_SAL_ThreadCreate(&pid2[m], TEST_Read, (void *)lock) == BSL_SUCCESS);
}
for (size_t j = 0; j < i; j++) {
BSL_SAL_ThreadClose(pid[j]);
}
for (size_t n = 0; n < m; n++) {
BSL_SAL_ThreadClose(pid2[n]);
}
ASSERT_EQ(g_threadDefaultWrite001, TEST_READ_PID_CNT * TEST_THREAD_DEFAULT_TC001_WRITE_CNT);
// Concurrent reads. The read result is uncertain and does not determine whether to perform the read operation.
// 3
uint64_t mainId = BSL_SAL_ThreadGetId();
ASSERT_TRUE(mainId != g_threadDefaultId001);
// 4
uint64_t childId = 0;
pid_t pidFork = fork();
if (pidFork == 0) {
// The child process
childId = BSL_SAL_ThreadGetId();
} else {
// The parent process
goto EXIT;
}
// The default implementation uses pthread_self. Therefore, the IDs of the parent and child processes are the same.
ASSERT_EQ(childId, mainId);
EXIT:
// 5
BSL_SAL_ThreadLockFree(lock);
g_threadDefaultWrite001 = 0;
g_threadDefaultRead001 = 0;
g_threadDefaultId001 = 0;
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_CALLBACK_CTRL_FUNC_TC001
* @title test BSL_SAL_CallBack_Ctrl functions
* @precon nan
* @brief
* 1.Call BSL_SAL_CallBack_Ctrl registering file Callback Function, Expected result 1 is obtained.
* 2.Call BSL_SAL_CallBack_Ctrl registering time Callback Function, Expected result 1 is obtained.
* 3.Call BSL_SAL_CallBack_Ctrl registering net Callback Function, Expected result 1 is obtained.
* 4.Call BSL_SAL_CallBack_Ctrl registering invalid Callback Function, Expected result 2 is obtained.
* 5.Call BSL_SAL_SockGetLastSocketError obtaining the last socket error, Expected result 3 is obtained.
* @expect
* 1. BSL_SUCCESS
* 2. BSL_SAL_ERR_NET_IOCTL
* 3. Succeeded in obtaining the last socket error.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_CALLBACK_CTRL_FUNC_TC001(void)
{
#if defined(HITLS_BSL_SAL_FILE) || defined(HITLS_BSL_SAL_TIME) || defined(HITLS_BSL_SAL_NET)
#ifdef HITLS_BSL_SAL_FILE
ASSERT_EQ(BSL_SAL_CallBack_Ctrl(BSL_SAL_FILE_OPEN_CB_FUNC, NULL), BSL_SUCCESS);
#endif
#ifdef HITLS_BSL_SAL_TIME
ASSERT_EQ(BSL_SAL_CallBack_Ctrl(BSL_SAL_TIME_GET_UTC_TIME_CB_FUNC, NULL), BSL_SUCCESS);
#endif
#ifdef HITLS_BSL_SAL_NET
ASSERT_EQ(BSL_SAL_CallBack_Ctrl(BSL_SAL_NET_WRITE_CB_FUNC, NULL), BSL_SUCCESS);
ASSERT_EQ(BSL_SAL_Ioctlsocket(0, 0, NULL), BSL_SAL_ERR_NET_IOCTL);
#endif
EXIT:
return;
#endif
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/bsl/sal/test_suite_sdv_sal.c
|
C
|
unknown
| 26,808
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <unistd.h>
#include <pthread.h>
#include "bsl_sal.h"
#include "bsl_errno.h"
#include "sal_atomic.h"
#define TEST_THREAD_ATOMICADD_CNT 1000000
#define TEST_ATOMIC_ADD_PID_CNT 3
#define TEST_ATOMIC_SUB_PID_CNT 3
int g_threadStartNum = 0;
static BSL_SAL_ThreadLockHandle g_lock = NULL;
static void *TestAtomicAdd(void *arg)
{
(void)arg;
int ref = 0;
int ret = 0;
for (int i = 0; i < TEST_THREAD_ATOMICADD_CNT; i++) {
ret = BSL_SAL_AtomicAdd(&g_threadStartNum, 1, &ref, g_lock);
if (ret != BSL_SUCCESS) {
return NULL;
}
}
return NULL;
}
static void *TestAtomicSub(void *arg)
{
(void)arg;
int ref = 0;
int ret = 0;
for (int i = 0; i < TEST_THREAD_ATOMICADD_CNT; i++) {
ret = BSL_SAL_AtomicAdd(&g_threadStartNum, -1, &ref, g_lock);
if (ret != BSL_SUCCESS) {
return NULL;
}
}
return NULL;
}
/* END_HEADER */
/**
* @test SDV_BSL_SAL_ATOMIC_ADD_TC001
* @title atomic add test.
* @precon nan
* @brief
* 1. Create thread lock. Expected result 1 is obtained.
* 2. Create 3 threads to perform addition and one thread to perform subtraction. Expected result 2 is obtained.
* 3. Check whether the value after execution is consistent with the expected value. Expected result 3 is obtained.
* 4. Create 2 threads to perform subtraction. Expected result 4 is obtained.
* @expect
* 1. create success
* 2. create success
* 3. The value at the end of the thread is the same as expected.
* 4. The value at the end of the thread is the same as expected.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_ATOMIC_ADD_TC001(void)
{
ASSERT_TRUE(BSL_SAL_ThreadLockNew(&g_lock) == BSL_SUCCESS);
pthread_t pid[TEST_ATOMIC_ADD_PID_CNT];
pthread_t pid2[TEST_ATOMIC_SUB_PID_CNT];
size_t i;
for (i = 0u; i < TEST_ATOMIC_ADD_PID_CNT; i++) {
pthread_create(&pid[i], NULL, TestAtomicAdd, NULL);
}
pthread_create(&pid2[0], NULL, TestAtomicSub, NULL);
for (i = 0u; i < TEST_ATOMIC_ADD_PID_CNT; i++) {
pthread_join(pid[i], NULL);
}
pthread_join(pid2[0], NULL);
ASSERT_EQ(g_threadStartNum, (TEST_ATOMIC_ADD_PID_CNT - 1) * TEST_THREAD_ATOMICADD_CNT);
for (i = 1; i < TEST_ATOMIC_SUB_PID_CNT; i++) {
pthread_create(&pid2[i], NULL, TestAtomicSub, NULL);
}
for (i = 1; i < TEST_ATOMIC_SUB_PID_CNT; i++) {
pthread_join(pid2[i], NULL);
}
ASSERT_EQ(g_threadStartNum, 0);
EXIT:
g_threadStartNum = 0;
BSL_SAL_ThreadLockFree(g_lock);
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/bsl/sal/test_suite_sdv_sal_atomic.c
|
C
|
unknown
| 3,144
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_errno.h"
#include "sal_dlimpl.h"
/* END_HEADER */
/**
* @test SDV_BSL_SAL_DL_FUNC_TC001
* @title BSL SAL Provider functionality test
* @precon None
* @brief
* 1. Call BSL_SAL_LoadLib with valid inputs. Expected result 1 is obtained.
* 2. Call BSL_SAL_LoadLib with NULL filename. Expected result 2 is obtained.
* 3. Call BSL_SAL_LoadLib with NULL handle pointer. Expected result 3 is obtained.
* 4. Call BSL_SAL_LoadLib with non-existent library. Expected result 4 is obtained.
* 5. Call BSL_SAL_GetFuncAddress with valid inputs. Expected result 5 is obtained.
* 6. Call BSL_SAL_GetFuncAddress with provider lacking init function. Expected result 6 is obtained.
* 7. Call BSL_SAL_GetFuncAddress with NULL handle. Expected result 7 is obtained.
* 8. Call BSL_SAL_GetFuncAddress with NULL function pointer. Expected result 8 is obtained.
* 9. Call BSL_SAL_UnLoadLib with valid inputs. Expected result 9 is obtained.
* 10. Call BSL_SAL_UnLoadLib with NULL handle. Expected result 10 is obtained.
* @expect
* 1. BSL_SUCCESS, handle is not NULL
* 2. BSL_SAL_ERR_BAD_PARAM
* 3. BSL_SAL_ERR_BAD_PARAM
* 4. BSL_SAL_ERR_DL_NOT_FOUND
* 5. BSL_SUCCESS, function pointer is not NULL
* 6. BSL_SAL_ERR_DL_NON_FUNCTION
* 7. BSL_SAL_ERR_BAD_PARAM
* 8. BSL_SAL_ERR_BAD_PARAM
* 9. BSL_SUCCESS
* 10. BSL_SAL_ERR_BAD_PARAM
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_DL_FUNC_TC001(char *test1, char *test2, char *testNoInit, char *funcName)
{
void *handle1 = NULL;
void *handle2 = NULL;
void *handleNoInit = NULL;
void *func = NULL;
void *nonExistentLib = NULL;
int32_t ret;
// Test BSL_SAL_LoadLib with valid input
ret = BSL_SAL_LoadLib(test1, &handle1);
ASSERT_EQ(ret, BSL_SUCCESS);
ASSERT_TRUE(handle1 != NULL);
ret = BSL_SAL_LoadLib(test2, &handle2);
ASSERT_EQ(ret, BSL_SUCCESS);
ASSERT_TRUE(handle2 != NULL);
// Test BSL_SAL_LoadLib with invalid input
ret = BSL_SAL_LoadLib(NULL, &handle1);
ASSERT_EQ(ret, BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_LoadLib(test1, NULL);
ASSERT_EQ(ret, BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_LoadLib("nonExistentLib", &nonExistentLib);
ASSERT_EQ(ret, BSL_SAL_ERR_DL_NOT_FOUND);
// Test BSL_SAL_GetFuncAddress with valid input
ret = BSL_SAL_GetFuncAddress(handle1, funcName, &func);
ASSERT_EQ(ret, BSL_SUCCESS);
ASSERT_TRUE(func != NULL);
// Test BSL_SAL_GetFuncAddress with provider lacking init function
ret = BSL_SAL_LoadLib(testNoInit, &handleNoInit);
ASSERT_EQ(ret, BSL_SUCCESS);
ret = BSL_SAL_GetFuncAddress(handleNoInit, funcName, &func);
ASSERT_EQ(ret, BSL_SAL_ERR_DL_NON_FUNCTION);
// Test BSL_SAL_GetFuncAddress with invalid input
ret = BSL_SAL_GetFuncAddress(NULL, funcName, &func);
ASSERT_EQ(ret, BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_GetFuncAddress(handle1, funcName, NULL);
ASSERT_EQ(ret, BSL_SAL_ERR_BAD_PARAM);
// Test BSL_SAL_UnLoadLib with valid input
ret = BSL_SAL_UnLoadLib(handle1);
ASSERT_EQ(ret, BSL_SUCCESS);
handle1 = NULL;
ret = BSL_SAL_UnLoadLib(handle2);
ASSERT_EQ(ret, BSL_SUCCESS);
handle2 = NULL;
// Test BSL_SAL_UnLoadLib with invalid input
ret = BSL_SAL_UnLoadLib(NULL);
ASSERT_EQ(ret, BSL_SAL_ERR_BAD_PARAM);
EXIT:
if (handle1 != NULL) {
BSL_SAL_UnLoadLib(handle1);
}
if (handle2 != NULL) {
BSL_SAL_UnLoadLib(handle2);
}
if (handleNoInit != NULL) {
BSL_SAL_UnLoadLib(handleNoInit);
}
return;
}
/* END_CASE */
#define INVALID_COMMEND 5
/**
* @test SDV_BSL_SAL_CONVERTER_NAME_FUNC_TC001
* @title BSL SAL ConverterName functionality test
* @precon None
* @brief
* 1. Call BSL_SAL_LibNameFormat with valid inputs. Expected result 1 is obtained.
* 2. Call BSL_SAL_LibNameFormat with insufficient buffer size. Expected result 2 is obtained.
* 3. Call BSL_SAL_LibNameFormat with NULL filename. Expected result 3 is obtained.
* 4. Call BSL_SAL_LibNameFormat with NULL output name pointer. Expected result 4 is obtained.
* 5. Call BSL_SAL_LibNameFormat with invalid command. Expected result 5 is obtained.
* @expect
* 1. BSL_SUCCESS, converted name matches aimResult
* 2. BSL_SAL_ERR_DL_PATH_EXCEED
* 3. BSL_SAL_ERR_BAD_PARAM
* 4. BSL_SAL_ERR_BAD_PARAM
* 5. BSL_SAL_ERR_BAD_PARAM
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_CONVERTER_NAME_TC001(char *name, int cmd, char *aimResult)
{
char *convertedName = NULL;
int32_t ret;
TestMemInit();
ret = BSL_SAL_LibNameFormat(cmd, name, &convertedName);
ASSERT_EQ(ret, BSL_SUCCESS);
ASSERT_TRUE(convertedName != NULL);
ASSERT_TRUE(strcmp(convertedName, aimResult) == 0);
BSL_SAL_FREE(convertedName);
// Test with NULL inputs
ret = BSL_SAL_LibNameFormat(cmd, NULL, &convertedName);
ASSERT_EQ(ret, BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_LibNameFormat(cmd, name, NULL);
ASSERT_EQ(ret, BSL_SAL_ERR_BAD_PARAM);
// Test with invalid command
ret = BSL_SAL_LibNameFormat(INVALID_COMMEND, name, &convertedName);
ASSERT_EQ(ret, BSL_SAL_ERR_BAD_PARAM);
EXIT:
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/bsl/sal/test_suite_sdv_sal_dl.c
|
C
|
unknown
| 5,894
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <string.h>
#include <stdio.h>
#include "bsl_errno.h"
#include "bsl_sal.h"
#define MAX_PATH_LEN 4096
#define MAX_FILE_LEN 4096
void CreateFile(const char *fileName)
{
FILE *fp = fopen(fileName, "rb");
if (fp == NULL) {
fp = fopen(fileName, "wb");
}
fclose(fp);
}
void RemoveFile(const char *fileName)
{
remove(fileName);
}
/* END_HEADER */
static void *TestFileOpenFunc(void *args)
{
bsl_sal_file_handle stream = NULL;
char mode[] = "rb";
char path[MAX_PATH_LEN];
(void)args;
(void)strcpy(path, "");
int ret;
// 1.If the setting path is empty, the system fails to open the path, and BSL_NULL_INPUT is returned.
ret = BSL_SAL_FileOpen(&stream, path, mode);
ASSERT_EQ(ret, BSL_NULL_INPUT);
// 2.If the build does not exist, the file path fails to be opened and BSL_SAL_ERR_FILE_Open is returned.
(void)strcpy(path, "ret/sd/s.s");
ret = BSL_SAL_FileOpen(&stream, path, mode);
ASSERT_EQ(ret, BSL_SAL_ERR_FILE_OPEN);
// 3.Create a new file and open it. If the operation is successful, BSL_SUCCESS is returned.
(void)strcpy(path, "test.txt");
CreateFile(path);
ret = BSL_SAL_FileOpen(&stream, path, mode);
ASSERT_EQ(ret, BSL_SUCCESS);
BSL_SAL_FileClose(stream);
EXIT:
RemoveFile(path);
return NULL;
}
/**
* @test SDV_BSL_SAL_FILE_OPEN_FUNC_TC001
* @title Test the file opening operation.
* @precon nan
* @brief
* 1. Open the file and leave the path empty. Expected result 1 is obtained.
* 2. Open the file but the file does not exist. Expected result 2 is obtained.
* 3. Create a file and then open the file. The operation is successful. Expected result 3 is obtained.
* @expect
* 1. BSL_NULL_INPUT
* 2. BSL_SAL_ERR_FILE_OPEN
* 3. BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_FILE_OPEN_FUNC_TC001(void)
{
TestFileOpenFunc(NULL);
}
/* END_CASE */
static void *TestFileLengthFunc(void *args)
{
bsl_sal_file_handle stream = NULL;
char path[MAX_PATH_LEN];
char writeBuffer[MAX_FILE_LEN] = "we come from same country!";
char readBuffer[MAX_FILE_LEN];
int ret;
size_t len = 0;
(void)args;
(void)strcpy(path, "test.txt");
CreateFile(path);
ret = BSL_SAL_FileOpen(&stream, path, "wb");
ASSERT_EQ(ret, BSL_SUCCESS);
ret = BSL_SAL_FileWrite(stream, writeBuffer, 1, 10);
ASSERT_EQ(ret, BSL_SUCCESS);
BSL_SAL_FileClose(stream);
ret = BSL_SAL_FileOpen(&stream, path, "rb");
ASSERT_EQ(ret, BSL_SUCCESS);
ret = BSL_SAL_FileRead(stream, readBuffer, 1, 10, &len); // Reads the file content to the buffer.
ASSERT_TRUE(len > 0); // The read length is greater than 0.
ASSERT_EQ(ret, BSL_SUCCESS);
ret = BSL_SAL_FileLength(path, &len);
ASSERT_TRUE(len > 0); // The length of the existing file is greater than 0.
ASSERT_EQ(ret, BSL_SUCCESS);
EXIT:
BSL_SAL_FileClose(stream);
RemoveFile(path);
return NULL;
}
/**
* @test SDV_BSL_SAL_FILE_LENGTH_FUNC_TC001
* @title Write content to a file and obtain the file length.
* @precon nan
* @brief
* 1. Create a file. Expected result 1 is obtained.
* 2. Write data to a file. After the write operation is performed,
* perform the close operation to write the buffer data to the file. Expected result 2 is obtained.
* 3. Open the file again and read the file content. Because the file contains information,
* the read length is greater than 0. Expected result 3 is obtained.
* 4. Obtain the file length, which is greater than 0. Expected result 4 is obtained.
* @expect
* 1. File created successfully.
* 2. BSL_SUCCESS
* 3. BSL_SUCCESS
* 4. BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_FILE_LENGTH_FUNC_TC001(void)
{
TestFileLengthFunc(NULL);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/bsl/sal/test_suite_sdv_sal_file.c
|
C
|
unknown
| 4,378
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <stdbool.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/time.h>
#include "bsl_sal.h"
#include "bsl_errno.h"
#define READ_TIME_OUT_SEC 3 // 3s timeout
/* END_HEADER */
/**
* @test SDV_BSL_SAL_SOCKET_FUNC_TC001
* @title Socket-related function test
* @precon nan
* @brief
* 1. Call BSL_SAL_Socket to create a TCP socket. Expected result 1 is displayed.
* 2. Set the TCP timeout period. Expected result 2 is obtained.
* 3. Close tcp socket. Expected result 3 is obtained.
* 4. Call BSL_SAL_Socket to create a UDP socket. Expected result 4 is displayed.
* 5. Set the UDP timeout period. Expected result 5 is obtained.
* 6. Close UDP socket. Expected result 6 is obtained.
* @expect
* 1. Created successfully.
* 2. Setting successfully.
* 3. Closed successfully.
* 4. Created successfully.
* 5. Setting successfully.
* 6. Closed successfully.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_SOCKET_FUNC_TC001(void)
{
int32_t tcp = BSL_SAL_Socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
ASSERT_TRUE(tcp != -1);
struct timeval timeOut = { 0 };
timeOut.tv_sec = READ_TIME_OUT_SEC;
ASSERT_TRUE(BSL_SAL_SetSockopt(tcp, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeOut, sizeof(timeOut)) == 0);
ASSERT_TRUE(BSL_SAL_SockClose(tcp) == 0);
int32_t udp = BSL_SAL_Socket(AF_INET, SOCK_DGRAM, 0);
ASSERT_TRUE(udp != -1);
ASSERT_TRUE(BSL_SAL_SetSockopt(udp, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeOut, sizeof(timeOut)) == 0);
ASSERT_TRUE(BSL_SAL_SockClose(udp) == 0);
EXIT:
return;
}
/* END_CASE */
#ifdef HITLS_BSL_SAL_THREAD
static uint16_t GetPort()
{
uint16_t port = 8888;
char *userPort = getenv("FIXED_PORT");
if (userPort == NULL) {
const uint32_t basePort = 10000;
port = basePort + getpid();
}
return port;
}
static void *TestTcpClient(void *args)
{
(void)args;
struct sockaddr_in remoteAddr;
remoteAddr.sin_family = AF_INET;
remoteAddr.sin_port = htons(GetPort());
remoteAddr.sin_addr.s_addr = htonl(INADDR_ANY);
int32_t socketRemote = BSL_SAL_Socket(AF_INET, SOCK_STREAM, 0);
ASSERT_TRUE(socketRemote != -1);
while(true) {
int32_t ret = BSL_SAL_SockConnect(socketRemote, (BSL_SAL_SockAddr)&remoteAddr, sizeof(remoteAddr));
if (ret == 0) {
char *msg = "Hello,TCP!!";
ASSERT_TRUE(BSL_SAL_SockSend(socketRemote, msg, strlen(msg), 0) >= 0);
goto EXIT;
}
ASSERT_TRUE(BSL_SAL_SockGetLastSocketError() != 0);
}
EXIT:
BSL_SAL_SockClose(socketRemote);
return NULL;
}
static void *TestTcpServer(void *args)
{
(void)args;
uint8_t buff[32] = {0};
int serConn = -1;
struct sockaddr_in localAddr = {0};
struct sockaddr_in cliAddr = {0};
localAddr.sin_family = AF_INET;
localAddr.sin_port = htons(GetPort());
localAddr.sin_addr.s_addr = htonl(INADDR_ANY);
int32_t socketLocal = BSL_SAL_Socket(AF_INET, SOCK_STREAM, 0);
ASSERT_TRUE(socketLocal != -1);
ASSERT_TRUE(BSL_SAL_SockBind(socketLocal, (BSL_SAL_SockAddr)&localAddr, sizeof(localAddr)) == 0);
ASSERT_TRUE(BSL_SAL_SockListen(socketLocal, 5) == 0);
socklen_t len = sizeof(cliAddr);
serConn = accept(socketLocal, (struct sockaddr *)&cliAddr, &len);
ASSERT_TRUE(serConn != -1);
while(true) {
if (BSL_SAL_SockRecv(serConn, buff, 32, 0) > 0) {
goto EXIT;
}
ASSERT_TRUE(BSL_SAL_SockGetLastSocketError() != 0);
}
EXIT:
BSL_SAL_SockClose(socketLocal);
BSL_SAL_SockClose(serConn);
return NULL;
}
#endif
/**
* @test SDV_BSL_SAL_SOCKET_FUNC_TC002
* @title Socket-related function test
* @precon nan
* @brief
* 1. Creating a TCP Server. Expected result 1 is obtained.
* 2. Creating a TCP Client. Expected result 2 is obtained.
* @expect
* 1. Created successfully.
* 2. Created successfully.
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_SOCKET_FUNC_TC002(void)
{
#ifndef HITLS_BSL_SAL_THREAD
SKIP_TEST();
#else
BSL_SAL_ThreadId serverThread = NULL;
ASSERT_EQ(BSL_SAL_ThreadCreate(&serverThread, TestTcpServer, NULL), BSL_SUCCESS);
BSL_SAL_ThreadId clientThread = NULL;
ASSERT_EQ(BSL_SAL_ThreadCreate(&clientThread, TestTcpClient, NULL), BSL_SUCCESS);
EXIT:
BSL_SAL_ThreadClose(serverThread);
BSL_SAL_ThreadClose(clientThread);
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_SELECT_FUNC_TC001
* @title Socket-related function test
* @precon nan
* @brief
* 1. Open the /dev/urandom file only. Expected result 1 is obtained.
* 2. Call BSL_SAL_Select to check the number of open read-only descriptors.
Expected result 2 is obtained.
* @expect
* 1. Opened successfully.
* 2. Read-only descriptor open count is greater than 0
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_SELECT_FUNC_TC001(void)
{
const char *path = "/dev/urandom";
int fd = open(path, O_RDONLY);
ASSERT_TRUE(fd != -1);
fd_set fds;
FD_ZERO(&fds);
FD_SET(fd, &fds);
struct timeval tv;
tv.tv_sec = 2;
tv.tv_usec = 0;
ASSERT_TRUE(BSL_SAL_Select(fd + 1, &fds, NULL, NULL, &tv) > 0);
EXIT:
close(fd);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/bsl/sal/test_suite_sdv_sal_socket.c
|
C
|
unknown
| 5,950
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <unistd.h>
#include <sys/time.h>
#include <time.h>
#include <sys/times.h>
#include "bsl_sal.h"
#include "sal_time.h"
#include "bsl_errno.h"
static int64_t TestBslSysTimeFunc(void)
{
return (time_t)1;
}
static int64_t TestBslSysTimeFunc1(void)
{
return time(NULL);
}
static void TestBslSysTimeInit(BSL_TIME *dateTime)
{
dateTime->year = 1990;
dateTime->month = 6;
dateTime->day = 12;
dateTime->hour = 10;
dateTime->minute = 3;
dateTime->microSec = 1;
dateTime->millSec = 1;
}
static void TestBslSysTimeAndTmCompare(BSL_TIME *dateTime, struct tm *tempTime)
{
ASSERT_EQ(dateTime->year, tempTime->tm_year + 1900); /* 1900 is base year */
ASSERT_EQ(dateTime->month, tempTime->tm_mon + 1U);
ASSERT_EQ(dateTime->day, tempTime->tm_mday);
ASSERT_EQ(dateTime->hour, tempTime->tm_hour);
ASSERT_EQ(dateTime->minute, tempTime->tm_min);
ASSERT_EQ(dateTime->second, tempTime->tm_sec);
EXIT:
return;
}
/* END_HEADER */
/**
* @test SDV_BSL_TIME_FUNC_GET_DATETIME_TC001
* @title Function test of obtaining the date as a character string.
* @precon
* @brief 1.The input parameter dateTime, timeStr, or len is invalid (less than the storage length).
* 2.Invalid time.
* 3.The time is legal.
* @expect 1.Fail, return BSL_ERR
* 2.Fail, return BSL_ERR
* 3.Success, return BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_TIME_FUNC_GET_DATETIME_TC001(void)
{
BSL_TIME dateTime = {0};
char timeStr[26];
timeStr[0] = '\0';
dateTime.year = BSL_TIME_SYSTEM_EPOCH_YEAR;
dateTime.month = 1;
dateTime.day = 1;
dateTime.hour = 0;
dateTime.minute = 0;
dateTime.second = 0;
/* 1.The input parameter dateaTime or timeStr is invalid. */
ASSERT_EQ(BSL_DateToStrConvert(NULL, timeStr, 26), (uint32_t)BSL_INTERNAL_EXCEPTION);
ASSERT_EQ(BSL_DateToStrConvert(&dateTime, NULL, 26), (uint32_t)BSL_INTERNAL_EXCEPTION);
/* 2.Invalid time. */
dateTime.month = 13;
ASSERT_EQ(BSL_DateToStrConvert(&dateTime, timeStr, 26), (uint32_t)BSL_INTERNAL_EXCEPTION);
dateTime.month = 1;
/* 3.The time is legal. */
ASSERT_EQ(BSL_DateToStrConvert(&dateTime, timeStr, 26), (uint32_t)BSL_SUCCESS);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_TIME_FUNC_REGISTER_TC001
* @title Obtaining the current system time
* @precon
* @brief
* 1. Registering System Time Hooks, obtain the Unix time. Expected result 1 is obtained.
* 2. Unregistered system time hook, Obtain the Unix time. Expected result 2 is obtained.
* 3. Unregister System Time Hook, Obtain the Unix time. Expected result 3 is obtained.
* @expect
* 1. The operation is successful, 0 is returned.
* 2. The operation is successful, 0 is returned. The hook has not changed
* 3. The operation is successful, a non-zero value is returned.
*/
/* BEGIN_CASE */
void SDV_BSL_TIME_FUNC_REGISTER_TC001(void)
{
/* 1.Registering System Time Hooks */
BSL_SAL_SysTimeFuncReg(TestBslSysTimeFunc);
ASSERT_EQ(BSL_SAL_CurrentSysTimeGet(), 1);
/* 2.Unregistered system time hook */
BSL_SAL_SysTimeFuncReg(NULL);
ASSERT_EQ(BSL_SAL_CurrentSysTimeGet(), 1);
BSL_SysTimeFuncUnReg();
ASSERT_NE(BSL_SAL_CurrentSysTimeGet(), 1);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_TIME_CMP_TIME_API_TC001
* @title Time comparison function test
* @precon
* @brief
* 1. The existence time is invalid. Expected result 1 is obtained.
* 2. The two dates are consistent. Expected result 2 is obtained.
* 3. The first date is before the second date. Expected result 3 is obtained.
* 4. The first date is after the second. Expected result 3 is obtained.
* @expect
* 1. Fail, return BSL_TIME_CMP_ERROR
* 2. Success, return BSL_TIME_CMP_EQUAL
* 3. Success, return BSL_TIME_DATE_BEFORE
* 4. Success, return BSL_TIME_DATE_AFTER
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_TIME_CMP_TIME_API_TC001(void)
{
int64_t diffSec;
BSL_TIME dateA = {0};
BSL_TIME dateB = {0};
dateA.year = BSL_TIME_SYSTEM_EPOCH_YEAR;
dateA.month = 1;
dateA.day = 1;
dateB.year = BSL_TIME_SYSTEM_EPOCH_YEAR;
dateB.month = 1;
dateB.day = 1;
/* 1.The existence time is invalid */
ASSERT_EQ(BSL_SAL_DateTimeCompare(NULL, &dateB, &diffSec), BSL_TIME_CMP_ERROR);
/* 2.The two dates are consistent */
ASSERT_EQ(BSL_SAL_DateTimeCompare(&dateA, &dateB, &diffSec), BSL_TIME_CMP_EQUAL);
ASSERT_EQ(diffSec, 0);
/* 3.The first date is before the second date */
dateB.second = 1;
ASSERT_EQ(BSL_SAL_DateTimeCompare(&dateA, &dateB, &diffSec), BSL_TIME_DATE_BEFORE);
ASSERT_EQ(diffSec, -1);
dateB.second = 0;
/* 4.The first date is after the second */
dateA.second = 1;
ASSERT_EQ(BSL_SAL_DateTimeCompare(&dateA, &dateB, &diffSec), BSL_TIME_DATE_AFTER);
ASSERT_EQ(diffSec, 1);
dateA.second = 0;
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_TIME_CMP_TIME_API_TC002
* @title Time comparison function test
* @precon
* @brief
* 1. The existence time is invalid. Expected result 1 is obtained.
* 2. The two dates are consistent. Expected result 2 is obtained.
* 3. The first date is before the second date. Expected result 3 is obtained.
* 4. The first date is after the second. Expected result 3 is obtained.
* @expect
* 1. Fail, return BSL_TIME_CMP_ERROR
* 2. Success, return BSL_TIME_CMP_EQUAL
* 3. Success, return BSL_TIME_DATE_BEFORE
* 4. Success, return BSL_TIME_DATE_AFTER
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_TIME_CMP_TIME_API_TC002(void)
{
BSL_TIME dateA = {0};
BSL_TIME dateB = {0};
dateA.year = BSL_TIME_SYSTEM_EPOCH_YEAR;
dateA.month = 1;
dateA.day = 1;
dateA.millSec = 2;
dateA.microSec = 3;
dateB.year = BSL_TIME_SYSTEM_EPOCH_YEAR;
dateB.month = 1;
dateB.day = 1;
dateB.millSec = 2;
dateB.microSec = 3;
/* 1.The existence time is invalid. */
ASSERT_EQ(BSL_SAL_DateTimeCompareByUs(NULL, &dateB), BSL_TIME_CMP_ERROR);
/* 2.The two dates are consistent. */
ASSERT_EQ(BSL_SAL_DateTimeCompareByUs(&dateA, &dateB), BSL_TIME_CMP_EQUAL);
/* 3.The first date is before the second date. */
dateB.millSec = 1;
ASSERT_EQ(BSL_SAL_DateTimeCompareByUs(&dateA, &dateB), BSL_TIME_DATE_AFTER);
dateB.millSec = 2;
/* 4.The first date is after the second */
dateA.microSec = 1;
ASSERT_EQ(BSL_SAL_DateTimeCompareByUs(&dateA, &dateB), BSL_TIME_DATE_BEFORE);
dateA.microSec = 0;
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_TIME_SYSTIME_API_TC001
* @title Obtaining the System Time
* @precon
* @brief
* 1. Call BSL_SAL_SysTimeGet to transfer the NULL parameter. Expected result 1 is obtained.
* 2. Call BSL_SAL_SysTimeGet to transfer the normal parameter. Expected result 2 is obtained.
* @expect
* 1. Return BSL_SAL_ERR_BAD_PARAM.
* 2. The obtained time is the same as the expected value. Return BSL_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_BSL_TIME_SYSTIME_API_TC001(void)
{
BSL_TIME systime;
uint32_t ret;
/* The time obtaining interface is registered as time. */
BSL_SAL_SysTimeFuncReg(TestBslSysTimeFunc1);
ret = BSL_SAL_SysTimeGet(NULL);
ASSERT_EQ(ret, BSL_SAL_ERR_BAD_PARAM);
ret = BSL_SAL_SysTimeGet(&systime);
ASSERT_TRUE(ret == BSL_SUCCESS);
/* Get the current time. */
int64_t curtime = time(NULL);
int64_t timestamp = 0;
ret = BSL_SAL_DateToUtcTimeConvert(&systime, ×tamp);
ASSERT_LT(abs((int)(curtime - timestamp)), 5);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_TIME_CONVERT_TIME_FUNC_TC001
* @title UTC time conversion
* @precon
* @brief
* 1. Call BSL_SAL_DateToUtcTimeConvert to transfer the NULL parameter. Expected result 1 is obtained.
* 2. Call BSL_SAL_DateToUtcTimeConvert to transfer an exception parameter. Expected result 1 is obtained.
* 3. Call BSL_SAL_DateToUtcTimeConvert to transfer normal parameters. Expected result 2 is obtained.
* @expect
* 1. Fail, return BSL_ERR
* 2. Fail, return BSL_ERR
* 3. Success, return BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_TIME_CONVERT_TIME_FUNC_TC001(void)
{
int64_t utcTime;
BSL_TIME dateTime = {0};
/* 1.The input parameter dateTime or utcTime is empty. */
ASSERT_TRUE(BSL_SAL_DateToUtcTimeConvert(NULL, &utcTime) == BSL_INTERNAL_EXCEPTION);
ASSERT_TRUE(BSL_SAL_DateToUtcTimeConvert(&dateTime, NULL) == BSL_INTERNAL_EXCEPTION);
/* 2.Failed to convert the time. */
ASSERT_TRUE(BSL_SAL_DateToUtcTimeConvert(&dateTime, &utcTime) != BSL_SUCCESS);
/* 3.Time conversion succeeded. */
dateTime.year = BSL_TIME_SYSTEM_EPOCH_YEAR;
dateTime.month = 1;
dateTime.day = 1;
dateTime.hour = 0;
dateTime.minute = 0;
dateTime.second = 0;
ASSERT_TRUE(BSL_SAL_DateToUtcTimeConvert(&dateTime, &utcTime) == (uint32_t)BSL_SUCCESS);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_SAL_CONVERT_TIME_API_TC002
* @title Converting BslSysTime to BslUnixTime
* @precon
* @brief
* 1. The value of utcTime is 0. Expected result 1 is obtained.
* 2. The value of utcTime is a negative number. Expected result 2 is obtained.
* 3. The value of utcTime is INT32_MAX - 1. Expected result 3 is obtained.
* 4. The value of utcTime is INT32_MAX. Expected result 4 is obtained.
* 5. The value of utcTime is INT32_MAX + 1. Expected result 5 is obtained.
* 6. The value of utcTime is BSL_UTCTIME_MAX. Expected result 6 is obtained.
* @expect
* 1. Success, return BSL_SUCCESS
* 2. Success, return BSL_SUCCESS
* 3. Success, return BSL_SUCCESS
* 4. Success, return BSL_SUCCESS
* 5. Success, return BSL_SUCCESS
* 6. Success, return BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_SAL_CONVERT_TIME_API_TC001(void)
{
int64_t utcTime;
BSL_TIME dateTime = {0};
struct tm tempTime;
utcTime = 0;
ASSERT_TRUE(BSL_SAL_UtcTimeToDateConvert(utcTime, &dateTime) == BSL_SUCCESS);
ASSERT_TRUE(gmtime_r((const time_t *)&utcTime, &tempTime) != NULL);
TestBslSysTimeAndTmCompare(&dateTime, &tempTime);
utcTime = -1;
ASSERT_TRUE(BSL_SAL_UtcTimeToDateConvert(utcTime, &dateTime) == BSL_SUCCESS);
ASSERT_TRUE(gmtime_r((const time_t *)&utcTime, &tempTime) != NULL);
TestBslSysTimeAndTmCompare(&dateTime, &tempTime);
utcTime = INT32_MAX;
ASSERT_TRUE(BSL_SAL_UtcTimeToDateConvert(utcTime, &dateTime) == BSL_SUCCESS);
ASSERT_TRUE(gmtime_r((const time_t *)&utcTime, &tempTime) != NULL);
TestBslSysTimeAndTmCompare(&dateTime, &tempTime);
utcTime = INT32_MAX - 1;
ASSERT_TRUE(BSL_SAL_UtcTimeToDateConvert(utcTime, &dateTime) == BSL_SUCCESS);
ASSERT_TRUE(gmtime_r((const time_t *)&utcTime, &tempTime) != NULL);
TestBslSysTimeAndTmCompare(&dateTime, &tempTime);
utcTime = (int64_t)INT32_MAX + 1;
ASSERT_TRUE(BSL_SAL_UtcTimeToDateConvert(utcTime, &dateTime) == BSL_SUCCESS);
ASSERT_TRUE(gmtime_r((const time_t *)&utcTime, &tempTime) != NULL);
TestBslSysTimeAndTmCompare(&dateTime, &tempTime);
utcTime = BSL_UTCTIME_MAX;
ASSERT_TRUE(BSL_SAL_UtcTimeToDateConvert(utcTime, &dateTime) == BSL_SUCCESS);
ASSERT_TRUE(gmtime_r((const time_t *)&utcTime, &tempTime) != NULL);
TestBslSysTimeAndTmCompare(&dateTime, &tempTime);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_TIME_FUNC_DATETIME_CHECK_TC001
* @title BSL_DateTimeCheck the test of the year
* @precon nan
* @brief
* 1.Year illegal (<1970). Expected result 1 is obtained.
* 2.Year legal (1990). Expected result 2 is obtained.
* @expect
* 1.Return false
* 2.Return true
*/
/* BEGIN_CASE */
void SDV_BSL_TIME_DATETIME_CHECK_FUNC_TC001(void)
{
bool ret;
BSL_TIME dateTime = {0};
TestBslSysTimeInit(&dateTime);
/* 1.Year illegal (<1970) */
dateTime.year = 1969;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 2.Year legal (=1970) */
dateTime.year = 1970;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_TIME_FUNC_DATETIME_CHECK_TC002
* @title BSL_DateTimeCheck the test of the month
* @precon nan
* @brief
* 1.Month illegal (== 0 or > 12). Expected result 1 is obtained.
* 2.Month legal (== 1 or == 12). Expected result 2 is obtained.
* @expect
* 1.Return false
* 2.Return true
*/
/* BEGIN_CASE */
void SDV_BSL_TIME_DATETIME_CHECK_FUNC_TC002(void)
{
bool ret;
BSL_TIME dateTime = {0};
TestBslSysTimeInit(&dateTime);
/* 1.Month illegal (== 0 or > 12) */
dateTime.month = 0;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
dateTime.month = 13;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 2.Month legal (== 1 or == 12) */
dateTime.month = 1;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
dateTime.month = 12;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_TIME_FUNC_DATETIME_CHECK_TC003
* @title BSL_DateTimeCheck the test of the day
* @precon
* @brief
* 1.Day illegal (== 0). Expected result 1 is obtained.
* 2.Day legal (== 1). Expected result 2 is obtained.
* 3.Day illegal (More than 28 days in February). Expected result 3 is obtained.
* 4.Day legal (February equals 28 days). Expected result 4 is obtained.
* 5.Day illegal (More than 31 days in January). Expected result 5 is obtained.
* 6.Day legal (January equals 31 days). Expected result 6 is obtained.
* 7.Day illegal (More than 30 in April). Expected result 7 is obtained.
* 8.Day legal (April equals 30 days). Expected result 8 is obtained.
* 9.Day illegal (Leap year February greater than 29 days). Expected result 9 is obtained.
* 10.Day legal (Leap year February equals 29 days). Expected result 10 is obtained.
* @expect
* 1.Return false
* 2.Return true
* 3.Return false
* 4.Return true
* 5.Return false
* 6.Return true
* 7.Return false
* 8.Return true
* 9.Return false
* 10.Return true
*/
/* BEGIN_CASE */
void SDV_BSL_TIME_DATETIME_CHECK_FUNC_TC003(void)
{
bool ret;
BSL_TIME dateTime = {0};
TestBslSysTimeInit(&dateTime);
/* 1.Day illegal (== 0) */
dateTime.day = 0;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 2.Day legal (== 1) */
dateTime.day = 1;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
/* 3.Day illegal (More than 28 days in February) */
dateTime.month = 2;
dateTime.day = 29;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 4.Day legal (February equals 28 days) */
dateTime.month = 2;
dateTime.day = 28;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
/* 5.Day illegal (More than 31 days in January) */
dateTime.month = 1;
dateTime.day = 32;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 6.Day legal (January equals 31 days) */
dateTime.month = 1;
dateTime.day = 31;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
/* 7.Day illegal (More than 30 days in April) */
dateTime.month = 4;
dateTime.day = 31;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 8.Day legal (April equals 30 days) */
dateTime.month = 4;
dateTime.day = 30;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
/* 9.Day illegal (Leap year February greater than 29) */
dateTime.year = 2020;
dateTime.month = 2;
dateTime.day = 30;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 10.Day legal (Leap year February equals 29) */
dateTime.year = 2020;
dateTime.month = 2;
dateTime.day = 29;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_TIME_FUNC_DATETIME_CHECK_TC004
* @title BSL_DateTimeCheck hour minute second test
* @precon nan
* @brief
* 1. hour is illegal ( > 23). Expected result 1 is obtained.
* 2. hour is legal ( == 23). Expected result 2 is obtained.
* 3. minute is illegal ( > 59). Expected result 3 is obtained.
* 4. minute is legal ( == 59). Expected result 4 is obtained.
* 5. second is illegal( > 59). Expected result 5 is obtained.
* 6. second is legal ( == 59). Expected result 6 is obtained.
* 7. millisecond is illegal ( > 999). Expected result 7 is obtained.
* 8. millisecond is legal ( == 999). Expected result 8 is obtained.
* 9. call BSL_DateToStrConvert to convert legal time. Expected result 9 is obtained.
* @expect
* 1. Return false
* 2. Return true
* 3. Return false
* 4. Return true
* 5. Return false
* 6. Return true
* 7. Return false
* 8. Return true
* 9. Return BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_TIME_DATETIME_CHECK_FUNC_TC004(void)
{
bool ret;
BSL_TIME dateTime = {0};
TestBslSysTimeInit(&dateTime);
/* 1.hour is illegal ( > 23) */
dateTime.hour = 24;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 2.hour is legal ( == 23) */
dateTime.hour = 23;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
/* 3.minute is illegal ( > 59) */
dateTime.minute = 60;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 4.minute is legal ( == 59) */
dateTime.minute = 59;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
/* 5.second is illegal ( > 59) */
dateTime.second = 60;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 6.second is legal ( == 59) */
dateTime.second = 59;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
/* 7.millisecond is illegal ( > 999) */
dateTime.millSec = 1000;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, false);
/* 8.millisecond is legal ( == 999) */
dateTime.millSec = 59;
ret = BSL_DateTimeCheck(&dateTime);
ASSERT_EQ(ret, true);
char buf[256] = {0};
ASSERT_EQ(BSL_DateToStrConvert(&dateTime, buf, 256), BSL_SUCCESS);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_TIME_FUNC_TICK_TC001
* @title Test of functions related to the number of ticks in the system
* @precon
* @brief
* 1. Call BSL_SAL_Tick to obtain the number of ticks that the system has experienced since startup.
* Expected result 1 is obtained.
* 2. Call BSL_SAL_TicksPerSec to obtain the number of system ticks per second. Expected result 2 is obtained.
* @expect
* 1. Succeeded in obtaining the number of ticks that have been experienced since the system is started.
* 2. Succeeded in obtaining the number of system ticks per second.
*/
/* BEGIN_CASE */
void SDV_BSL_TIME_FUNC_TICK_TC001(void)
{
long res = BSL_SAL_Tick();
ASSERT_TRUE(res != 0);
res = BSL_SAL_TicksPerSec();
ASSERT_EQ(res, sysconf(_SC_CLK_TCK));
BSL_SAL_Sleep(1);
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_BSL_TIME_ADD_TIME_TC001
* @title Time comparison function test.
* @tprecon
* @brief 1.Adding succeeded.
* 2.The two dates are consistent.
* 3.One of them is empty. Adding failed.
* @texpect 1.Sucessful, return BSL_SUCCESS
* 2.Sucessful, return BSL_TIME_CMP_EQUAL
* 3.Fail, return BSL_ERR
*/
/* BEGIN_CASE */
void SDV_BSL_TIME_ADD_TIME_TC001(void)
{
BSL_TIME dateA = {0};
BSL_TIME dateB = {0};
BSL_TIME dateC = {0};
dateA.year = BSL_TIME_SYSTEM_EPOCH_YEAR;
dateA.month = 1;
dateA.day = 1;
dateA.millSec = 1;
dateB.year = BSL_TIME_SYSTEM_EPOCH_YEAR;
dateB.month = 2;
dateB.day = 1;
dateB.millSec = 2;
dateC.year = BSL_TIME_SYSTEM_EPOCH_YEAR;
dateC.month = 1;
dateC.day = 1;
dateC.millSec = 3;
/* Dates add up */
ASSERT_TRUE(BSL_DateTimeAddUs(&dateA, &dateC, 0) == BSL_SUCCESS);
/* 2.Comparison of two dates */
ASSERT_NE(BSL_SAL_DateTimeCompareByUs(&dateA, &dateB), BSL_TIME_CMP_EQUAL);
ASSERT_EQ(BSL_SAL_DateTimeCompareByUs(&dateA, &dateC), BSL_TIME_CMP_EQUAL);
/* Exceptions */
ASSERT_TRUE(BSL_DateTimeAddUs(&dateA, NULL, 0) == BSL_INTERNAL_EXCEPTION);
EXIT:
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/bsl/sal/test_suite_sdv_sal_time.c
|
C
|
unknown
| 20,963
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include "tlv.h"
#include "bsl_errno.h"
/* END_HEADER */
/**
* @test SDV_BSL_TLV_Find_API_TC001
* @title Find tlv value pos test
* @precon nan
* @brief
* 1. Invoke BSL_TLV_Pack to construct a tlv buffer. Expected result 1 is obtained.
* 2. Invoke BSL_TLV_FindValuePos to find a type which valid. Expected result 2 is obtained.
* 3. Invoke BSL_TLV_FindValuePos to find a type which invalid. Expected result 3 is obtained.
* @expect
* 1. Expected success
* 2. Expected success
* 3. Expected failure
*/
/* BEGIN_CASE */
void SDV_BSL_TLV_Find_API_TC001(void)
{
int ret;
uint32_t type = 0x0101;
uint16_t version = 1;
BSL_Tlv tlv = {0};
tlv.type = type;
tlv.length = sizeof(version);
tlv.value = (uint8_t *)&version;
uint32_t encLen = 0;
uint8_t data[1024] = {0};
ret = BSL_TLV_Pack(&tlv, data, sizeof(data), &encLen);
ASSERT_TRUE(ret == BSL_SUCCESS);
uint32_t offset = 0;
uint32_t length = 0;
ret = BSL_TLV_FindValuePos(type, data, encLen, &offset, &length);
ASSERT_TRUE(ret == BSL_SUCCESS);
uint32_t invalidType = 0x0102;
ret = BSL_TLV_FindValuePos(invalidType, data, encLen, &offset, &length);
ASSERT_TRUE(ret == BSL_TLV_ERR_NO_WANT_TYPE);
EXIT:
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/bsl/tlv/test_suite_sdv_tlv.c
|
C
|
unknown
| 1,846
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/select.h>
#include <sys/time.h>
#include <linux/ioctl.h>
#include "securec.h"
#include "stub_replace.h"
#include "bsl_sal.h"
#include "sal_net.h"
#include "bsl_errno.h"
#include "bsl_uio.h"
#include "uio_base.h"
#include "sal_atomic.h"
#include "uio_abstraction.h"
/* END_HEADER */
#define MAX_BUF_SIZE 255
#define IP_V4_LEN 4
#define IP_V6_LEN 16
static int32_t g_writeRet;
static uint32_t g_writeLen;
static int32_t STUB_Write(BSL_UIO *uio, const void *buf, uint32_t len, uint32_t *writeLen)
{
(void)uio;
(void)buf;
(void)len;
*writeLen = g_writeLen;
return g_writeRet;
}
static int32_t g_readRet;
static uint32_t g_readLen;
static int32_t STUB_Read(BSL_UIO *uio, void *buf, uint32_t len, uint32_t *readLen)
{
(void)uio;
(void)buf;
(void)len;
*readLen = g_readLen;
return g_readRet;
}
static int32_t g_ctrlRet1;
static int32_t g_ctrlRet2;
static int32_t g_ctrlRet3;
static BSL_UIO_CtrlParameter g_ctrlCmd1;
static BSL_UIO_CtrlParameter g_ctrlCmd2;
static BSL_UIO_CtrlParameter g_ctrlCmd3;
static uint16_t g_shareKeyId;
static uint16_t g_delShareKeyId;
static uint8_t g_isEmpty;
static int32_t STUB_Ctrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *param)
{
(void)larg;
(void)uio;
(void)param;
if (cmd == BSL_UIO_SCTP_ADD_AUTH_SHARED_KEY) {
BSL_UIO_SctpAuthKey *key = (BSL_UIO_SctpAuthKey *)param;
g_shareKeyId = key->shareKeyId;
}
if (cmd == BSL_UIO_SCTP_DEL_PRE_AUTH_SHARED_KEY) {
g_delShareKeyId = *(uint16_t*)param;
}
if (cmd == BSL_UIO_SCTP_SND_BUFF_IS_EMPTY) {
*(uint8_t *)param = g_isEmpty;
}
if ((int32_t)g_ctrlCmd1 == cmd) {
return g_ctrlRet1;
}
if ((int32_t)g_ctrlCmd2 == cmd) {
return g_ctrlRet2;
}
if ((int32_t)g_ctrlCmd3 == cmd) {
return g_ctrlRet3;
}
return BSL_UIO_FAIL;
}
const BSL_UIO_Method * GetUioMethodByType(int uioType)
{
switch (uioType) {
#ifdef HITLS_BSL_UIO_TCP
case BSL_UIO_TCP:
return BSL_UIO_TcpMethod();
#endif
#ifdef HITLS_BSL_UIO_UDP
case BSL_UIO_UDP:
return BSL_UIO_UdpMethod();
#endif
#ifdef HITLS_BSL_UIO_MEM
case BSL_UIO_MEM:
return BSL_UIO_MemMethod();
#endif
case BSL_UIO_BUFFER:
return BSL_UIO_BufferMethod();
default:
return NULL;
}
}
typedef struct {
int32_t len;
uint8_t index;
uint8_t *buff;
} CustomLowCtx;
static int32_t BslUioCreate(BSL_UIO *uio)
{
int32_t len = 20;
int32_t ret;
CustomLowCtx *lowCtx = BSL_SAL_Calloc(1, sizeof(CustomLowCtx));
if (lowCtx == NULL) {
ret = BSL_MALLOC_FAIL;
goto EXIT;
}
lowCtx->buff = BSL_SAL_Malloc(len);
if (lowCtx->buff == NULL) {
ret = BSL_MALLOC_FAIL;
goto EXIT;
}
lowCtx->len = len;
BSL_UIO_SetCtx(uio, (void *)lowCtx);
BSL_UIO_SetInit(uio, 1);
return BSL_SUCCESS;
EXIT:
if(lowCtx != NULL) {
BSL_SAL_FREE(lowCtx->buff);
BSL_SAL_FREE(lowCtx);
}
return ret;
}
static int32_t BslUioDestroy(BSL_UIO *uio)
{
CustomLowCtx *lowCtx = BSL_UIO_GetCtx(uio);
if (lowCtx == NULL) {
return BSL_INVALID_ARG;
}
BSL_SAL_FREE(lowCtx->buff);
BSL_SAL_FREE(lowCtx);
BSL_UIO_SetCtx(uio, NULL);
return BSL_SUCCESS;
}
static int32_t BslUioWrite(BSL_UIO *uio, const void *buf, uint32_t len, uint32_t *writeLen)
{
CustomLowCtx *lowCtx = BSL_UIO_GetCtx(uio);
if (lowCtx == NULL) {
return BSL_INVALID_ARG;
}
uint32_t reslen = lowCtx->len - lowCtx->index;
if (reslen < len) {
return BSL_INVALID_ARG;
}
memcpy_s(lowCtx->buff + lowCtx->index, len, buf, len);
lowCtx->index += len;
*writeLen = len;
return BSL_SUCCESS;
}
static int32_t BslUioRead(BSL_UIO *uio, void *buf, uint32_t len, uint32_t *readLen)
{
CustomLowCtx *lowCtx = BSL_UIO_GetCtx(uio);
if (lowCtx == NULL) {
return BSL_INVALID_ARG;
}
if (lowCtx->index == 0) {
return BSL_INVALID_ARG;
}
int copyLen = (lowCtx->index > len) ? len : lowCtx->index;
(void)memcpy_s(buf, copyLen, lowCtx->buff, copyLen);
*readLen = copyLen;
lowCtx->index -= copyLen;
return BSL_SUCCESS;
}
#define BSL_CUSTOM_UIO_GET_INDEX 0x100
static int32_t BslUioCtrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *parg)
{
(void)larg;
CustomLowCtx *lowCtx = BSL_UIO_GetCtx(uio);
if (lowCtx == NULL) {
return BSL_INVALID_ARG;
}
if (cmd == BSL_CUSTOM_UIO_GET_INDEX) {
*(uint32_t *)parg = lowCtx->index;
return BSL_SUCCESS;
}
return BSL_INVALID_ARG;
}
static int32_t BslUioPuts(BSL_UIO *uio, const char *buf, uint32_t *writeLen)
{
(void) uio;
(void) buf;
(void) writeLen;
return BSL_INVALID_ARG;
}
static int32_t BslUioGets(BSL_UIO *uio, char *buf, uint32_t *readLen)
{
(void) uio;
(void) buf;
(void) readLen;
return BSL_INVALID_ARG;
}
/**
* @test SDV_BSL_UIO_NEW_API_TC001
* @title Input parameter test
* @precon nan
* @brief
* 1. Construct the tcp/sctp/udp method structure, and invoke BSL_UIO_New.
* 2. Invoke the BSL_UIO_GetTransportType interface.
* @expect
* 1. Expected the uio is not NULL, and transport type is the target type
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_NEW_API_TC001(void)
{
#if defined(HITLS_BSL_UIO_TCP) || defined(HITLS_BSL_UIO_UDP)
TestMemInit();
/* Set method to NULL */
BSL_UIO *uio = BSL_UIO_New(NULL);
ASSERT_TRUE(uio == NULL);
#ifdef HITLS_BSL_UIO_TCP
/* Set transportType to tcp and construct the method structure. */
{
const BSL_UIO_Method *ori = BSL_UIO_TcpMethod();
BSL_UIO_Method method = {0};
memcpy(&method, ori, sizeof(method));
method.uioWrite = STUB_Write;
method.uioRead = STUB_Read;
method.uioCtrl = STUB_Ctrl;
uio = BSL_UIO_New(&method);
ASSERT_TRUE(uio != NULL && BSL_UIO_GetTransportType(uio) == BSL_UIO_TCP);
BSL_UIO_Free(uio);
}
#endif
#ifdef HITLS_BSL_UIO_UDP
/* Set transportType to udp and construct the method structure. */
{
const BSL_UIO_Method *ori = BSL_UIO_UdpMethod();
BSL_UIO_Method method = {0};
memcpy(&method, ori, sizeof(method));
method.uioWrite = STUB_Write;
method.uioRead = STUB_Read;
method.uioCtrl = STUB_Ctrl;
uio = BSL_UIO_New(&method);
ASSERT_TRUE(uio != NULL && BSL_UIO_GetTransportType(uio) == BSL_UIO_UDP);
BSL_UIO_Free(uio);
}
#endif
EXIT:
return;
#else
SKIP_TEST();
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_NEW_API_TC002
* @title BSL uio and meth parameter test
* @precon Registering memory-related functions.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_NEW_API_TC002(void)
{
TestMemInit();
BSL_UIO *uio = BSL_UIO_New(NULL);
ASSERT_EQ(uio, NULL);
BSL_UIO_Method *ori = BSL_UIO_NewMethod();
ASSERT_NE(ori, NULL);
int32_t customType = BSL_UIO_EXTEND + 3;
ASSERT_EQ(BSL_UIO_SetMethodType(ori, customType), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_READ_CB, BslUioRead), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_WRITE_CB, BslUioWrite), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_CTRL_CB, BslUioCtrl), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_CREATE_CB, BslUioCreate), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_DESTROY_CB, BslUioDestroy), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_PUTS_CB, BslUioPuts), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_GETS_CB, BslUioGets), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_READ_CB, NULL), BSL_NULL_INPUT);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_GETS_CB + 1, BslUioGets), BSL_INVALID_ARG);
uio = BSL_UIO_New(ori);
ASSERT_NE(uio, NULL);
ASSERT_EQ(BSL_UIO_GetTransportType(uio), customType);
char *test = "test ";
uint32_t len = 0;
ASSERT_EQ(BSL_UIO_Gets(uio, test, &len), BSL_INVALID_ARG);
ASSERT_EQ(BSL_UIO_Puts(uio, test, &len), BSL_INVALID_ARG);
EXIT:
BSL_UIO_Free(uio);
BSL_UIO_FreeMethod(ori);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_NEW_API_TC001
* @title BSL uio and meth functional test
* @precon Registering memory-related functions.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_NEW_FUNC_TC001(void)
{
uint8_t test[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
TestMemInit();
BSL_UIO_Method *ori = BSL_UIO_NewMethod();
ASSERT_NE(ori, NULL);
int32_t customType = BSL_UIO_EXTEND + 3;
ASSERT_EQ(BSL_UIO_SetMethodType(ori, customType), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_READ_CB, BslUioRead), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_WRITE_CB, BslUioWrite), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_CTRL_CB, BslUioCtrl), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_CREATE_CB, BslUioCreate), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_DESTROY_CB, BslUioDestroy), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_PUTS_CB, BslUioPuts), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_SetMethod(ori, BSL_UIO_GETS_CB, BslUioGets), BSL_SUCCESS);
BSL_UIO *uio = BSL_UIO_New(ori);
ASSERT_NE(uio, NULL);
ASSERT_EQ(BSL_UIO_GetTransportType(uio), customType);
uint32_t len = 0;
ASSERT_EQ(BSL_UIO_Write(uio, test, 3, &len), BSL_SUCCESS);
ASSERT_EQ(len, 3);
ASSERT_EQ(BSL_UIO_Write(uio, &test[3], 7, &len), BSL_SUCCESS);
ASSERT_EQ(len, 7);
uint32_t index = 0;
ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_CUSTOM_UIO_GET_INDEX, sizeof(index), &index), BSL_SUCCESS);
ASSERT_EQ(index, 10);
uint8_t readBuff[20] = {0};
ASSERT_EQ(BSL_UIO_Read(uio, readBuff, 8, &len), BSL_SUCCESS);
ASSERT_EQ(len, 8);
ASSERT_EQ(BSL_UIO_Read(uio, &readBuff[7], 8, &len), BSL_SUCCESS);
ASSERT_EQ(len, 2);
ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_CUSTOM_UIO_GET_INDEX, sizeof(index), &index), BSL_SUCCESS);
ASSERT_EQ(index, 0);
EXIT:
BSL_UIO_Free(uio);
BSL_UIO_FreeMethod(ori);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_INIT_FUNC_TC001
* @title Init status value test: The uio type of the FD can be set.
* @precon nan
* @brief
* 1.BSL_UIO_New,Expected result 1 is obtained.
* 2.BSL_UIO_GET_INIT,Expected result 2 is obtained.
* 3.BSL_UIO_GET_FD,Expected result 3 is obtained.
* 4.BSL_UIO_SET_FD,Expected result 4 is obtained.
* 5.BSL_UIO_GET_INIT,Expected result 5 is obtained.
* 6.BSL_UIO_GET_FD,Expected result 6 is obtained.
* @expect
* 1.Expected success
* 2.The value of init is 0.
* 3.Expected failure, The error code is BSL_UIO_UNINITIALIZED,fd is - 1.
* 4.Expected success
* 5.The value of init is 1.
* 6.Expected success
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_INIT_FUNC_TC001(int uioType)
{
BSL_UIO *uio = NULL;
int32_t fd = 5;
uint8_t init = 0;
int32_t getFd = 0;
const BSL_UIO_Method *ori = NULL;
switch (uioType) {
case BSL_UIO_TCP:
case BSL_UIO_UDP:
ori = GetUioMethodByType(uioType);
break;
default: // The uio of the FD cannot be set.
ASSERT_TRUE(false);
}
ASSERT_TRUE(ori != NULL);
uio = BSL_UIO_New(ori);
ASSERT_TRUE(uio != NULL);
ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_GET_INIT, (int32_t)sizeof(init), &init), BSL_SUCCESS);
ASSERT_EQ(init, 0);
ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_SET_FD, (int32_t)sizeof(fd), &fd), BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_GET_INIT, (int32_t)sizeof(init), &init), BSL_SUCCESS);
ASSERT_EQ(init, 1);
ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_GET_FD, (int32_t)sizeof(fd), &getFd), BSL_SUCCESS);
ASSERT_EQ(getFd, fd);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_INIT_FUNC_TC002
* @title Init status value test: Test the UIO type whose init is set to 1 during create.
* @precon nan
* @brief
* 1.Call BSL_UIO_New. Expected result 1 is obtained.
* 2.Call BSL_UIO_GET_INIT. Expected result 1 is obtained.
* @expect
* 1.Success
* 2.init is 1
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_INIT_FUNC_TC002(int uioType)
{
BSL_UIO *uio = NULL;
uint8_t init = 0;
const BSL_UIO_Method *ori = NULL;
switch (uioType) {
case BSL_UIO_BUFFER:
case BSL_UIO_MEM:
ori = GetUioMethodByType(uioType);
break;
default:
ASSERT_TRUE(false);
}
ASSERT_TRUE(ori != NULL);
uio = BSL_UIO_New(ori);
ASSERT_TRUE(uio != NULL);
ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_GET_INIT, (int32_t)sizeof(init), &init), BSL_SUCCESS);
ASSERT_EQ(init, 1);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/**
* @test UT_BSL_UIO_FREE_API_TC001
* @title Input parameter test
* @precon nan
* @brief
* 1. Set UIO to null and invoke BSL_UIO_Free. Expected result 1 is obtained.
* @expect
* 1. It is expected that the program does not dump code. No memory leakage occurs.
*/
/* BEGIN_CASE */
void UT_BSL_UIO_FREE_API_TC001(void)
{
/* The test UIO is empty. */
BSL_UIO_Free(NULL);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_SETUSERDATA_API_TC001
* @title Input parameter test
* @precon nan
* @brief
* 1.The specified uio is empty, Invoke BSL_UIO_SetUserData,Expected result 1 is obtained.
* 2.Construct the uio object, the user data is empty, invoke the BSL_UIO_SetUserData interface.
Expected result 2 is obtained.
* 3.Invoke BSL_UIO_SetUserData to specify that data1 is not null, Expected result 3 is obtained.
* 4.User data2 is not empty, call BSL_UIO_SetUserData again, Expected result 4 is obtained.
* 5.Releasing a UIO Object, Expected result 5 is obtained.
* @expect
* 1.Expected return failure
* 2.Expected success
* 3.Expected success
* 4.Expected success
* 5.It is expected that the program does not have code dump and no memory leakage occurs.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_SETUSERDATA_API_TC001(void)
{
BSL_UIO *uio = NULL;
void *userData1 = (void *)STUB_Write;
void *userData2 = (void *)STUB_Read;
/* The test UIO is empty. */
int32_t ret = BSL_UIO_SetUserData(NULL, userData1);
ASSERT_TRUE(ret == BSL_NULL_INPUT);
uio = BSL_UIO_New(BSL_UIO_TcpMethod());
ASSERT_TRUE(uio != NULL);
ret = BSL_UIO_SetUserData(uio, NULL);
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_UIO_SetUserData(uio, userData1);
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_UIO_SetUserData(uio, userData2);
ASSERT_TRUE(ret == BSL_SUCCESS);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_GETUSERDATA_API_TC001
* @title Input parameter test
* @precon nan
* @brief
* 1.The specified uio is empty., invoke BSL_UIO_GetUserData. Expected result 1 is obtained.
* 2.Construct the uio object, invoke BSL_UIO_GetUserData. Expected result 2 is obtained.
* 3.Construct user data, invoke BSL_UIO_SetUserData. Expected result 3 is obtained.
* 4.Invoke BSL_UIO_GetUserData. Expected result 4 is obtained.
* 5.Invoke BSL_UIO_Free. Expected result 5 is obtained.
* @expect
* 1.Expected return NULL
* 2.Expected return NULL
* 3.Expected success
* 4.The expected return value is the same as the data pointer.
* 5.It is expected that the program does not have code dump and no memory leakage occurs.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_GETUSERDATA_API_TC001(void)
{
BSL_UIO *uio = NULL;
void *userData = (void *)STUB_Write;
/* The test UIO is empty. */
void *data = BSL_UIO_GetUserData(NULL);
ASSERT_TRUE(data == NULL);
uio = BSL_UIO_New(BSL_UIO_TcpMethod());
ASSERT_TRUE(uio != NULL);
int32_t ret = BSL_UIO_SetUserData(uio, userData);
ASSERT_TRUE(ret == BSL_SUCCESS);
data = BSL_UIO_GetUserData(uio);
ASSERT_TRUE(data == userData);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_FLAGS_FUNC_TC001
* @title UIO Setting the Status Test
* @precon nan
* @brief
* 1.BSL_UIO_New. Expected result 1 is obtained.
* 2.BSL_UIO_SetFlags. Expected result 2 is obtained.
* @expect
* 1.Expected success
* 2.If the flags are invalid, BSL_INVALID_ARG is returned. If the flags are valid, BSL_SUCCESS is returned.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_FLAGS_FUNC_TC001(int uioType)
{
BSL_UIO *uio = NULL;
const BSL_UIO_Method *ori = GetUioMethodByType(uioType);
ASSERT_TRUE(ori != NULL);
uio = BSL_UIO_New(ori);
ASSERT_TRUE(uio != NULL);
// 0000 0001
ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_READ), BSL_SUCCESS);
// 0000 0010
ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_WRITE), BSL_SUCCESS);
// 0000 0100
ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_IO_SPECIAL), BSL_SUCCESS);
// 0000 0111
ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_RWS), BSL_SUCCESS);
// 0000 1000
ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_SHOULD_RETRY), BSL_SUCCESS);
// 0001 0000
ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_MEM_READ_ONLY), BSL_INVALID_ARG);
// 0010 0000
ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_BASE64_NO_NEWLINE), BSL_SUCCESS);
// 0100 0000
ASSERT_EQ(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_BASE64_PEM), BSL_SUCCESS);
// 0111 1111
ASSERT_EQ(BSL_UIO_SetFlags(uio, 0b01111111), BSL_INVALID_ARG);
// 0110 1111
ASSERT_EQ(BSL_UIO_SetFlags(uio, 0b01101111), BSL_SUCCESS);
// 1110 1111
ASSERT_EQ(BSL_UIO_SetFlags(uio, 0b11101111), BSL_INVALID_ARG);
ASSERT_EQ(BSL_UIO_SetFlags(uio, -1), BSL_INVALID_ARG);
ASSERT_EQ(BSL_UIO_SetFlags(uio, INT_MAX), BSL_INVALID_ARG);
ASSERT_EQ(BSL_UIO_SetFlags(uio, 0), BSL_INVALID_ARG);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_FLAGS_FUNC_TC002
* @title UIO flags interface test
* @precon
* @brief
* 1. uio new. Expected result 1 is obtained.
* 2. Set two flags A and B. Expected result 2 is obtained.
* 3. Detection mark A. Expected result 3 is obtained.
* 4. Clear mark A. Expected result 4 is obtained.
* 5. Detection mark A. Expected result 5 is obtained.
* 6. Detection mark B. Expected result 6 is obtained.
* @expect
* 1. The success is not null.
* 2. Success
* 3. Successful and flag A detected
* 4. Success
* 5. Succeeded and Flag A Not Detected
* 6. Successful and Mark B detected
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_FLAGS_FUNC_TC002(void)
{
BSL_UIO *uio = BSL_UIO_New(BSL_UIO_TcpMethod());
ASSERT_TRUE(uio != NULL);
ASSERT_TRUE(BSL_UIO_SetFlags(uio, BSL_UIO_FLAGS_WRITE | BSL_UIO_FLAGS_SHOULD_RETRY) == BSL_SUCCESS);
uint32_t out = 0;
ASSERT_TRUE(BSL_UIO_TestFlags(uio, BSL_UIO_FLAGS_WRITE, &out) == BSL_SUCCESS);
ASSERT_TRUE(out == BSL_UIO_FLAGS_WRITE);
ASSERT_TRUE(BSL_UIO_ClearFlags(uio, BSL_UIO_FLAGS_WRITE) == BSL_SUCCESS);
ASSERT_TRUE(BSL_UIO_TestFlags(uio, BSL_UIO_FLAGS_WRITE, &out) == BSL_SUCCESS);
ASSERT_TRUE(out == 0);
ASSERT_TRUE(BSL_UIO_TestFlags(uio, BSL_UIO_FLAGS_SHOULD_RETRY, &out) == BSL_SUCCESS);
ASSERT_TRUE(out == BSL_UIO_FLAGS_SHOULD_RETRY);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_UPREF_API_TC001
* @title Input Parameter test
* @precon nan
* @brief
* 1.The specified uio is empty, invoke UIO_UpRef. Expected result 1 is obtained.
* 2.Construct the uio object(BSL_UIO_New), invoke UIO_UpRef. Expected result 2 is obtained.
* 3.BSL_UIO_Free is invoked twice. Expected result 3 is obtained.
* @expect
* 1.Expected return failure
* 2.Expected success
* 3.It is expected that the program does not have code dump and no memory leakage occurs.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_UPREF_API_TC001(void)
{
#ifndef HITLS_BSL_UIO_SCTP
SKIP_TEST();
#else
BSL_UIO *uio = NULL;
/* The test UIO is empty. */
int32_t ret = BSL_UIO_UpRef(NULL);
ASSERT_TRUE(ret == BSL_INTERNAL_EXCEPTION);
uio = BSL_UIO_New(BSL_UIO_SctpMethod());
ASSERT_TRUE(uio != NULL);
ret = BSL_UIO_UpRef(uio);
ASSERT_TRUE(ret == BSL_SUCCESS);
EXIT:
BSL_UIO_Free(uio);
BSL_UIO_Free(uio);
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_WRITE_API_TC001
* @title Input parameter test
* @precon nan
* @brief
* 1. Call BSL_UIO_TcpMethod to create a tcp method. Expected result 1 is obtained.
* 2. The value of the input parameter UIO is NULL when BSL_UIO_Write is invoked. Expected result 2 is obtained.
* 3. The value of the input parameter data is NULL when BSL_UIO_Write is invoked. Expected result 2 is obtained.
* 4. The value of the input parameter data len is 0 when BSL_UIO_Write is invoked. Expected result 2 is obtained.
* 5. The value of the input parameter write len is NULL when BSL_UIO_Write is invoked. Expected result 2 is obtained.
* @expect
* 1. The TCP method is successfully created.
* 2. Return HITLS_INTERNAL_EXCEPTION
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_WRITE_API_TC001(void)
{
#ifdef HITLS_BSL_UIO_TCP
BSL_UIO *uio = NULL;
uint8_t data[MAX_BUF_SIZE] = {0};
const uint32_t len = 1;
uint32_t writeLen;
const BSL_UIO_Method *ori = BSL_UIO_TcpMethod();
BSL_UIO_Method method = {0};
memcpy(&method, ori, sizeof(method));
method.uioWrite = STUB_Write;
method.uioRead = STUB_Read;
/* The test UIO is empty. */
int32_t ret = BSL_UIO_Write(NULL, data, len, &writeLen);
ASSERT_TRUE(ret == BSL_INTERNAL_EXCEPTION);
uio = BSL_UIO_New(&method);
ASSERT_TRUE(uio != NULL);
/* The test data is null. */
ret = BSL_UIO_Write(uio, NULL, len, &writeLen);
ASSERT_TRUE(ret == BSL_INTERNAL_EXCEPTION);
/* Test the case when the write length is 0. */
ret = BSL_UIO_Write(uio, data, 0, &writeLen);
ASSERT_TRUE(ret == BSL_INTERNAL_EXCEPTION);
/* Test that writeLen is NULL. */
ret = BSL_UIO_Write(uio, data, len, NULL);
ASSERT_TRUE(ret == BSL_INTERNAL_EXCEPTION);
EXIT:
BSL_UIO_Free(uio);
#else
SKIP_TEST();
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_READ_API_TC001
* @title Input parameter test
* @precon nan
* @brief
* 1. Call BSL_UIO_TcpMethod to create a tcp method. Expected result 1 is obtained.
* 2. The value of the input parameter UIO is NULL when BSL_UIO_Read is invoked. Expected result 2 is obtained.
* 3. The value of the input parameter data is NULL when BSL_UIO_Read is invoked. Expected result 3 is obtained.
* 4. The value of the input parameter data len is 0 when BSL_UIO_Read is invoked. Expected result 4 is obtained.
* 5. The value of the input parameter write len is NULL when BSL_UIO_Read is invoked. Expected result 4 is obtained.
* @expect
* 1. The TCP method is successfully created.
* 2. Return BSL_INTERNAL_EXCEPTION
* 3. Return BSL_INTERNAL_EXCEPTION
* 4. Return BSL_INTERNAL_EXCEPTION
* 5. Return BSL_INTERNAL_EXCEPTION
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_READ_API_TC001(void)
{
#ifdef HITLS_BSL_UIO_TCP
BSL_UIO *uio = NULL;
uint8_t data[MAX_BUF_SIZE] = {0};
const uint32_t len = 1;
uint32_t readLen;
const BSL_UIO_Method *ori = BSL_UIO_TcpMethod();
BSL_UIO_Method method = {0};
memcpy(&method, ori, sizeof(method));
method.uioWrite = STUB_Write;
method.uioRead = STUB_Read;
/* The test UIO is empty. */
int32_t ret = BSL_UIO_Read(NULL, data, len, &readLen);
ASSERT_TRUE(ret == BSL_INTERNAL_EXCEPTION);
uio = BSL_UIO_New(&method);
ASSERT_TRUE(uio != NULL);
/* The test data is null. */
ret = BSL_UIO_Read(uio, NULL, len, &readLen);
ASSERT_TRUE(ret == BSL_INTERNAL_EXCEPTION);
/* Test the case when the write length is 0. */
ret = BSL_UIO_Read(uio, data, 0, &readLen);
ASSERT_TRUE(ret == BSL_INTERNAL_EXCEPTION);
/* Test that writeLen is NULL. */
ret = BSL_UIO_Read(uio, data, len, NULL);
ASSERT_TRUE(ret == BSL_INTERNAL_EXCEPTION);
EXIT:
BSL_UIO_Free(uio);
#else
SKIP_TEST();
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_SET_USERDATA_FREE_TC001
* @title Set userData free test
* @precon nan
* @brief
* 1. Call BSL_UIO_New to create a tcp uio. Expected result 1 is obtained.
* 2. Apply for space for userData. Expected result 2 is obtained.
* 3. Call BSL_UIO_SetUserData to set userData for UIO. Expected result 3 is obtained.
* 4. Call BSL_UIO_SetUserDataFreeFunc when uio is NULL. Expected result 4 is obtained.
* 5. Call BSL_UIO_SetUserDataFreeFunc when uio is not null. Expected result 5 is obtained.
* @expect
* 1. The TCP UIO is successfully created.
* 2. The value of userData is not empty.
* 3. Return BSL_SUCCESS and the userdata of the UIO is not empty.
* 4. Return BSL_NULL_INPUT
* 5. Return BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_SET_USERDATA_FREE_TC001(void)
{
BSL_UIO *uio = BSL_UIO_New(BSL_UIO_TcpMethod());
ASSERT_TRUE(uio != NULL);
void *userData = BSL_SAL_Malloc(MAX_BUF_SIZE);
ASSERT_TRUE(userData != NULL);
int32_t ret = BSL_UIO_SetUserData(uio, userData);
ASSERT_TRUE(ret == BSL_SUCCESS);
ASSERT_TRUE(uio->userData != NULL);
ret = BSL_UIO_SetUserDataFreeFunc(NULL, BSL_SAL_Free);
ASSERT_TRUE(ret == BSL_NULL_INPUT);
ret = BSL_UIO_SetUserDataFreeFunc(uio, BSL_SAL_Free);
ASSERT_TRUE(ret == BSL_SUCCESS);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_GET_METHOD_TC001
* @title Get uio method test
* @precon nan
* @brief
* 1. Call BSL_UIO_New to create a tcp uio. Expected result 1 is obtained.
* 2. Call BSL_UIO_TcpMethod to create a tcp method. Call BSL_UIO_GetMethod to obtain the method of TCP_UIO.
* Compare the two methods. Expected result 2 is obtained.
* @expect
* 1. The TCP UIO is successfully created.
* 2. The two methods are equal.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_GET_METHOD_TC001(void)
{
#ifdef HITLS_BSL_UIO_TCP
const BSL_UIO_Method *ori = BSL_UIO_TcpMethod();
BSL_UIO *uio = BSL_UIO_New(ori);
ASSERT_TRUE(uio != NULL);
const BSL_UIO_Method *method = BSL_UIO_GetMethod(uio);
int ret = memcmp(method, ori, sizeof(BSL_UIO_Method));
ASSERT_TRUE(ret == 0);
EXIT:
BSL_UIO_Free(uio);
#else
SKIP_TEST();
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_GET_READANDWRITE_NUM_TC001
* @title Get read and written num test
* @precon nan
* @brief
* 1. Call BSL_UIO_TcpMethod to create a tcp method. Expected result 1 is obtained.
* 2. Call BSL_UIO_New to create a tcp uio. Expected result 2 is obtained.
* 3. Call BSL_UIO_Ctrl and transfer the BSL_UIO_GET_WRITE_NUM parameter to obtain the number of written
* bytes. Expected result 3 is obtained.
* 4. Call BSL_UIO_Ctrl and transfer the BSL_UIO_GET_READ_NUM parameter to obtain the number of read bytes.
* Expected result 4 is obtained.
* @expect
* 1. The TCP METHOD is successfully created.
* 2. The TCP UIO is successfully created.
* 3. The value of writeNum is the same as the number of written bytes.
* 4. The value of readNum is the same as the number of read bytes.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_GET_READANDWRITE_NUM_TC001(void)
{
#ifdef HITLS_BSL_UIO_TCP
BSL_UIO *uio = NULL;
uint8_t data[10] = {'0', '1', '2', '3', '4'};
uint8_t readBuf[10] = {0};
const uint32_t dataLen = 5;
uint32_t writeLen = 0;
uint32_t readLen = 0;
int64_t writeNum = 0;
int64_t readNum = 0;
const BSL_UIO_Method *ori = BSL_UIO_TcpMethod();
BSL_UIO_Method method = {0};
memcpy(&method, ori, sizeof(method));
method.uioWrite = STUB_Write;
method.uioRead = STUB_Read;
uio = BSL_UIO_New(&method);
ASSERT_TRUE(uio != NULL);
BSL_UIO_SetInit(uio, 1);
ASSERT_TRUE(BSL_UIO_Write(uio, data, dataLen, &writeLen) == BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_GET_WRITE_NUM, (int32_t)sizeof(writeNum), &writeNum), BSL_SUCCESS);
ASSERT_EQ(writeNum, writeLen);
ASSERT_TRUE(BSL_UIO_Read(uio, readBuf, dataLen, &readLen) == BSL_SUCCESS);
ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_GET_READ_NUM, (int32_t)sizeof(readNum), &readNum), BSL_SUCCESS);
ASSERT_EQ(readNum, readLen);
EXIT:
BSL_UIO_Free(uio);
#else
SKIP_TEST();
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_SET_FD_TC001
* @title Set fd test
* @precon nan
* @brief
* 1. Call BSL_UIO_New to create a tcp uio. Expected result 1 is obtained.
* 2. Call BSL_UIO_SetFD to set fd to uio. Call BSL_UIO_Ctrl and transfer the BSL_UIO_GET_FD parameter to obtain
* the fd1 of uio. Compare the two fds. Expected result 2 is obtained.
* @expect
* 1. The TCP UIO is successfully created.
* 2. The two fds are equal.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_SET_FD_TC001(void)
{
char *filename = "fd_test_file.txt";
int fd = open(filename, O_RDWR | O_CREAT, 0060);
const char *data = "012345678\nabcdef";
write(fd, data, strlen(data));
BSL_UIO *uio = BSL_UIO_New(BSL_UIO_TcpMethod());
ASSERT_TRUE(uio != NULL);
BSL_UIO_SetIsUnderlyingClosedByUio(uio, true);
BSL_UIO_SetFD(uio, fd);
int32_t fd1 = -1;
ASSERT_TRUE(BSL_UIO_Ctrl(uio, BSL_UIO_GET_FD, (int32_t)sizeof(fd1), &fd1) == BSL_SUCCESS);
ASSERT_TRUE(fd == fd1);
EXIT:
BSL_UIO_Free(uio);
remove(filename);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_NEXT_TC001
* @title Uio next test
* @precon nan
* @brief
* 1. Call BSL_UIO_New to create a tcp uio named tcp1. Expected result 1 is obtained.
* 2. Call BSL_UIO_New to create a tcp uio named tcp2. Expected result 2 is obtained.
* 3. Append tcp2 to tcp1. Expected result 3 is obtained.
* 4. Check the next uio of tcp1 and the next uio of tcp2. Expected result 4 is obtained.
* @expect
* 1. The tcp1 is successfully created.
* 2. The tcp2 is successfully created.
* 3. Return BSL_SUCCESS.
* 4. The next uio of tcp1 is tcp2 and the next uio of tcp2 is NULL.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_NEXT_TC001(void)
{
BSL_UIO *tcp1 = BSL_UIO_New(BSL_UIO_TcpMethod());
ASSERT_TRUE(tcp1 != NULL);
BSL_UIO *tcp2 = BSL_UIO_New(BSL_UIO_TcpMethod());
ASSERT_TRUE(tcp2 != NULL);
ASSERT_TRUE(BSL_UIO_Append(tcp1, tcp2) == BSL_SUCCESS);
ASSERT_TRUE(BSL_UIO_Next(tcp1) == tcp2);
ASSERT_TRUE(BSL_UIO_Next(tcp2) == NULL);
EXIT:
BSL_UIO_Free(tcp1);
BSL_UIO_Free(tcp2);
}
/* END_CASE */
typedef union {
struct sockaddr addr;
struct sockaddr_in6 addrIn6;
struct sockaddr_in addrIn;
struct sockaddr_un addrUn;
} UIO_Addr;
/**
* @test SDV_BSL_UIO_UDP_API_TC001
* @title UDP ctrl test
* @precon nan
* @brief
* 1. Call BSL_UIO_UdpMethod to create a UDP method. Expected result 1 is obtained.
* 2. The input cmd is BSL_UIO_SET_PEER_IP_ADDR when BSL_UIO_Ctrl is invoked. Expected result 2 is obtained.
* 3. The input cmd is BSL_UIO_GET_PEER_IP_ADDR when BSL_UIO_Ctrl is invoked. Expected result 3 is obtained.
* 4. The input cmd is BSL_UIO_UDP_SET_CONNECTED when BSL_UIO_Ctrl is invoked. Expected result 3 is obtained.
* @expect
* 1. The UDP method is successfully created.
* 2. Return BSL_SUCCESS
* 3. Return BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_UDP_API_TC001(void)
{
BSL_UIO *uio = NULL;
int ret;
UIO_Addr peerAddr = { 0 };
uint8_t ipv4[IP_V4_LEN] = {0x11, 0x22, 0x33, 0x44};
peerAddr.addr.sa_family = AF_INET;
ASSERT_TRUE(memcpy_s(peerAddr.addr.sa_data, sizeof(UIO_Addr), ipv4, IP_V4_LEN) == EOK);
const BSL_UIO_Method *ori = BSL_UIO_UdpMethod();
BSL_UIO_Method method = {0};
memcpy_s(&method, sizeof(method), ori, sizeof(method));
method.uioWrite = STUB_Write;
method.uioRead = STUB_Read;
uio = BSL_UIO_New(&method);
ASSERT_TRUE(uio != NULL);
ret = BSL_UIO_Ctrl(uio, BSL_UIO_SET_PEER_IP_ADDR, sizeof(peerAddr), &peerAddr);
ASSERT_TRUE(ret == BSL_SUCCESS);
UIO_Addr getAddr = { 0 };
ret = BSL_UIO_Ctrl(uio, BSL_UIO_GET_PEER_IP_ADDR, sizeof(getAddr), &getAddr);
ASSERT_TRUE(ret == BSL_SUCCESS);
ASSERT_TRUE(memcmp(getAddr.addr.sa_data, peerAddr.addr.sa_data, IP_V4_LEN) == 0);
ret = BSL_UIO_Ctrl(uio, BSL_UIO_UDP_SET_CONNECTED, sizeof(peerAddr.addr), &peerAddr);
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_UIO_Ctrl(uio, BSL_UIO_UDP_SET_CONNECTED, 0, NULL);
ASSERT_TRUE(ret == BSL_SUCCESS);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_SCTP_API_TC001
* @title SCTP ctrl test
* @precon nan
* @brief
* 1. Call BSL_UIO_SctpMethod to create a SCTP method. Expected result 1 is obtained.
* 2. The input cmd is BSL_UIO_SET_PEER_IP_ADDR when BSL_UIO_Ctrl is invoked. Expected result 2 is obtained.
* 3. The input cmd is BSL_UIO_GET_PEER_IP_ADDR when BSL_UIO_Ctrl is invoked. Expected result 3 is obtained.
* 4. The input cmd is BSL_UIO_SCTP_SET_APP_STREAM_ID when BSL_UIO_Ctrl is invoked. Expected result 4 is obtained.
* @expect
* 1. The SCTP method is successfully created.
* 2. Return BSL_SUCCESS
* 3. Return BSL_SUCCESS
* 4. Return BSL_SUCCESS
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_SCTP_API_TC001(void)
{
#ifndef HITLS_BSL_UIO_SCTP
SKIP_TEST();
#else
BSL_UIO *uio = NULL;
int ret;
uint8_t ipAddr[256] = {0};
BSL_UIO_CtrlGetPeerIpAddrParam param = {ipAddr, sizeof(ipAddr)};
uint8_t data[IP_ADDR_V4_LEN] = {0};
uint16_t sendAppStreamId = 1;
const BSL_UIO_Method *ori = BSL_UIO_SctpMethod();
BSL_UIO_Method method = {0};
memcpy(&method, ori, sizeof(method));
method.uioWrite = STUB_Write;
method.uioRead = STUB_Read;
uio = BSL_UIO_New(&method);
ASSERT_TRUE(uio != NULL);
ret = BSL_UIO_Ctrl(uio, BSL_UIO_SET_PEER_IP_ADDR, sizeof(data), data);
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_UIO_Ctrl(uio, BSL_UIO_GET_PEER_IP_ADDR, sizeof(param), ¶m);
ASSERT_TRUE(ret == BSL_SUCCESS);
ret = BSL_UIO_Ctrl(uio, BSL_UIO_SCTP_SET_APP_STREAM_ID, sizeof(uint16_t), &sendAppStreamId);
ASSERT_TRUE(ret == BSL_SUCCESS);
EXIT:
BSL_UIO_Free(uio);
#endif
}
/* END_CASE */
/**
* @test SDV_BSL_UIO_BUFFER_RESET_TC001
* @title Buffer reset test
* @precon nan
* @brief
* 1. Call BSL_UIO_New to create a buffer uio named buffer. Expected result 1 is obtained.
* 2. Call BSL_UIO_New to create a tcp uio named tcp. Expected result 2 is obtained.
* 3. Append tcp to buffer. Expected result 3 is obtained.
* 4. Write 2048-length data to the buffer uio. Expected result 4 is obtained.
* 5. Call BSL_UIO_Ctrl and transfer the BSL_UIO_RESET parameter to reset the buffer uio. Expected result 5 is
* obtained.
* @expect
* 1. The buffer is successfully created.
* 2. The tcp is successfully created.
* 3. Return BSL_SUCCESS and the next uio of buffer is tcp.
* 4. Return BSL_SUCCESS and writeLen is 2048.
* 5. Return BSL_UIO_FAIL.
*/
/* BEGIN_CASE */
void SDV_BSL_UIO_BUFFER_RESET_TC001(void)
{
BSL_UIO *buffer = BSL_UIO_New(BSL_UIO_BufferMethod());
ASSERT_TRUE(buffer != NULL);
BSL_UIO *tcp = BSL_UIO_New(BSL_UIO_TcpMethod());
ASSERT_TRUE(tcp != NULL);
int32_t ret = BSL_UIO_Append(buffer, tcp);
ASSERT_TRUE(ret == BSL_SUCCESS);
ASSERT_TRUE(BSL_UIO_Next(buffer) == tcp);
ASSERT_TRUE(BSL_UIO_Next(tcp) == NULL);
uint8_t buf[8192];
uint32_t writeLen = 0;
ret = BSL_UIO_Write(buffer, buf, 2048, &writeLen);
ASSERT_TRUE(ret == BSL_SUCCESS);
ASSERT_TRUE(writeLen == 2048);
ret = BSL_UIO_Ctrl(buffer, BSL_UIO_RESET, 0, NULL);
ASSERT_TRUE(ret = BSL_UIO_FAIL);
EXIT:
BSL_UIO_Free(buffer);
BSL_UIO_Free(tcp);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_UIO_MEM_BASIC_TC001(void)
{
TestMemInit();
// Create memory UIO
BSL_UIO *uio = BSL_UIO_New(BSL_UIO_MemMethod());
ASSERT_TRUE(uio != NULL);
// Test write operation
const char testData[] = "Hello World";
uint32_t writeLen = 0;
int32_t ret = BSL_UIO_Write(uio, testData, strlen(testData), &writeLen);
ASSERT_TRUE(ret == BSL_SUCCESS);
ASSERT_TRUE(writeLen == strlen(testData));
// Test read operation
char readBuf[20] = {0};
uint32_t readLen = 0;
ret = BSL_UIO_Read(uio, readBuf, sizeof(readBuf), &readLen);
ASSERT_TRUE(ret == BSL_SUCCESS);
ASSERT_TRUE(readLen == strlen(testData));
ASSERT_TRUE(memcmp(readBuf, testData, readLen) == 0);
// Test pending data length
uint64_t pendingLen = 0;
ret = BSL_UIO_Ctrl(uio, BSL_UIO_PENDING, sizeof(uint64_t), &pendingLen);
ASSERT_TRUE(ret == BSL_SUCCESS);
ASSERT_TRUE(pendingLen == 0); // All data has been read
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_UIO_MEM_NEW_BUF_TC001(void)
{
TestMemInit();
BSL_UIO *uio = BSL_UIO_New(BSL_UIO_MemMethod());
ASSERT_TRUE(uio != NULL);
// Test MemNewBuf with invalid parameters
int32_t ret = BSL_UIO_Ctrl(uio, BSL_UIO_MEM_NEW_BUF, -1, NULL);
ASSERT_TRUE(ret == BSL_NULL_INPUT);
// Test MemNewBuf with valid parameters
char testBuf[] = "Test Buffer";
ret = BSL_UIO_Ctrl(uio, BSL_UIO_MEM_NEW_BUF, strlen(testBuf), testBuf);
ASSERT_TRUE(ret == BSL_SUCCESS);
// Verify buffer is in read-only mode
uint32_t writeLen = 0;
ret = BSL_UIO_Write(uio, "data", 4, &writeLen);
ASSERT_TRUE(ret == BSL_UIO_WRITE_NOT_ALLOWED);
// Test reading from new buffer
char readBuf[20] = {0};
uint32_t readLen = 0;
ret = BSL_UIO_Read(uio, readBuf, sizeof(readBuf), &readLen);
ASSERT_TRUE(ret == BSL_SUCCESS);
ASSERT_TRUE(readLen == strlen(testBuf));
ASSERT_TRUE(memcmp(readBuf, testBuf, readLen) == 0);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_UIO_MEM_EOF_TC001(void)
{
TestMemInit();
BSL_UIO *uio = BSL_UIO_New(BSL_UIO_MemMethod());
ASSERT_TRUE(uio != NULL);
// Test setting EOF behavior
int32_t eofValue = 1;
int32_t ret = BSL_UIO_Ctrl(uio, BSL_UIO_MEM_SET_EOF, sizeof(int32_t), &eofValue);
ASSERT_TRUE(ret == BSL_SUCCESS);
// Verify EOF value
int32_t readEof = 0;
ret = BSL_UIO_Ctrl(uio, BSL_UIO_MEM_GET_EOF, sizeof(int32_t), &readEof);
ASSERT_TRUE(ret == BSL_SUCCESS);
ASSERT_TRUE(readEof == eofValue);
// Test read behavior with EOF set
char readBuf[10];
uint32_t readLen = 0;
ret = BSL_UIO_Read(uio, readBuf, sizeof(readBuf), &readLen);
ASSERT_TRUE(ret == BSL_SUCCESS);
ASSERT_TRUE(readLen == 0);
// Verify retry flag is set due to EOF
uint32_t flags = 0;
BSL_UIO_TestFlags(uio, BSL_UIO_FLAGS_SHOULD_RETRY, &flags);
ASSERT_TRUE((flags & BSL_UIO_FLAGS_SHOULD_RETRY) != 0);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_UIO_MEM_PUTS_TC001(void)
{
char buf[MAX_BUF_SIZE] = {0};
uint32_t len = 0;
const char *str = "Hello World";
bool init = 0;
BSL_UIO *uio = BSL_UIO_New(BSL_UIO_MemMethod());
ASSERT_TRUE(uio != NULL);
ASSERT_EQ(BSL_UIO_Ctrl(uio, BSL_UIO_GET_INIT, (int32_t)sizeof(init), &init), BSL_SUCCESS);
ASSERT_EQ(init, true);
BSL_UIO_SetInit(uio, false);
ASSERT_EQ(BSL_UIO_Puts(uio, str, &len), BSL_UIO_UNINITIALIZED);
ASSERT_EQ(BSL_UIO_Read(uio, buf, sizeof(buf), &len), BSL_UIO_UNINITIALIZED);
BSL_UIO_SetInit(uio, true);
ASSERT_EQ(BSL_UIO_Puts(uio, str, &len), BSL_SUCCESS);
ASSERT_EQ(len, strlen(str));
len = 0;
ASSERT_EQ(BSL_UIO_Read(uio, buf, sizeof(buf), &len), BSL_SUCCESS);
ASSERT_EQ(len, strlen(str));
buf[len] = '\0';
ASSERT_EQ(strcmp(buf, str), 0);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_BSL_UIO_MEM_GETS_TC001(void)
{
char buf[MAX_BUF_SIZE] = {0};
uint32_t len = 0;
const char *data = "-----BEGIN PUBLIC KEY-----\nMCowBQYDK9zf3ZM1EP9N\n-----END PUBLIC KEY-----";
uint32_t dataLen = strlen(data);
BSL_UIO *uio = BSL_UIO_New(BSL_UIO_MemMethod());
ASSERT_TRUE(uio != NULL);
BSL_UIO_SetInit(uio, false);
ASSERT_EQ(BSL_UIO_Write(uio, data, dataLen, &len), BSL_UIO_UNINITIALIZED);
ASSERT_EQ(BSL_UIO_Gets(uio, buf, &len), BSL_UIO_UNINITIALIZED);
BSL_UIO_SetInit(uio, true);
ASSERT_EQ(BSL_UIO_Write(uio, data, dataLen, &len), BSL_SUCCESS);
ASSERT_EQ(len, dataLen);
len = MAX_BUF_SIZE;
ASSERT_EQ(BSL_UIO_Gets(uio, buf, &len), BSL_SUCCESS);
const char *str = "-----BEGIN PUBLIC KEY-----\n";
ASSERT_EQ(len, strlen(str));
ASSERT_EQ(strcmp(buf, str), 0);
len = MAX_BUF_SIZE;
ASSERT_EQ(BSL_UIO_Gets(uio, buf, &len), BSL_SUCCESS);
const char *str1 = "MCowBQYDK9zf3ZM1EP9N\n";
ASSERT_EQ(len, strlen(str1));
ASSERT_EQ(strcmp(buf, str1), 0);
len = MAX_BUF_SIZE;
ASSERT_EQ(BSL_UIO_Gets(uio, buf, &len), BSL_SUCCESS);
const char *str2 = "-----END PUBLIC KEY-----";
ASSERT_EQ(len, strlen(str2));
ASSERT_EQ(strcmp(buf, str2), 0);
EXIT:
BSL_UIO_Free(uio);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/bsl/uio/test_suite_sdv_uio.c
|
C
|
unknown
| 41,731
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
/* BEGIN_HEADER */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <sys/stat.h>
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "cmvp_common.h"
#include "crypt_cmvp.h"
#include "stub_replace.h"
#include "crypt_util_rand.h"
#include "crypt_cmvp_selftest.h"
#include "crypt_eal_cipher.h"
#include "crypt_eal_kdf.h"
#include "crypt_eal_mac.h"
#include "crypt_eal_md.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_rand.h"
#include "crypt_entropy.h"
#include "securec.h"
#include "bsl_errno.h"
#include "crypt_params_key.h"
#include "crypt_hmac.h"
/* END_HEADER */
#define MAX_OUTPUT 200
extern const char *GetIntegrityKey(void);
static void *StdMalloc(uint32_t len)
{
return malloc((size_t)len);
}
static void RegNormalMem(void)
{
BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_MALLOC, StdMalloc);
BSL_SAL_CallBack_Ctrl(BSL_SAL_MEM_FREE, free);
}
static void *STUB_Malloc(uint32_t size)
{
(void)size;
return NULL;
}
static char *Bin2Hex(const uint8_t *input, int length)
{
const int perHexLen = 2;
int rLen = length * perHexLen + 1;
char *result = malloc(rLen);
if (result == NULL) {
return NULL;
}
(void)memset_s(result, rLen, 0, rLen);
for (int i = 0; i < length; i++) {
if (sprintf_s(result + perHexLen * i, rLen, "%02x", input[i]) <= 0) {
free(result);
return NULL;
}
}
result[rLen - 1] = 0;
return result;
}
#define HMAC_SHA256_SIZE 32
static int32_t CmvpHmacTest(const char *key, uint32_t id, uint8_t *buf, uint32_t bufLen, uint8_t *mac, uint32_t *macLen)
{
CRYPT_HMAC_Ctx *hmacCtx = CRYPT_HMAC_NewCtx(id);
if (hmacCtx == NULL) {
return -1;
}
int32_t ret = CRYPT_HMAC_Init(hmacCtx, (uint8_t *)(uintptr_t)key, strlen(key), NULL);
if (ret != CRYPT_SUCCESS) {
CRYPT_HMAC_FreeCtx(hmacCtx);
return ret;
}
ret = CRYPT_HMAC_Update(hmacCtx, buf, bufLen);
if (ret != CRYPT_SUCCESS) {
CRYPT_HMAC_FreeCtx(hmacCtx);
return ret;
}
ret = CRYPT_HMAC_Final(hmacCtx, mac, macLen);
CRYPT_HMAC_FreeCtx(hmacCtx);
return ret;
}
static void CreatIntegrityFile(void)
{
uint32_t bufLen;
char *out = NULL;
FILE *fp = NULL;
uint8_t *buf = (uint8_t *)CMVP_ReadFile("test_suite_sdv_cmvp", "rb", &bufLen);
ASSERT_TRUE(buf != NULL);
uint32_t id;
uint8_t mac[HMAC_SHA256_SIZE];
uint32_t macLen = sizeof(mac);
id = CRYPT_MAC_HMAC_SHA256;
ASSERT_TRUE(CmvpHmacTest(GetIntegrityKey(), id, buf, bufLen, mac, &macLen) == CRYPT_SUCCESS);
out = Bin2Hex(mac, HMAC_SHA256_SIZE);
ASSERT_TRUE(out != NULL);
fp = fopen("test_suite_sdv_cmvp.hmac", "w");
ASSERT_TRUE(fp != NULL);
ASSERT_TRUE(fprintf(fp, "%s%s\n", "HMAC-SHA256(test_suite_sdv_cmvp)= ", out) > 0);
(void)fclose(fp);
EXIT:
free(buf);
free(out);
}
static int CreateFakeIntegrityFile(const char *key, uint32_t id)
{
int ret = 1;
uint32_t bufLen;
char *out = NULL;
FILE *fp = NULL;
uint8_t *buf = (uint8_t *)CMVP_ReadFile("test_suite_sdv_cmvp", "rb", &bufLen);
ASSERT_TRUE(buf != NULL);
uint8_t mac[HMAC_SHA256_SIZE];
uint32_t macLen = sizeof(mac);
ASSERT_TRUE(CmvpHmacTest(key, id, buf, bufLen, mac, &macLen) == CRYPT_SUCCESS);
out = Bin2Hex(mac, HMAC_SHA256_SIZE);
ASSERT_TRUE(out != NULL);
fp = fopen("test_suite_sdv_cmvp.hmac", "w");
ASSERT_TRUE(fp != NULL);
ASSERT_TRUE(fprintf(fp, "%s%s\n", "HMAC-SHA256(test_suite_sdv_cmvp)= ", out) > 0);
(void)fclose(fp);
ret = CRYPT_SUCCESS;
EXIT:
free(buf);
free(out);
return ret;
}
static int FalsifyFile(const char *path)
{
FILE *fp;
char ch;
int ret = 1;
fp = fopen(path, "r+");
ASSERT_TRUE(fp != NULL);
ASSERT_TRUE(fseek(fp, -2, SEEK_END) == 0);
ASSERT_TRUE(fread(&ch, 1, 1, fp) != 0);
ch++;
ASSERT_TRUE(fseek(fp, -2, SEEK_END) == 0);
ASSERT_TRUE(fwrite(&ch, 1, 1, fp) != 0); // 将文件最后一个字节修改
(void)fclose(fp);
ret = CRYPT_SUCCESS;
EXIT:
return ret;
}
static int RecoverFile(const char *path)
{
FILE *fp;
char ch;
int ret = 1;
fp = fopen(path, "r+");
ASSERT_TRUE(fp != NULL);
ASSERT_TRUE(fseek(fp, -2, SEEK_END) == 0);
ASSERT_TRUE(fread(&ch, 1, 1, fp) != 0);
ch--;
ASSERT_TRUE(fseek(fp, -2, SEEK_END) == 0);
ASSERT_TRUE(fwrite(&ch, 1, 1, fp) != 0); // 将文件最后一个字节修改
(void)fclose(fp);
ret = CRYPT_SUCCESS;
EXIT:
return ret;
}
static int CopyFile(const char *src_path)
{
FILE *src_file, *dst_file;
int ret = 1;
char *dst_path = "copy";
char buffer[1024];
size_t bytes_read;
src_file = fopen(src_path, "rb");
if (src_file == NULL) {
return ret;
}
dst_file = fopen(dst_path, "wb");
if (dst_file == NULL) {
fclose(src_file);
return ret;
}
while ((bytes_read = fread(buffer, 1, sizeof(buffer), src_file)) > 0) {
fwrite(buffer, 1, bytes_read, dst_file);
}
fclose(src_file);
fclose(dst_file);
ret = CRYPT_SUCCESS;
return ret;
}
static void ResetStatus(void)
{
CreatIntegrityFile(); // Generating an Integrity Verification File
CRYPT_EAL_RegEventReport(NULL);
}
static void StartTest(void)
{
RegNormalMem();
}
static void ResetStatusAndStartTest(void)
{
ResetStatus();
StartTest();
}
static void EndTest(void)
{
return;
}
/* @
* @test SDV_CRYPTO_CMVP_INTEGRITY_TC002
* @spec -
* @title Integrity verification file error_Integrity verification file missing
* @precon Prepare the test environment.
* @brief
1.CRYPT_CMVP_StatusGet Obtain the error code. Expected result 1 is obtained.
2.Create an asymmetric context. Expected result 2 is obtained.
* @expect
1.return CRYPT_CMVP_ERR_INTEGRITY
2.return NULL
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_INTEGRITY_TC002(void)
{
ResetStatus();
ASSERT_TRUE(remove("test_suite_sdv_cmvp.hmac") == 0);
StartTest();
ASSERT_TRUE(CMVP_CheckIntegrity(NULL, NULL, CRYPT_MAC_HMAC_SHA256) == CRYPT_CMVP_ERR_INTEGRITY);
EXIT:
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_INTEGRITY_TC003
* @spec -
* @title Integrity verification file error_Integrity verification file is falsified.
* @precon Prepare the test environment.
* @brief
1.CRYPT_CMVP_StatusGet Obtain the error code. Expected result 1 is obtained.
2.Create an asymmetric context. Expected result 2 is obtained.
* @expect
1.return CRYPT_CMVP_ERR_INTEGRITY
2.return NULL
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_INTEGRITY_TC003(void)
{
ResetStatus();
ASSERT_TRUE(FalsifyFile("test_suite_sdv_cmvp.hmac") == 0);
StartTest();
ASSERT_TRUE(CMVP_CheckIntegrity(NULL, NULL, CRYPT_MAC_HMAC_SHA256) == CRYPT_CMVP_ERR_INTEGRITY);
EXIT:
RecoverFile("test_suite_sdv_cmvp.hmac");
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_INTEGRITY_TC004
* @spec -
* @title Integrity verification file error_Integrity verification file is generated with incorrect Mac key
* @precon Prepare the test environment.
* @brief
1.CRYPT_CMVP_StatusGet Obtain the error code. Expected result 1 is obtained.
2.Create an asymmetric context. Expected result 2 is obtained.
* @expect
1.return CRYPT_CMVP_ERR_INTEGRITY
2.return NULL
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_INTEGRITY_TC004(void)
{
const char fake_key[] = "a8fc4931453af3285f0f";
ResetStatus();
ASSERT_TRUE(CreateFakeIntegrityFile(fake_key, CRYPT_MAC_HMAC_SHA256) == 0);
StartTest();
ASSERT_TRUE(CMVP_CheckIntegrity(NULL, NULL, CRYPT_MAC_HMAC_SHA256) == CRYPT_CMVP_ERR_INTEGRITY);
EXIT:
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_INTEGRITY_TC005
* @spec -
* @title Integrity verification file error_Integrity verification file is generated using an incorrect algorithm
* @precon Prepare the test environment.
* @brief
1.CRYPT_CMVP_StatusGet Obtain the error code. Expected result 1 is obtained.
2.Create an asymmetric context. Expected result 2 is obtained.
* @expect
1.return CRYPT_CMVP_ERR_INTEGRITY
2.return NULL
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_INTEGRITY_TC005(void)
{
const char key[] = "b8fc4931453af3285f0f";
ResetStatus();
ASSERT_TRUE(CreateFakeIntegrityFile(key, CRYPT_MAC_HMAC_SHA3_256) == 0);
StartTest();
ASSERT_TRUE(CMVP_CheckIntegrity(NULL, NULL, CRYPT_MAC_HMAC_SHA256) == CRYPT_CMVP_ERR_INTEGRITY);
EXIT:
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_INTEGRITY_TC006
* @spec -
* @title Integrity verification file error_"test_suite_sdv_cmvp" file missing
* @precon Prepare the test environment.
* @brief
1.CRYPT_CMVP_StatusGet Obtain the error code. Expected result 1 is obtained.
2.Create an asymmetric context. Expected result 2 is obtained.
* @expect
1.return CRYPT_CMVP_ERR_INTEGRITY
2.return NULL
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_INTEGRITY_TC006(void)
{
ResetStatus();
ASSERT_TRUE(CopyFile("test_suite_sdv_cmvp") == 0);
ASSERT_TRUE(remove("test_suite_sdv_cmvp") == 0);
StartTest();
ASSERT_TRUE(CMVP_CheckIntegrity(NULL, NULL, CRYPT_MAC_HMAC_SHA256) == CRYPT_CMVP_ERR_INTEGRITY);
EXIT:
ASSERT_TRUE(rename("copy", "test_suite_sdv_cmvp") == 0);
ASSERT_TRUE(chmod("test_suite_sdv_cmvp", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) == 0);
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_INTEGRITY_TC001
* @spec -
* @title Integrity verification file is correct_Integrity verification file
* @precon nan
* @brief
1.CRYPT_CMVP_StatusGet Obtain the error code. Expected result 1 is obtained.
2.Create an asymmetric context. Expected result 2 is obtained.
* @expect
1.return CRYPT_SUCCESS
2.return no NULL
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_INTEGRITY_TC001(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CMVP_CheckIntegrity(NULL, NULL, CRYPT_MAC_HMAC_SHA256) == CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC001
* @spec -
* @title MAC Algorithm self-check, Algorithm id
* @precon nan
* @brief
1.Register Memory Management
2.Transfer CRYPT_MAC_HMAC_SHA1 to perform algorithm self-check. Expected result 2 is obtained.
3.Transfer CRYPT_MAC_HMAC_SHA224 to perform algorithm self-check. Expected result 3 is obtained.
4.Transfer CRYPT_MAC_HMAC_SHA256 to perform algorithm self-check. Expected result 4 is obtained.
5.Transfer CRYPT_MAC_HMAC_SHA384 to perform algorithm self-check. Expected result 5 is obtained.
6.Transfer CRYPT_MAC_HMAC_SHA512 to perform algorithm self-check. Expected result 6 is obtained.
7.Transfer CRYPT_MAC_MAX to perform algorithm self-check. Expected result 7 is obtained.
8.Transfer -1 to perform algorithm self-check. Expected result 8 is obtained.
* @expect
1.none 2.return true 3.return true
4.return true 5.return true 6.return true
7.return true 8.return true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC001(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_HMAC_SM3) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_CMAC_AES128) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_CMAC_AES192) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_CMAC_AES256) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_HMAC_SHA1) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_HMAC_SHA224) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_HMAC_SHA256) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_HMAC_SHA384) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_HMAC_SHA512) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_GMAC_AES128) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_GMAC_AES192) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_GMAC_AES256) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_MAX) == false);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(-1) == false);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC010
* @spec -
* @title MD Algorithm self-check. Indicates whether the ID is valid.
* @precon nan
* @brief
1.Register the memory management callback function. Expected result 1 is obtained.
3.Transfer CRYPT_MD_MD5 to perform algorithm self-check. Expected result 2 is obtained.
3.Transfer CRYPT_MD_SHA1 to perform algorithm self-check. Expected result 3 is obtained.
4.Transfer CRYPT_MD_SHA224 to perform algorithm self-check. Expected result 4 is obtained.
5.Transfer CRYPT_MD_SHA256 to perform algorithm self-check. Expected result 5 is obtained.
6.Transfer CRYPT_MD_SHA384 to perform algorithm self-check. Expected result 6 is obtained.
7.Transfer CRYPT_MD_SHA512 to perform algorithm self-check. Expected result 7 is obtained.
8.Transfer CRYPT_MD_SHA3_224 to perform algorithm self-check. Expected result 8 is obtained.
9.Transfer CRYPT_MD_SHA3_256 to perform algorithm self-check. Expected result 9 is obtained.
10.Transfer CRYPT_MD_SHA3_384 to perform algorithm self-check. Expected result 10 is obtained.
11.Transfer CRYPT_MD_SHA3_512 to perform algorithm self-check. Expected result 111 is obtained.
12.Transfer CRYPT_MD_SM3 to perform algorithm self-check. Expected result 12 is obtained.
13.Transfer CRYPT_MD_MAX to perform algorithm self-check. Expected result 13 is obtained.
14.Transfer -1 to perform algorithm self-check. Expected result 14 is obtained.
* @expect
1.none 2.return false 3.return true
4.return true 5.return true 6.return true
7.return true 8.return true 9.return true
10.return true 11.return true 12.return false
13.return false 14.return false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC010(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SM3) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_MD5) == false);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHA1) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHA224) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHA256) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHA384) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHA512) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHA3_224) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHA3_256) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHA3_384) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHA3_512) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHAKE128) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHAKE256) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_MAX) == false);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(-1) == false);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC019
* @spec -
* @title DRBG Algorithm self-check. Indicates whether the ID is valid.
* @precon Prepare the test environment.
* @brief
1.Register the memory management callback function. Expected result 1 is obtained.
2.Transfer CRYPT_RAND_AES128_CTR_DF to perform algorithm self-check. Expected result 2 is obtained.
3.Transfer CRYPT_RAND_AES192_CTR_DF to perform algorithm self-check. Expected result 3 is obtained.
4.Transfer CRYPT_RAND_AES256_CTR_DF to perform algorithm self-check. Expected result 4 is obtained.
5.Transfer CRYPT_RAND_AES128_CTR to perform algorithm self-check. Expected result 5 is obtained.
6.Transfer CRYPT_RAND_AES192_CTR to perform algorithm self-check. Expected result 6 is obtained.
7.Transfer CRYPT_RAND_AES256_CTR to perform algorithm self-check. Expected result 7 is obtained.
8.Transfer CRYPT_RAND_HMAC_SHA1 to perform algorithm self-check. Expected result 8 is obtained.
9.Transfer CRYPT_RAND_HMAC_SHA224 to perform algorithm self-check. Expected result 9 is obtained.
10.Transfer CRYPT_RAND_HMAC_SHA256 to perform algorithm self-check. Expected result 10 is obtained.
11.Transfer CRYPT_RAND_HMAC_SHA384 to perform algorithm self-check. Expected result 11 is obtained.
12.Transfer CRYPT_RAND_HMAC_SHA512 to perform algorithm self-check. Expected result 12 is obtained.
13.Transfer CRYPT_RAND_SHA1 to perform algorithm self-check. Expected result 13 is obtained.
14.Transfer CRYPT_RAND_SHA224 to perform algorithm self-check. Expected result 14 is obtained.
15.Transfer CRYPT_RAND_SHA256 to perform algorithm self-check. Expected result 15 is obtained.
16.Transfer CRYPT_RAND_SHA384 to perform algorithm self-check. Expected result 16 is obtained.
17.Transfer CRYPT_RAND_SHA512 to perform algorithm self-check. Expected result 17 is obtained.
18.Transfer CRYPT_RAND_ALGID_MAX to perform algorithm self-check. Expected result 18 is obtained.
19.Transfer -1 to perform algorithm self-check. Expected result 19 is obtained.
* @expect
1.none
2.return true 3.return true 4.return true 5.return true
6.return true 7.return true 8.return true 9.return true
10.return true 11.return true 12.return true 13.return true
14.return true 15.return true 16.return true 17.return true
18.return false 19.return false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC019(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_AES128_CTR_DF) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_AES192_CTR_DF) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_AES256_CTR_DF) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_SM4_CTR_DF) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_AES128_CTR) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_AES192_CTR) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_AES256_CTR) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_HMAC_SHA1) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_HMAC_SHA224) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_HMAC_SHA256) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_HMAC_SHA384) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_HMAC_SHA512) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_SHA1) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_SHA224) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_SHA256) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_SHA384) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_SHA512) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_SM3) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_ALGID_MAX) == false);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(-1) == false);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC035
* @spec -
* @title SM2 Algorithm self-check.
* @precon nan
* @brief
1.Register the memory management callback function. Expected result 1 is obtained.
2.Perform SM2 algorithm self-check. Expected result 2 is obtained.
* @expect
1.none
2.return true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC035(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestSM2() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC036
* @spec -
* @title RSA Algorithm self-check.
* @precon nan
* @brief
1.Register the memory management callback function. Expected result 1 is obtained.
2.Perform RSA algorithm self-check. Expected result 2 is obtained.
* @expect
1.none
2.return true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC036(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestRsa() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC037
* @spec -
* @title 内存管理已注册_内存管理是否注册_20220523171150526
* @precon nan
* @brief 1.注册内存管理回调,有预期结果1
2.执行算法自检,有预期结果2
* @expect 1.返回BSL_SUCCESS
2.返回true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC037(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_SM4_CBC) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_SM4_XTS) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_SM4_ECB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_SM4_CTR) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_SM4_GCM) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_SM4_CFB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_SM4_OFB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES128_CBC) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES192_CBC) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES256_CBC) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES128_CTR) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES192_CTR) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES256_CTR) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES128_ECB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES192_ECB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES256_ECB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES128_XTS) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES256_XTS) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES128_CCM) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES192_CCM) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES256_CCM) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES128_GCM) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES192_GCM) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES256_GCM) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES128_CFB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES192_CFB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES256_CFB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES128_OFB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES192_OFB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES256_OFB) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_CHACHA20_POLY1305) == false);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_MAX) == false);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(-1) == false);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC038
* @spec -
* @title 内存管理已注册_内存管理是否注册_20220523171311299
* @precon nan
* @brief 1.注册内存管理回调,有预期结果1
2.执行算法自检,有预期结果2
* @expect 1.返回BSL_SUCCESS
2.返回true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC038(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestChacha20poly1305() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC039
* @spec -
* @title 内存管理已注册_内存管理是否注册_20220523171322795
* @precon 准备好测试环境
* @brief 1.注册内存管理回调,有预期结果1
2.执行算法自检,有预期结果2
* @expect 1.返回BSL_SUCCESS
2.返回true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC039(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestDh() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC040
* @spec -
* @title 内存管理已注册_内存管理是否注册_20220523171331230
* @precon nan
* @brief 1.注册内存管理回调,有预期结果1
2.执行算法自检,有预期结果2
* @expect 1.返回BSL_SUCCESS
2.返回true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC040(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestDsa() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC041
* @spec -
* @title 内存管理已注册_内存管理是否注册_20220523171347201
* @precon 准备好测试环境
* @brief 1.注册内存管理回调,有预期结果1
2.执行算法自检,有预期结果2
* @expect 1.返回BSL_SUCCESS
2.返回true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC041(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestEd25519() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC042
* @spec -
* @title 内存管理已注册_内存管理是否注册_20220523171421887
* @precon nan
* @brief 1.注册内存管理回调,有预期结果1
* 2.执行Hkdf算法自检,有预期结果2
* 3.执行Pbkdf2算法自检,有预期结果3
* 4.执行Scrypt算法自检,有预期结果4
* @expect 1.返回BSL_SUCCESS
2.返回true 3.返回true 4.返回true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC042(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestHkdf() == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestPbkdf2(CRYPT_MAC_HMAC_SHA1) == true);
ASSERT_TRUE(CRYPT_CMVP_SelftestScrypt() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC043
* @spec -
* @title 内存管理已注册_内存管理是否注册_20220523171421887
* @precon nan
* @brief 1.注册内存管理回调,有预期结果1
* 2.执行KdfTls12算法自检,有预期结果2
* @expect 1.无
2.返回true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC043(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestKdfTls12() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC045
* @spec -
* @title X25519算法自检
* @precon nan
* @brief 1.注册内存管理回调,有预期结果1
2.执行算法自检,有预期结果2
* @expect 1.返回BSL_SUCCESS
2.返回true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC045(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestX25519() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC046
* @spec -
* @title 内存管理未注册_内存是否注册_20220523171100467
* @precon nan
* @brief 1.传入CRYPT_RAND_AES256_CTR_DF执行算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC046(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_AES256_CTR_DF) == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC047
* @spec -
* @title 内存管理未注册_内存管理回调是否注册_20220523171144681
* @precon 准备好测试环境
* @brief 1.传入CRYPT_MD_SHA256执行算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC047(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestMd(CRYPT_MD_SHA256) == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC048
* @spec -
* @title 内存管理未注册_内存管理是否已注册_20220523171355210
* @precon nan
* @brief 1.执行算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC048(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestRsa() == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC049
* @spec -
* @title 内存管理未注册_内存管理是否注册_20220523171153018
* @precon nan
* @brief 1.执行算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC049(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES128_CBC) == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC050
* @spec -
* @title 内存管理未注册_内存管理是否注册_20220523171318396
* @precon nan
* @brief 1.执行算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC050(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestChacha20poly1305() == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC051
* @spec -
* @title 内存管理未注册_内存管理是否注册_20220523171325201
* @precon nan
* @brief 1.执行算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC051(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestDh() == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC052
* @spec -
* @title 内存管理未注册_内存管理是否注册_20220523171333044
* @precon nan
* @brief 1.执行算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC052(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestDsa() == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC053
* @spec -
* @title 内存管理未注册_内存管理是否注册_20220523171349655
* @precon nan
* @brief 1.执行算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC053(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestEd25519() == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC054
* @spec -
* @title 内存管理未注册_内存管理是否注册_20220523171358066
* @precon 准备好测试环境
* @brief 1.执行Hkdf算法自检,有预期结果1
* 2.执行Pbkdf2算法自检,有预期结果2
* 3.执行Scrypt算法自检,有预期结果3
* @expect 1.返回false 2.返回false 3.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC054(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestHkdf() == false);
ASSERT_TRUE(CRYPT_CMVP_SelftestPbkdf2(CRYPT_MAC_HMAC_SHA1) == false);
ASSERT_TRUE(CRYPT_CMVP_SelftestScrypt() == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC057
* @spec -
* @title 内存管理未注册_内存管理是否注册_20220523171435826
* @precon nan
* @brief 1.执行算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC057(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestX25519() == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC058(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestMac(CRYPT_MAC_HMAC_SHA256) == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC059
* @spec -
* @title ECDSA算法自检
* @precon nan
* @brief 1.执行算法自检,有预期结果1
* @expect 1.返回true
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC059(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestEcdsa() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC060
* @spec -
* @title ECDH算法自检
* @precon nan
* @brief 1.执行算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC060(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestEcdh() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC062
* @spec -
* @title 内存管理未注册_内存管理是否注册
* @precon nan
* @brief 1.执行TDES算法自检,有预期结果1
* @expect 1.返回false
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC062(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
STUB_Replace(&tmpStubInfo, BSL_SAL_Malloc, STUB_Malloc);
ASSERT_TRUE(CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AES128_CBC) == false);
EXIT:
STUB_Reset(&tmpStubInfo);
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC063
* @spec -
* @title CMVP test for MLDSA
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC063(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestMldsaSignVerify() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC064
* @spec -
* @title CMVP test for MLKEM
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC064(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestMlkemEncapsDecaps() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_CMVP_SELFTEST_TC065
* @spec -
* @title CMVP test for SLHDSA
* @precon nan
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_CMVP_SELFTEST_TC065(void)
{
ResetStatusAndStartTest();
ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_CMVP_SelftestSlhdsaSignVerify() == true);
EXIT:
CRYPT_EAL_RandDeinit();
EndTest();
}
/* END_CASE */
#endif
|
2301_79861745/bench_create
|
testcode/sdv/testcase/cmvp/test_suite_sdv_cmvp.c
|
C
|
unknown
| 39,979
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_list.h"
#include "bsl_err_internal.h"
#include "sal_file.h"
#include "crypt_errno.h"
#include "crypt_eal_provider.h"
#include "crypt_eal_implprovider.h"
#include "crypt_provider.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_codecs.h"
#include "bsl_types.h"
#include "crypt_types.h"
#include "crypt_utils.h"
#include "decode_local.h"
#include "test.h"
#include "stub_replace.h"
/* END_HEADER */
void *malloc_fail(uint32_t size)
{
(void)size;
return NULL;
}
/**
* @test SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC001
* @brief Test CRYPT_DECODE_ProviderNewCtx API
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC001(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
TestMemInit();
CRYPT_DECODER_Ctx *ctx = NULL;
ctx = CRYPT_DECODE_ProviderNewCtx(NULL, BSL_CID_DECODE_UNKNOWN, "provider=default, inFormat=PEM, outFormat=ASN1");
ASSERT_TRUE(ctx != NULL);
CRYPT_DECODE_Free(ctx);
ctx = NULL;
CRYPT_DECODE_Free(NULL);
/* Test with NULL libCtx */
ctx = CRYPT_DECODE_ProviderNewCtx(NULL, CRYPT_PKEY_RSA, NULL);
ASSERT_TRUE(ctx != NULL);
CRYPT_DECODE_Free(ctx);
ctx = NULL;
/* Test with invalid key type */
ctx = CRYPT_DECODE_ProviderNewCtx(NULL, -1, NULL);
ASSERT_TRUE(ctx == NULL);
/* Test with valid parameters */
ctx = CRYPT_DECODE_ProviderNewCtx(NULL, BSL_CID_DECODE_UNKNOWN, "provider=default, inFormat=PEM, outFormat=ASN1");
ASSERT_TRUE(ctx != NULL);
CRYPT_DECODE_Free(ctx);
ctx = NULL;
ctx = CRYPT_DECODE_ProviderNewCtx(NULL, BSL_CID_DECODE_UNKNOWN, "provider?default, inFormat?PEM");
ASSERT_TRUE(ctx != NULL);
CRYPT_DECODE_Free(ctx);
ctx = NULL;
ctx = CRYPT_DECODE_ProviderNewCtx(NULL, CRYPT_PKEY_RSA, "provider=default, inFormat=PEM, outFormat=ASN1");
ASSERT_TRUE(ctx == NULL);
ctx = CRYPT_DECODE_ProviderNewCtx(NULL, CRYPT_PKEY_RSA, "provider=default, inFormat=ASN1, inType=PRIKEY_RSA");
ASSERT_TRUE(ctx != NULL);
CRYPT_DECODE_Free(ctx);
ctx = NULL;
EXIT:
CRYPT_DECODE_Free(ctx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC002
* @brief When no provider is loaded, CRYPT_DECODE_ProviderNewCtx should return NULL
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC002(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
CRYPT_DECODER_Ctx *ctx = NULL;
CRYPT_EAL_LibCtx *libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
ctx = CRYPT_DECODE_ProviderNewCtx(libCtx, CRYPT_PKEY_RSA, "provider=default, inFormat=ASN1, inType=PRIKEY_RSA");
ASSERT_TRUE(ctx == NULL);
EXIT:
CRYPT_EAL_LibCtxFree(libCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC002
* @brief When user provider no decoder implement, CRYPT_DECODE_ProviderNewCtx should return NULL
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_PROVIDER_NEW_CTX_API_TC003(char *providerPath, char *providerName, int cmd, int keyType)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)providerPath;
(void)providerName;
(void)cmd;
(void)keyType;
SKIP_TEST();
#else
CRYPT_DECODER_Ctx *ctx = NULL;
CRYPT_EAL_LibCtx *libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, providerPath), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, cmd, providerName, NULL, NULL), CRYPT_SUCCESS);
ctx = CRYPT_DECODE_ProviderNewCtx(libCtx, keyType, NULL);
ASSERT_TRUE(ctx == NULL);
EXIT:
CRYPT_EAL_LibCtxFree(libCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_SET_PARAM_API_TC001
* @brief Test CRYPT_DECODE_SetParam API
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_SET_PARAM_API_TC001(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
CRYPT_DECODER_Ctx *ctx = NULL;
/* Test with NULL ctx */
BSL_Param param = {0};
ASSERT_EQ(CRYPT_DECODE_SetParam(NULL, ¶m), CRYPT_NULL_INPUT);
ctx = CRYPT_DECODE_ProviderNewCtx(NULL, CRYPT_PKEY_RSA, "provider=default, inFormat=ASN1, inType=PRIKEY_RSA");
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_DECODE_SetParam(ctx, NULL), CRYPT_NULL_INPUT);
ctx->method->setParam = NULL;
ASSERT_EQ(CRYPT_DECODE_SetParam(ctx, ¶m), CRYPT_NOT_SUPPORT);
EXIT:
CRYPT_DECODE_Free(ctx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_GET_PARAM_API_TC001
* @brief Test CRYPT_DECODE_GetParam API
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_GET_PARAM_API_TC001(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
CRYPT_DECODER_Ctx *ctx = CRYPT_DECODE_ProviderNewCtx(NULL, CRYPT_PKEY_RSA, "provider=default, inFormat=ASN1, inType=PRIKEY_RSA");
ASSERT_TRUE(ctx != NULL);
/* Test with NULL ctx */
BSL_Param param = {0};
int32_t ret = CRYPT_DECODE_GetParam(NULL, ¶m);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
ret = CRYPT_DECODE_GetParam(ctx, NULL);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
ctx->method->getParam = NULL;
ret = CRYPT_DECODE_GetParam(ctx, ¶m);
ASSERT_EQ(ret, CRYPT_NOT_SUPPORT);
EXIT:
CRYPT_DECODE_Free(ctx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_DECODE_API_TC001
* @title Test CRYPT_DECODE_Decode API
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_DECODE_API_TC001(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
CRYPT_DECODER_Ctx *ctx = CRYPT_DECODE_ProviderNewCtx(NULL, BSL_CID_DECODE_UNKNOWN, "provider=default, inFormat=PEM, outFormat=ASN1");
ASSERT_TRUE(ctx != NULL);
/* Test with NULL ctx */
BSL_Param inParam[2] = {0};
BSL_Param *outParam = NULL;
int32_t ret = CRYPT_DECODE_Decode(NULL, inParam, &outParam);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
/* Test with NULL inParam */
ret = CRYPT_DECODE_Decode(ctx, NULL, &outParam);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
/* Test with NULL outParam */
ret = CRYPT_DECODE_Decode(ctx, inParam, NULL);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
/* Test with NULL decode function */
ctx->method->decode = NULL;
ret = CRYPT_DECODE_Decode(ctx, inParam, &outParam);
ASSERT_EQ(ret, CRYPT_NOT_SUPPORT);
EXIT:
CRYPT_DECODE_Free(ctx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_DECODE_API_TC002
* @title Test CRYPT_DECODE_Decode API with valid parameters,
* Test with valid PEM to ASN1 conversion
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_DECODE_API_TC002(char *pemPath, char *asn1Path)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)pemPath;
(void)asn1Path;
SKIP_TEST();
#else
CRYPT_DECODER_Ctx *ctx = CRYPT_DECODE_ProviderNewCtx(NULL, BSL_CID_DECODE_UNKNOWN, "provider=default, inFormat=PEM, outFormat=ASN1");
ASSERT_TRUE(ctx != NULL);
/* Test with valid PEM to ASN1 conversion */
uint8_t *pemData = NULL;
uint32_t pemDataLen = 0;
uint8_t *asn1Data = NULL;
uint32_t asn1DataLen = 0;
ASSERT_EQ(BSL_SAL_ReadFile(pemPath, &pemData, &pemDataLen), BSL_SUCCESS);
BSL_Param inParam[2] = {
{CRYPT_PARAM_DECODE_BUFFER_DATA, BSL_PARAM_TYPE_OCTETS, pemData, pemDataLen, 0},
BSL_PARAM_END
};
BSL_Param *outParam = NULL;
ASSERT_EQ(CRYPT_DECODE_Decode(ctx, inParam, &outParam), CRYPT_SUCCESS);
ASSERT_TRUE(outParam != NULL);
ASSERT_TRUE(outParam->value != NULL);
ASSERT_TRUE(outParam->valueLen > 0);
ASSERT_EQ(BSL_SAL_ReadFile(asn1Path, &asn1Data, &asn1DataLen), BSL_SUCCESS);
ASSERT_EQ(outParam->valueLen, asn1DataLen);
ASSERT_EQ(memcmp(outParam->value, asn1Data, asn1DataLen), 0);
EXIT:
BSL_SAL_Free(pemData);
BSL_SAL_Free(asn1Data);
if (outParam != NULL) {
CRYPT_DECODE_FreeOutData(ctx, outParam);
}
CRYPT_DECODE_Free(ctx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_FREE_OUT_DATA_API_TC001
* @title Test CRYPT_DECODE_FreeOutData API
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_FREE_OUT_DATA_API_TC001(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
/* Test with NULL ctx */
BSL_Param outData = {0};
CRYPT_DECODE_FreeOutData(NULL, &outData);
/* Test with NULL outData */
CRYPT_DECODER_Ctx *ctx = CRYPT_DECODE_ProviderNewCtx(NULL, BSL_CID_DECODE_UNKNOWN, "provider=default, inFormat=PEM, outFormat=ASN1");
ASSERT_TRUE(ctx != NULL);
CRYPT_DECODE_FreeOutData(ctx, NULL);
ctx->method->freeOutData = NULL;
CRYPT_DECODE_FreeOutData(ctx, &outData);
EXIT:
CRYPT_DECODE_Free(ctx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_POOL_NEW_CTX_API_TC001
* @title Test CRYPT_DECODE_PoolNewCtx API
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_POOL_NEW_CTX_API_TC001(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
FuncStubInfo tmpRpInfo = {0};
CRYPT_DECODER_PoolCtx *poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
ASSERT_TRUE(poolCtx != NULL);
CRYPT_DECODE_PoolFreeCtx(poolCtx);
poolCtx = NULL;
CRYPT_DECODE_PoolFreeCtx(NULL);
/* Test with malloc failed */
STUB_Init();
ASSERT_TRUE(STUB_Replace(&tmpRpInfo, BSL_SAL_Malloc, malloc_fail) == 0);
TestMemInit();
poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
ASSERT_TRUE(poolCtx == NULL);
EXIT:
STUB_Reset(&tmpRpInfo);
CRYPT_DECODE_PoolFreeCtx(poolCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_POOL_DECODE_API_TC001
* @title Test CRYPT_DECODE_PoolDecode API with invalid parameters
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_POOL_DECODE_API_TC001(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
CRYPT_DECODER_PoolCtx *poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
ASSERT_TRUE(poolCtx != NULL);
/* Test with NULL poolCtx */
BSL_Param inParam[2] = {0};
BSL_Param *outParam = NULL;
ASSERT_EQ(CRYPT_DECODE_PoolDecode(NULL, inParam, &outParam), CRYPT_NULL_INPUT);
/* Test with NULL inParam */
ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, NULL, &outParam), CRYPT_NULL_INPUT);
/* Test with NULL outParam */
ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, inParam, NULL), CRYPT_NULL_INPUT);
/* Test with invalid outParam */
outParam = inParam;
ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, inParam, &outParam), CRYPT_INVALID_ARG);
/* Test with invalid input data */
uint8_t invalidData[] = "Invalid PEM data";
inParam[0].valueType = BSL_PARAM_TYPE_OCTETS;
inParam[0].value = invalidData;
inParam[0].valueLen = sizeof(invalidData);
ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, inParam, &outParam), CRYPT_DECODE_ERR_NO_USABLE_DECODER);
EXIT:
CRYPT_DECODE_PoolFreeCtx(poolCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_POOL_DECODE_API_TC002
* @title Test CRYPT_DECODE_PoolDecode API with valid parameters
* @precon None
* @brief
* 1. Test with valid parameters
* 2. Test with valid PEM to ASN1 conversion
* @expect
* 1. Return CRYPT_SUCCESS
* 2. Return CRYPT_SUCCESS and output data matches expected
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_POOL_DECODE_API_TC002(char *inputFormat, char *inputType, char *path, char *targetFormat,
char *targetType, char *targetPath)
{
#ifndef HITLS_CRYPTO_PROVIDER
(void)inputFormat;
(void)inputType;
(void)path;
(void)targetFormat;
(void)targetType;
(void)targetPath;
SKIP_TEST();
#else
if (strcmp(inputFormat, "NULL") == 0) {
inputFormat = NULL;
}
if (strcmp(inputType, "NULL") == 0) {
inputType = NULL;
}
CRYPT_DECODER_PoolCtx *poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, BSL_CID_DECODE_UNKNOWN, inputFormat, inputType);
ASSERT_TRUE(poolCtx != NULL);
/* Test with valid PEM to ASN1 conversion */
uint8_t *inputData = NULL;
uint32_t inputDataLen = 0;
uint8_t *outputData = NULL;
uint32_t outputDataLen = 0;
bool isFreeOutData = true;
ASSERT_EQ(BSL_SAL_ReadFile(path, &inputData, &inputDataLen), BSL_SUCCESS);
BSL_Param inParam[2] = {
{CRYPT_PARAM_DECODE_BUFFER_DATA, BSL_PARAM_TYPE_OCTETS, inputData, inputDataLen, 0},
BSL_PARAM_END
};
BSL_Param *outParam = NULL;
/* Set target format and type */
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_FORMAT, targetFormat,
strlen(targetFormat)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_TYPE, targetType,
strlen(targetType)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, inParam, &outParam), CRYPT_SUCCESS);
ASSERT_TRUE(outParam != NULL);
ASSERT_TRUE(outParam->value != NULL);
ASSERT_TRUE(outParam->valueLen > 0);
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA, &isFreeOutData,
sizeof(bool)), CRYPT_SUCCESS);
if (outParam->key == CRYPT_PARAM_DECODE_BUFFER_DATA) {
ASSERT_EQ(BSL_SAL_ReadFile(targetPath, &outputData, &outputDataLen), BSL_SUCCESS);
ASSERT_EQ(outParam->valueLen, outputDataLen);
ASSERT_EQ(memcmp(outParam->value, outputData, outputDataLen), 0);
} else if (outParam->key == CRYPT_PARAM_DECODE_OBJECT_DATA) {
ASSERT_NE(outParam->value, NULL);
}
EXIT:
BSL_SAL_Free(inputData);
BSL_SAL_Free(outputData);
CRYPT_DECODE_PoolFreeCtx(poolCtx);
#endif
}
/* END_CASE */
/**
* @test SDV_CRYPT_DECODE_POOL_CTRL_API_TC001
* @title Test CRYPT_DECODE_PoolCtrl API with valid parameters and boundary conditions
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_POOL_CTRL_API_TC001(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
CRYPT_DECODER_PoolCtx *poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
ASSERT_TRUE(poolCtx != NULL);
/* Test setting target format */
const char *targetFormat = "ASN1";
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_FORMAT, (void *)targetFormat,
strlen(targetFormat)), CRYPT_SUCCESS);
ASSERT_EQ(poolCtx->targetFormat, targetFormat);
/* Test setting target type */
const char *targetType = "PRIKEY_RSA";
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_TYPE, (void *)targetType,
strlen(targetType)), CRYPT_SUCCESS);
ASSERT_EQ(poolCtx->targetType, targetType);
/* Test setting free output data flag */
bool isFreeOutData = true;
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA, &isFreeOutData,
sizeof(bool)), CRYPT_SUCCESS);
/* Test with invalid format length */
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_FORMAT, (void *)targetFormat,
MAX_CRYPT_DECODE_FORMAT_TYPE_SIZE + 1), CRYPT_INVALID_ARG);
/* Test with invalid type length */
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_TYPE, (void *)targetType,
MAX_CRYPT_DECODE_FORMAT_TYPE_SIZE + 1), CRYPT_INVALID_ARG);
/* Test with invalid flag size */
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA, &isFreeOutData,
sizeof(bool) + 1), CRYPT_INVALID_ARG);
/* Test with invalid command */
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, 0xFFFFFFFF, &isFreeOutData, sizeof(bool)), CRYPT_INVALID_ARG);
EXIT:
CRYPT_DECODE_PoolFreeCtx(poolCtx);
#endif
}
/* END_CASE */
#ifdef HITLS_CRYPTO_PROVIDER
static void FreeDecoderNode(CRYPT_DECODER_Node *decoderNode)
{
if (decoderNode == NULL) {
return;
}
CRYPT_DECODE_FreeOutData(decoderNode->decoderCtx, decoderNode->outData.data);
BSL_SAL_Free(decoderNode);
}
#endif
/**
* @test SDV_CRYPT_DECODE_POOL_CTRL_API_TC002
* @title Test CRYPT_DECODE_PoolCtrl CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA with valid parameters and boundary
* conditions
* @precon None
*/
/* BEGIN_CASE */
void SDV_CRYPT_DECODE_POOL_CTRL_API_TC002(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
BSL_Param *outParam = NULL;
bool isFreeOutData = true;
uint8_t *inputData = NULL;
uint32_t inputDataLen = 0;
CRYPT_DECODER_PoolCtx *poolCtx = NULL;
ASSERT_EQ(BSL_SAL_ReadFile("../testdata/cert/asn1/rsa2048key_pkcs1.pem", &inputData, &inputDataLen), BSL_SUCCESS);
BSL_Param inParam[2] = {
{CRYPT_PARAM_DECODE_BUFFER_DATA, BSL_PARAM_TYPE_OCTETS, inputData, inputDataLen, 0},
BSL_PARAM_END
};
poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
ASSERT_TRUE(poolCtx != NULL);
/* Manually clear the decoder path to simulate no nodes condition */
if (poolCtx->decoderPath != NULL) {
BSL_LIST_FREE(poolCtx->decoderPath, (BSL_LIST_PFUNC_FREE)FreeDecoderNode);
}
/* Now test the control operation with empty decoder path */
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA,
&isFreeOutData, sizeof(bool)), CRYPT_INVALID_ARG);
CRYPT_DECODE_PoolFreeCtx(poolCtx);
poolCtx = NULL;
/* Test when decoderPath has only one node (input equals output) */
poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
ASSERT_TRUE(poolCtx != NULL);
const char *targetFormat = "PEM";
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_FORMAT, (void *)targetFormat,
strlen(targetFormat)), CRYPT_SUCCESS);
ASSERT_EQ(poolCtx->targetFormat, targetFormat);
const char *targetType = "PRIKEY_RSA";
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_TYPE, (void *)targetType,
strlen(targetType)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, inParam, &outParam), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA,
&isFreeOutData, sizeof(bool)), CRYPT_SUCCESS);
CRYPT_DECODE_PoolFreeCtx(poolCtx);
poolCtx = NULL;
outParam = NULL;
/* Test isFreeOutData is false */
poolCtx = CRYPT_DECODE_PoolNewCtx(NULL, NULL, CRYPT_PKEY_RSA, "PEM", "PRIKEY_RSA");
ASSERT_TRUE(poolCtx != NULL);
targetFormat = "ASN1";
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_FORMAT, (void *)targetFormat,
strlen(targetFormat)), CRYPT_SUCCESS);
targetType = "PRIKEY_RSA";
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_TYPE, (void *)targetType,
strlen(targetType)), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_DECODE_PoolDecode(poolCtx, inParam, &outParam), CRYPT_SUCCESS);
isFreeOutData = false;
ASSERT_EQ(CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA,
&isFreeOutData, sizeof(bool)), CRYPT_SUCCESS);
BSL_SAL_FREE(outParam->value);
BSL_SAL_FREE(outParam);
EXIT:
BSL_SAL_Free(inputData);
CRYPT_DECODE_PoolFreeCtx(poolCtx);
#endif
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/codecs/decode/test_suite_sdv_decode.c
|
C
|
unknown
| 19,766
|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/* BEGIN_HEADER */
#include <pthread.h>
#include "crypt_errno.h"
#include "crypt_eal_cipher.h"
#include "eal_cipher_local.h"
#include "modes_local.h"
#include "bsl_sal.h"
#include "securec.h"
#define MAX_OUTPUT 5000
#define MCT_INNER_LOOP 1000
#define AES_BLOCKSIZE 16
#define MAX_DATA_LEN 1024
#define AES_TAG_LEN 16
static void Test_CipherOverLap(int algId, Hex *key, Hex *iv, Hex *in, Hex *out, int enc, uint32_t inOffset, uint32_t outOffset)
{
TestMemInit();
int32_t ret;
uint8_t outTmp[MAX_OUTPUT] = {0};
uint32_t len = MAX_OUTPUT;
uint32_t totalLen = 0;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
memcpy_s(outTmp + inOffset, sizeof(outTmp) - inOffset, in->x, in->len);
ret = CRYPT_EAL_CipherUpdate(ctx, outTmp + inOffset, in->len, outTmp + outOffset, &len);
if (outOffset > 0 && outOffset < in->len) {
ASSERT_TRUE(ret == CRYPT_EAL_ERR_PART_OVERLAP);
} else {
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
len = MAX_OUTPUT - len;
ret = CRYPT_EAL_CipherFinal(ctx, outTmp + totalLen + outOffset, &len);
totalLen += len;
ASSERT_TRUE(totalLen == out->len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(outTmp + outOffset, out->x, out->len) == 0);
}
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
void reportLog(CRYPT_EVENT_TYPE oper, CRYPT_ALGO_TYPE type, int32_t id, int32_t err)
{
#ifdef PRINT_TO_TERMINAL
printf("CRYPT_EVENT_TYPE=%d, CRYPT_ALGO_TYPE=%d, algId=%d, errorCode=%d\n", oper, type, id, err);
#else
(void)oper;
(void)type;
(void)id;
(void)err;
#endif
}
/* END_HEADER */
/**
* @test SDV_CRYPTO_AES_NEW_CTX_API_TC001
* @title Impact of the invalid algorithm ID on the New interface
* @brief
* 1.Create the context ctx with the input parameter CRYPT_CIPHER_MAX. Expected result 1 is obtained.
* @expect
* 1.Failed. NULL is returned.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_NEW_CTX_API_TC001(void)
{
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_MAX);
ASSERT_TRUE(ctx == NULL);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_INIT_API_TC001
* @title Impact of Input Parameters on the CRYPT_EAL_CipherInit Interface
* @precon Registering memory-related functions.
* @brief
* 1.Call the New interface with param CRYPT_CIPHER_AES192_CBC. Expected result 1 is obtained.
* 2.Call the Init interface, ctx is not NULL, key is not NULL, keyLen is not 0,
* iv is not NULL, and ivLen is not 0. Expected result 2 is obtained.
* 3.Call the Init interface, ctx is NULL, key is not NULL, keyLen is not 0,
* iv is not NULL, and ivLen is not 0. Expected result 3 is obtained.
* 4.Call the Init interface, ctx is not NULL, key is NULL, keyLen is not 0,
* iv is not NULL, and ivLen is not 0. Expected result 4 is obtained.
* 5.Call the Init interface, ctx is not NULL, key is not NULL, keyLen is 0,
* iv is not NULL, and ivLen is not 0. Expected result 5 is obtained.
* 6.Call the Init interface, ctx is not NULL, key is not NULL, keyLen is not 0,
* iv is NULL, and ivLen is not 0. Expected result 6 is obtained.
* 7.Call the Init interface, ctx is not NULL, key is not NULL, keyLen is not 0,
* iv is not NULL, and ivLen is 0. Expected result 7 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.Init succeeded.
* 3.Init failed.
* 4.Init failed.
* 5.Init failed.
* 6.Init failed.
* 7.Init failed.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_INIT_API_TC001(Hex *key, Hex *iv)
{
TestMemInit();
int32_t ret;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherInit(NULL, key->x, key->len, iv->x, iv->len, true);
ASSERT_EQ_LOG("1", ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherInit(ctx, NULL, key->len, iv->x, iv->len, true);
ASSERT_EQ_LOG("2", ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherInit(ctx, key->x, 0, iv->x, iv->len, true);
ASSERT_EQ_LOG("3", ret, CRYPT_AES_ERR_KEYLEN);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, NULL, iv->len, true);
ASSERT_EQ_LOG("4", ret, CRYPT_INVALID_ARG);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, 0, true);
ASSERT_EQ_LOG("5", ret, CRYPT_MODES_IVLEN_ERROR);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_DEINIT_API_TC001
* @title Impact of Input Parameters on the CRYPT_EAL_CipherDeinit Interface
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Deinit interface, ctx is not NULL. Expected result 2 is obtained.
* 3.Call the Deinit interface, ctx is NULL. Expected result 3 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The function is executed successfully.
* 3.The function is executed successfully.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_DEINIT_API_TC001(void)
{
TestMemInit();
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherDeinit(NULL);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_REINIT_API_TC001
* @title CRYPT_EAL_CipherReinit Interface Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the Reinit interface, ctx is not NULL, iv is not NULL, and ivLen is not 0. Expected result 3 is obtained.
* 4.Call the Reinit interface, ctx is NULL, iv is not NULL, and ivLen is not 0. Expected result 4 is obtained.
* 5.Call the Reinit interface, ctx is not NULL, iv is NULL, and ivLen is not 0. Expected result 5 is obtained.
* 6.Call the Reinit interface, ctx is not NULL, iv is not NULL, and ivLen is 0. Expected result 6 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Success. Return CRYPT_SUCCESS.
* 4.Failed. Return CRYPT_NULL_INPUT.
* 5.Failed. Return CRYPT_NULL_INPUT.
* 6.Failed. Return CRYPT_NULL_INPUT.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_REINIT_API_TC001(Hex *key, Hex *iv)
{
TestMemInit();
int32_t ret;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherReinit(ctx, iv->x, iv->len);
ASSERT_TRUE(ret == CRYPT_EAL_ERR_STATE);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherReinit(NULL, iv->x, iv->len);
ASSERT_TRUE(ret == CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherReinit(ctx, NULL, iv->len);
ASSERT_TRUE(ret == CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherReinit(ctx, iv->x, 0);
ASSERT_TRUE(ret == CRYPT_MODES_IVLEN_ERROR);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_UPDATE_API_TC001
* @title Impact of Input Parameters on the CRYPT_EAL_CipherUpdate Interface
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the Update interface, ctx is NULL, in is not NULL, and in len is not 0, out is not NULL, and out len is not NULL. Expected result 3 is obtained.
* 4.Call the Update interface, ctx is not NULL, in is NULL, and in len is not 0, out is not NULL, and out len is not NULL. Expected result 4 is obtained.
* 5.Call the Update interface, ctx is not NULL, in is not NULL, and in len is 0, out is not NULL, and out len is not NULL. Expected result 5 is obtained.
* 6.Call the Update interface, ctx is not NULL, in is not NULL, and in len is not 0, out is NULL, and out len is not NULL. Expected result 6 is obtained.
* 7.Call the Update interface, ctx is not NULL, in is not NULL, and in len is not 0, out is not NULL, and out len is NULL. Expected result 7 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Failed. Return CRYPT_NULL_INPUT.
* 4.Failed. Return CRYPT_NULL_INPUT.
* 5.Success. Return CRYPT_SUCCESS.
* 6.Failed. Return CRYPT_NULL_INPUT.
* 7.Failed. Return CRYPT_NULL_INPUT.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_UPDATE_API_TC001(Hex *key, Hex *iv, Hex *in)
{
TestMemInit();
int32_t ret;
uint8_t out[AES_BLOCKSIZE] = {0};
uint32_t len = AES_BLOCKSIZE;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true);
ASSERT_EQ_LOG("1", ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, out, &len);
ASSERT_EQ_LOG("2", ret, CRYPT_SUCCESS);
ASSERT_EQ_LOG("3", len, AES_BLOCKSIZE);
ret = CRYPT_EAL_CipherUpdate(NULL, in->x, in->len, out, &len);
ASSERT_EQ_LOG("4", ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherUpdate(ctx, NULL, in->len, out, &len);
ASSERT_EQ_LOG("5", ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, 0, out, &len);
ASSERT_EQ_LOG("6", ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, NULL, &len);
ASSERT_EQ_LOG("7", ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, out, NULL);
ASSERT_EQ_LOG("8", ret, CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_FINAL_API_TC001
* @title Impact of Input Parameters on the CRYPT_EAL_CipherFinal Interface
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the Update interface. Expected result 3 is obtained.
* 4.Call the Final interface, ctx is NULL, out is not NULL, and out len is not 0. Expected result 4 is obtained.
* 5.Call the Final interface, ctx is not NULL, out is NULL, and out len is not 0. Expected result 5 is obtained.
* 6.Call the Final interface, ctx is not NULL, out is not NULL, and out len is 0. Expected result 6 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.The update is successful and return CRYPT_SUCCESS.
* 4.Failed. Return CRYPT_NULL_INPUT.
* 5.Failed. Return CRYPT_NULL_INPUT.
* 6.Failed. Return CRYPT_NULL_INPUT.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_FINAL_API_TC001(Hex *key, Hex *iv, Hex *in)
{
TestMemInit();
int32_t ret;
uint8_t out[AES_BLOCKSIZE] = {0};
uint32_t len = AES_BLOCKSIZE;
uint32_t finLen = AES_BLOCKSIZE;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, out, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherFinal(ctx, out, &finLen);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherFinal(NULL, out, &finLen);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherFinal(ctx, NULL, &finLen);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherFinal(ctx, out, NULL);
ASSERT_EQ(ret, CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_CTRL_API_TC001
* @title Impact of Input Parameters on the CRYPT_EAL_CipherCtrl Interface
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the Ctrl interface, ctx is not NULL, and type is get iv, iv is not NULL, and iv len is not 0. Expected result 3 is obtained.
* 4.Call the Ctrl interface, ctx is not NULL, and type is get blocksize, data is not NULL, and len is not 0. Expected result 4 is obtained.
* 5.Call the Ctrl interface, ctx is not NULL, and type is get iv, iv is NULL, and iv len is not 0. Expected result 5 is obtained.
* 6.Call the Ctrl interface, ctx is not NULL, and type is get iv, iv is not NULL, and iv len is 0. Expected result 6 is obtained.
* 7.Call the Ctrl interface, ctx is not NULL, and type is get blocksize, data is not NULL, and len is 0. Expected result 7 is obtained.
* 8.Call the Ctrl interface, ctx is not NULL, and type is invalid. Expected result 8 is obtained.
* 9.Call the Ctrl interface, ctx is not NULL, and type is get blocksize, data is NULL, and len is not 0. Expected result 9 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Success. Return CRYPT_SUCCESS.
* 4.Success. Return CRYPT_SUCCESS.
* 5.Failed. Return CRYPT_NULL_INPUT.
* 6.Failed. Return CRYPT_MODE_ERR_INPUT_LEN.
* 7.Failed. Return CRYPT_MODE_ERR_INPUT_LEN.
* 8.Failed. Return CRYPT_MODES_METHODS_NOT_SUPPORT.
* 9.Failed. Return CRYPT_MODE_ERR_INPUT_LEN.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_CTRL_API_TC001(int id, Hex *key, Hex *iv)
{
TestMemInit();
int32_t ret;
uint8_t *ivGet[AES_BLOCKSIZE] = {0};
const uint32_t len = AES_BLOCKSIZE;
uint32_t blockSizeGet = 0;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(id);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_IV, ivGet, len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_BLOCKSIZE, (uint8_t *)&blockSizeGet, sizeof(uint32_t));
if (id == CRYPT_CIPHER_AES128_CBC) {
ASSERT_EQ(blockSizeGet, AES_BLOCKSIZE);
} else {
ASSERT_TRUE(blockSizeGet == 1);
}
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_IV, NULL, len);
ASSERT_TRUE(ret == CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_IV, ivGet, 0);
ASSERT_TRUE(ret == CRYPT_MODE_ERR_INPUT_LEN);
ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_BLOCKSIZE, (uint8_t *)&blockSizeGet, 0);
ASSERT_TRUE(ret == CRYPT_MODE_ERR_INPUT_LEN);
ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_MAX, iv->x, iv->len);
ASSERT_EQ(ret, CRYPT_MODES_CTRL_TYPE_ERROR);
ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_BLOCKSIZE, NULL, sizeof(uint32_t));
ASSERT_TRUE(ret == CRYPT_MODE_ERR_INPUT_LEN);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_SET_PADDING_API_TC001
* @title Impact of Input Parameters on the CRYPT_EAL_CipherSetPadding Interface
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the CRYPT_EAL_CipherSetPadding interface with ctx is NULL, and type set to a normal value. Expected result 3 is obtained.
* 4.Call the CRYPT_EAL_CipherSetPadding interface with ctx is not NULL, and type set to a invalid value. Expected result 4 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Failed. Return CRYPT_NULL_INPUT.
* 4.Failed. Return CRYPT_MODES_METHODS_NOT_SUPPORT.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_SET_PADDING_API_TC001(Hex *key, Hex *iv)
{
TestMemInit();
int32_t ret;
CRYPT_EAL_CipherCtx *ctxCBC = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
CRYPT_EAL_CipherCtx *ctxCCM = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CCM);
CRYPT_EAL_CipherCtx *ctxCTR = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CTR);
ASSERT_TRUE(ctxCBC != NULL);
ASSERT_TRUE(ctxCCM != NULL);
ASSERT_TRUE(ctxCTR != NULL);
ret = CRYPT_EAL_CipherInit(ctxCBC, key->x, key->len, iv->x, iv->len, true);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherSetPadding(ctxCBC, CRYPT_PADDING_ZEROS);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherSetPadding(NULL, CRYPT_PADDING_ZEROS);
ASSERT_TRUE(ret == CRYPT_NULL_INPUT);
ret = CRYPT_EAL_CipherSetPadding(ctxCBC, CRYPT_PADDING_MAX_COUNT);
ASSERT_EQ(ret, CRYPT_MODES_PADDING_NOT_SUPPORT);
ret = CRYPT_EAL_CipherSetPadding(ctxCCM, CRYPT_PADDING_ZEROS);
ASSERT_EQ(ret, CRYPT_MODES_CTRL_TYPE_ERROR);
ret = CRYPT_EAL_CipherSetPadding(ctxCTR, CRYPT_PADDING_ZEROS);
ASSERT_EQ(ret, CRYPT_MODES_CTRL_TYPE_ERROR);
EXIT:
CRYPT_EAL_CipherDeinit(ctxCBC);
CRYPT_EAL_CipherFreeCtx(ctxCBC);
CRYPT_EAL_CipherFreeCtx(ctxCCM);
CRYPT_EAL_CipherFreeCtx(ctxCTR);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_GET_PADDING_API_TC001
* @title Impact of Input Parameters on the CRYPT_EAL_CipherGetPadding Interface
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the CRYPT_EAL_CipherGetPadding interface with ctx is NULL. Expected result 3 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful and return CRYPT_SUCCESS.
* 3.Failed. Return CRYPT_NULL_INPUT.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_GET_PADDING_API_TC001(Hex *key, Hex *iv)
{
TestMemInit();
int32_t ret;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherSetPadding(ctx, CRYPT_PADDING_ZEROS);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherGetPadding(ctx);
ASSERT_TRUE(ret == CRYPT_PADDING_ZEROS);
ret = CRYPT_EAL_CipherGetPadding(NULL);
ASSERT_TRUE(ret == CRYPT_NULL_INPUT);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_ENCRYPT_FUNC_TC001
* @title Impact of multiple blocks on AES calculation_KAT, MMT Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the SetPadding interface to set the padding mode CRYPT_PADDING_NONE. Expected result 2 is obtained.
* 3.Call the Init interface. Expected result 3 is obtained.
* 4.Call the Update interface. Expected result 4 is obtained.
* 5.Call the Final interface. Expected result 5 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The setting is successful, return CRYPT_SUCCESS.
* 3.The init is successful, return CRYPT_SUCCESS.
* 4.The update is successful, return CRYPT_SUCCESS.
* 5.The final is successful, return CRYPT_SUCCESS. The calculation result is consistent with the vector value.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC001(int isProvider, int algId, Hex *key, Hex *iv, Hex *in, Hex *out, int enc)
{
if (IsAesAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
int32_t ret;
uint8_t outTmp[MAX_OUTPUT] = {0};
uint32_t len = MAX_OUTPUT;
uint32_t totalLen = 0;
CRYPT_EAL_CipherCtx *ctx = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len);
ASSERT_EQ(ret, CRYPT_SUCCESS);
totalLen += len;
len = MAX_OUTPUT - len;
ret = CRYPT_EAL_CipherFinal(ctx, outTmp + totalLen, &len);
totalLen += len;
ASSERT_EQ(totalLen, out->len);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_EQ(memcmp(outTmp, out->x, out->len), 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_ENCRYPT_FUNC_TC002
* @title Multiple update_MCT tests
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the SetPadding interface to set the padding mode. Expected result 2 is obtained.
* 3.Call the Init interface. Expected result 3 is obtained.
* 4.Call the Update interface for multiple times. Expected result 4 is obtained.
* 5.Call the Final interface. Expected result 5 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The setting is successful, return CRYPT_SUCCESS.
* 3.The init is successful, return CRYPT_SUCCESS.
* 4.The update is successful, return CRYPT_SUCCESS.
* 5.The final is successful, return CRYPT_SUCCESS. The calculation result is consistent with the vector value.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC002(int algId, Hex *key, Hex *iv, Hex *in, Hex *out, int enc)
{
if (IsAesAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
int32_t ret;
uint32_t len = AES_BLOCKSIZE;
uint8_t mctResult[MCT_INNER_LOOP][AES_BLOCKSIZE] = {0};
uint8_t *inputTmp = in->x;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
for (uint32_t i = 0; i < MCT_INNER_LOOP; i++) {
ret = CRYPT_EAL_CipherUpdate(ctx, inputTmp, AES_BLOCKSIZE, mctResult[i], &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
if (i == 0) {
inputTmp = iv->x;
} else {
inputTmp = mctResult[i - 1];
}
}
ASSERT_TRUE(memcmp(mctResult[MCT_INNER_LOOP - 1], out->x, out->len) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_ENCRYPT_FUNC_TC003
* @title After reinit, re-encrypt and decrypt data Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the SetPadding interface to set the padding mode. Expected result 2 is obtained.
* 3.Call the Init interface. Expected result 3 is obtained.
* 4.Call the Update interface. Expected result 4 is obtained.
* 5.Call the Final interface. Expected result 5 is obtained.
* 6.Call the Reinit interface. Expected result 6 is obtained.
* 7.Call the Update interface. Expected result 7 is obtained.
* 8.Call the Final interface. Expected result 8 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The setting is successful, return CRYPT_SUCCESS.
* 3.The init is successful, return CRYPT_SUCCESS.
* 4.The update is successful, return CRYPT_SUCCESS.
* 5.The final is successful, return CRYPT_SUCCESS. The calculation result is consistent with the vector value.
* 6.The reinit is successful, return CRYPT_SUCCESS.
* 7.The update is successful, return CRYPT_SUCCESS.
* 8.The final is successful, return CRYPT_SUCCESS. The calculation result is consistent with the vector value.
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC003(int isProvider, int algId, Hex *key, Hex *iv, Hex *in, Hex *out, int enc)
{
if (IsAesAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
int32_t ret;
uint8_t outTmp[MAX_OUTPUT] = {0};
uint32_t len = MAX_OUTPUT;
uint32_t finLen;
CRYPT_EAL_CipherCtx *ctx = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
finLen = MAX_OUTPUT - len;
ret = CRYPT_EAL_CipherFinal(ctx, outTmp + len, &finLen);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
(void)memset_s(outTmp, MAX_OUTPUT, 0, MAX_OUTPUT);
len = MAX_OUTPUT;
ret = CRYPT_EAL_CipherReinit(ctx, iv->x, iv->len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
finLen = MAX_OUTPUT - len;
ret = CRYPT_EAL_CipherFinal(ctx, outTmp + len, &finLen);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_STATE_CHANGE_API_TC001
* @title New, init, update, and final state transition Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx twice. Expected result 1 is obtained.
* 2.Call the Free interface twice. Expected result 2 is obtained.
* 3.Create the context ctx. Expected result 3 is obtained.
* 4.Call the Init interface twice. Expected result 4 is obtained.
* 5.Call the Update interface twice. Expected result 5 is obtained.
* 6.Call the Final interface twice. Expected result 6 is obtained.
* 7.Call the Update interface. Expected result 7 is obtained.
* 8.Call the Deinit interface twice and call Free interface. Expected result 8 is obtained.
* 9.Create the context ctx. Expected result 9 is obtained.
* 10.Call the Update interface. Expected result 10 is obtained.
* 11.Call the Free interface and create the context ctx. Expected result 11 is obtained.
* 12.Call the Final interface. Expected result 12 is obtained.
* 13.Call the Free interface and create the context ctx. Expected result 13 is obtained.
* 14.Call the Init interface. Expected result 14 is obtained.
* 15.Call the Update interface. Expected result 15 is obtained.
* 16.Call the Init interface. Expected result 16 is obtained.
* 17.Call the Free interface and create the context ctx. Expected result 17 is obtained.
* 18.Call the Reinit interface. Expected result 18 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The free function is successfully executed.
* 3.The creation is successful and the ctx is not empty.
* 4.The init is successful, return CRYPT_SUCCESS.
* 5.The update is successful, return CRYPT_SUCCESS.
* 6.The first final is successful, the second final is failed, return CRYPT_EAL_ERR_STATE.
* 7.Failed. return CRYPT_EAL_ERR_STATE.
* 8.The deinit adn free function is successfully executed.
* 9.The creation is successful and the ctx is not empty.
* 10.Failed. return CRYPT_EAL_ERR_STATE.
* 11.The creation is successful and the ctx is not empty.
* 12.Failed. return CRYPT_EAL_ERR_STATE.
* 13.The creation is successful and the ctx is not empty.
* 14.The init is successful, return CRYPT_SUCCESS.
* 15.The update is successful, return CRYPT_SUCCESS.
* 16.The init is successful, return CRYPT_SUCCESS.
* 17.The creation is successful and the ctx is not empty.
* 18.Failed. return CRYPT_EAL_ERR_STATE.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_STATE_CHANGE_API_TC001(Hex *key, Hex *iv, Hex *in, int enc)
{
TestMemInit();
uint8_t outTmp[MAX_OUTPUT] = {0};
uint32_t len = MAX_OUTPUT;
// multi new
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
CRYPT_EAL_CipherCtx *ctx1 = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(ctx1 != NULL);
CRYPT_EAL_CipherFreeCtx(ctx);
CRYPT_EAL_CipherFreeCtx(ctx1);
ctx = NULL;
ctx1 = NULL;
ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
// multi init
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc) == CRYPT_SUCCESS);
// multi update
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len) == CRYPT_SUCCESS);
// multi final
ASSERT_TRUE(CRYPT_EAL_CipherFinal(ctx, outTmp, &len) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherFinal(ctx, outTmp, &len) == CRYPT_EAL_ERR_STATE);
// update after final
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len) == CRYPT_EAL_ERR_STATE);
// multi deinit
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
// update after new
ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len) == CRYPT_EAL_ERR_STATE);
CRYPT_EAL_CipherFreeCtx(ctx);
// final after new
ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherFinal(ctx, outTmp, &len) == CRYPT_EAL_ERR_STATE);
CRYPT_EAL_CipherFreeCtx(ctx);
// init after new
len = MAX_OUTPUT;
ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc) == CRYPT_SUCCESS);
ASSERT_TRUE(CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len) == CRYPT_SUCCESS);
// init after update
ASSERT_TRUE(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc) == CRYPT_SUCCESS);
CRYPT_EAL_CipherFreeCtx(ctx);
ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(CRYPT_EAL_CipherReinit(ctx, iv->x, iv->len) == CRYPT_EAL_ERR_STATE);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_ENCRYPT_FUNC_TC004
* @title Encryption and decryption in different padding modes Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call SetPadding interface setting padding mode to CRYPT_PADDING_ISO7816, CRYPT_PADDING_ZEROS,
* CRYPT_PADDING_X923, CRYPT_PADDING_PKCS5, CRYPT_PADDING_PKCS7. Expected result 2 is obtained.
* 3.Call the Init interface. Expected result 3 is obtained.
* 4.Call the Update interface. Expected result 4 is obtained.
* 5.Call the Final interface. Expected result 5 is obtained.
* 6.Call the init, update, and final interfaces to decrypt and verifiy the result.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The setting is successful, return CRYPT_SUCCESS.
* 3.The init is successful, return CRYPT_SUCCESS.
* 4.The update is successful, return CRYPT_SUCCESS.
* 5.The final is successful, return CRYPT_SUCCESS.
* 6.The verification is successful, return CRYPT_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC004(int algId, Hex *key, Hex *iv, Hex *in, int padding)
{
if (IsAesAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
int32_t ret;
uint8_t outTmp[MAX_OUTPUT] = {0};
uint8_t result[MAX_OUTPUT] = {0};
uint32_t totalLen = 0;
uint32_t leftLen = MAX_OUTPUT;
uint32_t len = MAX_OUTPUT;
CRYPT_EAL_CipherCtx *ctxEnc = NULL;
CRYPT_EAL_CipherCtx *ctxDec = NULL;
ctxEnc = CRYPT_EAL_CipherNewCtx(algId);
ASSERT_TRUE(ctxEnc != NULL);
ret = CRYPT_EAL_CipherSetPadding(ctxEnc, padding);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherInit(ctxEnc, key->x, key->len, iv->x, iv->len, true);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherSetPadding(ctxEnc, padding);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctxEnc, in->x, in->len, outTmp, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
leftLen = leftLen - len;
ret = CRYPT_EAL_CipherFinal(ctxEnc, outTmp + len, &leftLen);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += leftLen;
len = MAX_OUTPUT;
leftLen = MAX_OUTPUT;
ctxDec = CRYPT_EAL_CipherNewCtx(algId);
ASSERT_TRUE(ctxDec != NULL);
ret = CRYPT_EAL_CipherInit(ctxDec, key->x, key->len, iv->x, iv->len, false);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherSetPadding(ctxDec, padding);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctxDec, outTmp, totalLen, result, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
leftLen -= len;
ret = CRYPT_EAL_CipherFinal(ctxDec, result + len, &leftLen);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(in->x, result, in->len) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctxEnc);
CRYPT_EAL_CipherFreeCtx(ctxEnc);
CRYPT_EAL_CipherDeinit(ctxDec);
CRYPT_EAL_CipherFreeCtx(ctxDec);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_ENCRYPT_FUNC_TC005
* @title Multiple update calculation encryption and decryption Test
* @precon Registering memory-related functions.
* @brief
* 1.Call the Init interface. Expected result 1 is obtained.
* 2.Call the update interface to update the first message. Expected result 2 is obtained.
* 3.Call the update interface to update the second message. Expected result 3 is obtained.
* 4.Call the update interface to update the third message. Expected result 4 is obtained.
* 5.Call the final interface. Expected result 5 is obtained.
* 6.Check whether the result is consistent with the test vector. Expected result 6 is obtained.
* @expect
* 1.The init is successful, return CRYPT_SUCCESS.
* 2.The update is successful, return CRYPT_SUCCESS.
* 3.The update is successful, return CRYPT_SUCCESS.
* 4.The update is successful, return CRYPT_SUCCESS.
* 5.The final is successful, return CRYPT_SUCCESS.
* 6.The verification is successful.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC005(int isProvider, int algId, Hex *key, Hex *iv, Hex *in1, Hex *in2,
Hex *in3, Hex *out, int enc)
{
TestMemInit();
int32_t ret;
uint8_t outTmp[MAX_OUTPUT] = {0};
uint32_t len = MAX_OUTPUT;
uint32_t totalLen = 0;
CRYPT_EAL_CipherCtx *ctx = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in1->x, in1->len, outTmp, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
len = MAX_OUTPUT - totalLen;
ret = CRYPT_EAL_CipherUpdate(ctx, in2->x, in2->len, outTmp + totalLen, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
len = MAX_OUTPUT - totalLen;
ret = CRYPT_EAL_CipherUpdate(ctx, in3->x, in3->len, outTmp + totalLen, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
len = MAX_OUTPUT - totalLen;
ret = CRYPT_EAL_CipherFinal(ctx, outTmp + totalLen, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_ENCRYPT_FUNC_TC006
* @title Encryption and decryption for multiple updates in CFB mode
* @precon Registering memory-related functions.
* @brief
* 1.Call the Init interface. Expected result 1 is obtained.
* 2.Call the Ctrl interface to set feedback.
* 3.Call the Ctrl interface to get feedback. Expected result 2 is obtained.
* 4.Call the update interface to update the first message. Expected result 3 is obtained.
* 5.Call the update interface to update the second message. Expected result 4 is obtained.
* 6.Call the update interface to update the third message. Expected result 5 is obtained.
* 7.Call the final interface. Expected result 6 is obtained.
* 8.Check whether the result is consistent with the test vector. Expected result 7 is obtained.
* @expect
* 1.The init is successful, return CRYPT_SUCCESS.
* 2.The get is successful, and getting FeedBack is equal to setting.
* 3.The update is successful, return CRYPT_SUCCESS.
* 4.The update is successful, return CRYPT_SUCCESS.
* 5.The update is successful, return CRYPT_SUCCESS.
* 6.The final is successful, return CRYPT_SUCCESS.
* 7.The verification is successful.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC006(int isProvider, int algId, int feed, Hex *key, Hex *iv, Hex *in1, Hex *in2,
Hex *in3, Hex *out, int enc)
{
if (IsAesAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
int32_t ret;
uint8_t outTmp[MAX_OUTPUT] = {0};
uint32_t len = MAX_OUTPUT;
uint32_t totalLen = 0;
CRYPT_EAL_CipherCtx *ctx = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
uint32_t feedBack = feed;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_FEEDBACKSIZE, (uint32_t *)&feedBack, sizeof(uint32_t)) == CRYPT_SUCCESS);
uint32_t tmpFeedBack = 0;
ASSERT_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_FEEDBACKSIZE, (uint32_t *)&tmpFeedBack, sizeof(uint32_t)) == CRYPT_SUCCESS);
ASSERT_TRUE(tmpFeedBack == (uint32_t)feed);
ret = CRYPT_EAL_CipherUpdate(ctx, in1->x, in1->len, outTmp, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
len = MAX_OUTPUT - totalLen;
ret = CRYPT_EAL_CipherUpdate(ctx, in2->x, in2->len, outTmp + totalLen, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
len = MAX_OUTPUT - totalLen;
ret = CRYPT_EAL_CipherUpdate(ctx, in3->x, in3->len, outTmp + totalLen, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
len = MAX_OUTPUT - totalLen;
ret = CRYPT_EAL_CipherFinal(ctx, outTmp + totalLen, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_ENCRYPT_FUNC_TC007
* @title The input and output use the same buffer Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call the Update interface. Expected result 3 is obtained.
* 4.Call the Final interface. Expected result 4 is obtained.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful, return CRYPT_SUCCESS.
* 3.The update is successful, return CRYPT_SUCCESS.
* 4.The final is successful, return CRYPT_SUCCESS. The result is consistent with the test vector.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC007(int algId, Hex *key, Hex *iv, Hex *in, Hex *out, int enc)
{
TestMemInit();
int32_t ret;
uint32_t len = in->len;
uint32_t totalLen = 0;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(algId);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, in->x, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen = totalLen + len;
len = in->len - totalLen;
ret = CRYPT_EAL_CipherFinal(ctx, in->x + totalLen, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(in->x, out->x, out->len) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
typedef struct {
int algId;
uint8_t *key;
uint32_t keyLen;
uint8_t *iv;
uint32_t ivLen;
uint8_t *in;
uint32_t inLen;
uint8_t *out;
uint32_t outLen;
int enc;
} TestVector;
void AES_MultiThreadTest(void *arg)
{
TestVector *pTestVector = (TestVector *)arg;
int32_t ret;
uint8_t outTmp[MAX_OUTPUT] = {0};
uint32_t len = MAX_OUTPUT;
uint32_t totalLen = 0;
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(pTestVector->algId);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, pTestVector->key, pTestVector->keyLen, pTestVector->iv,
pTestVector->ivLen, pTestVector->enc);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, pTestVector->in, pTestVector->inLen, outTmp, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen = totalLen + len;
len = MAX_OUTPUT - totalLen;
ret = CRYPT_EAL_CipherFinal(ctx, outTmp + totalLen, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(outTmp, pTestVector->out, pTestVector->outLen) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/**
* @test SDV_CRYPTO_AES_MULTI_THREAD_FUNC_TC001
* @title Multi-thread Test
* @precon Registering memory-related functions.
* @brief
* 1.Create three threads for synchronous encryption and decryption. Expected result 1 is obtained.
* 2.Create the context ctx. Expected result 2 is obtained.
* 3.Call the Init interface. Expected result 3 is obtained.
* 4.Call the Update interface. Expected result 4 is obtained.
* 5.Call the Final interface. Expected result 5 is obtained.
* 6.Waiting for the thread to exit normally. Expected result 6 is obtained.
* @expect
* 1.The thread is created successfully.
* 2.The creation is successful and the ctx is not empty.
* 3.The init is successful, return CRYPT_SUCCESS.
* 4.The update is successful, return CRYPT_SUCCESS.
* 5.The final is successful, return CRYPT_SUCCESS. The result is consistent with the test vector.
* 6.The thread exits successfully.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_MULTI_THREAD_FUNC_TC001(int algId, Hex *key, Hex *iv, Hex *in, Hex *out, int enc)
{
#define THREAD_NUM 3
TestMemInit();
int32_t ret;
pthread_t thrd[THREAD_NUM];
TestVector testVt = {.algId = algId,
.key = key->x,
.keyLen = key->len,
.iv = iv->x,
.ivLen = iv->len,
.in = in->x,
.inLen = in->len,
.out = out->x,
.outLen = out->len,
.enc = enc};
for (uint32_t i = 0; i < THREAD_NUM; i++) {
ret = pthread_create(&thrd[i], NULL, (void *)AES_MultiThreadTest, &testVt);
ASSERT_TRUE(ret == 0);
}
for (uint32_t i = 0; i < THREAD_NUM; i++) {
pthread_join(thrd[i], NULL);
}
EXIT:
return;
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_OVERLAP_FUNC_TC001
* @title The in and out memory partially overlaps during update
* @precon Registering memory-related functions.
* @brief
* 1.The in and out buff are partially overlaps. If out > in, Expected result 1 is obtained.
* 2.The in and out buff are partially overlaps. If in > out, Expected result 2 is obtained.
* @expect
* 1.Failed. Return RYPT_EAL_ERR_PART_OVERLAP
* 2.The operation is normal.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_OVERLAP_FUNC_TC001(int algId, Hex *key, Hex *iv, Hex *in, Hex *out, int enc)
{
for (uint32_t i = 0; i <= in->len + EAL_MAX_BLOCK_LENGTH; i++) {
Test_CipherOverLap(algId, key, iv, in, out, enc, i, 0);
}
for (uint32_t i = 0; i < in->len + EAL_MAX_BLOCK_LENGTH + EAL_MAX_BLOCK_LENGTH; i++) {
Test_CipherOverLap(algId, key, iv, in, out, enc, 0, i);
}
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_ENCRYPT_FUNC_TC008
* @title Encryption in different padding modes Test
* @precon Registering memory-related functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call SetPadding interface setting padding mode to CRYPT_PADDING_ISO7816,
* CRYPT_PADDING_X923, CRYPT_PADDING_PKCS7. Expected result 3 is obtained.
* 4.Call the Update interface. Expected result 4 is obtained.
* 5.Call the Final interface. Expected result 5 is obtained.
* 6.Call the init, update, and final interfaces to decrypt and verifiy the result.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful, return CRYPT_SUCCESS.
* 3.The setting is successful, return CRYPT_SUCCESS.
* 4.The update is successful, return CRYPT_SUCCESS.
* 5.The final is successful, return CRYPT_SUCCESS.
* 6.The verification is successful, return CRYPT_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC008(int isProvider, int algId, Hex *key, Hex *iv, Hex *in, Hex *out, int padding)
{
TestMemInit();
int32_t ret;
uint8_t outTmp[MAX_OUTPUT] = {0};
uint32_t totalLen = 0;
uint32_t leftLen = MAX_OUTPUT;
uint32_t len = MAX_OUTPUT;
CRYPT_EAL_CipherCtx *ctxEnc = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
ASSERT_TRUE(ctxEnc != NULL);
ret = CRYPT_EAL_CipherInit(ctxEnc, key->x, key->len, iv->x, iv->len, true);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherSetPadding(ctxEnc, padding);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctxEnc, in->x, in->len, outTmp, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
leftLen = leftLen - len;
ret = CRYPT_EAL_CipherFinal(ctxEnc, outTmp + len, &leftLen);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += leftLen;
ASSERT_TRUE(totalLen == out->len);
ASSERT_TRUE(memcmp(out->x, outTmp, out->len) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctxEnc);
CRYPT_EAL_CipherFreeCtx(ctxEnc);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_AES_ENCRYPT_FUNC_TC009
* @title Decryption in different padding modes Test
* @precon Registering memory-related functions and report-log functions.
* @brief
* 1.Create the context ctx. Expected result 1 is obtained.
* 2.Call the Init interface. Expected result 2 is obtained.
* 3.Call SetPadding interface setting padding mode to CRYPT_PADDING_ISO7816,
* CRYPT_PADDING_X923, CRYPT_PADDING_PKCS7. Expected result 3 is obtained.
* 4.Call the Update interface. Expected result 4 is obtained.
* 5.Call the Final interface. Expected result 5 is obtained.
* 6.Call the init, update, and final interfaces to decrypt and verifiy the result.
* @expect
* 1.The creation is successful and the ctx is not empty.
* 2.The init is successful, return CRYPT_SUCCESS.
* 3.The setting is successful, return CRYPT_SUCCESS.
* 4.The update is successful, return CRYPT_SUCCESS.
* 5.The final is successful, return CRYPT_SUCCESS.
* 6.The verification is successful, return CRYPT_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_CRYPTO_AES_ENCRYPT_FUNC_TC009(int isProvider, int algId, Hex *key, Hex *iv, Hex *in, Hex *out,
int padding)
{
TestMemInit();
CRYPT_EAL_RegEventReport(reportLog);
int32_t ret;
uint8_t result[MAX_OUTPUT] = {0};
uint32_t totalLen = 0;
uint32_t leftLen = MAX_OUTPUT;
uint32_t len = MAX_OUTPUT;
CRYPT_EAL_CipherCtx *ctxDec = NULL;
len = MAX_OUTPUT;
leftLen = MAX_OUTPUT;
ctxDec = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
ASSERT_TRUE(ctxDec != NULL);
ret = CRYPT_EAL_CipherInit(ctxDec, key->x, key->len, iv->x, iv->len, false);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherSetPadding(ctxDec, padding);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctxDec, in->x, in->len, result, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
leftLen = leftLen - len;
ret = CRYPT_EAL_CipherFinal(ctxDec, result + len, &leftLen);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += leftLen;
ASSERT_TRUE(totalLen == out->len);
ASSERT_TRUE(memcmp(out->x, result, out->len) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctxDec);
CRYPT_EAL_CipherFreeCtx(ctxDec);
}
/* END_CASE */
/**
* @test SDV_CRYPTO_EAL_AES_XTS_GET_IV_TC001
* @title AES-XTS: obtaining IV in different states.
* @brief
* 1. Get iv after init iv, and compare the getted iv with original iv, expected result 1
* 2. Get iv after update, and compare the getted iv with original iv, expected result 2
* 3. Get iv after final, expected result 3
* @expect
* 1. The IV is obtained successfully and the two IVs are the same.
* 2. The IV is obtained successfully and the two IVs are the same.
* 3. CRYPT_EAL_ERR_STATE
*/
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_AES_XTS_GET_IV_TC001(int id, Hex *key, Hex *iv, Hex *plainText, Hex *cipherText)
{
uint8_t outIv[AES_BLOCKSIZE] = {0};
uint8_t out[MAX_OUTPUT] = {0};
uint32_t totalOutLen = 0;
uint32_t outLen = MAX_OUTPUT;
TestMemInit();
CRYPT_EAL_CipherCtx *ctx = CRYPT_EAL_CipherNewCtx(id);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, true), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_IV, outIv, iv->len), CRYPT_SUCCESS);
ASSERT_COMPARE("Get iv after init", outIv, iv->len, iv->x, iv->len);
ASSERT_EQ(CRYPT_EAL_CipherUpdate(ctx, plainText->x, plainText->len, out, &outLen), CRYPT_SUCCESS);
(void)memset_s(outIv, AES_BLOCKSIZE, 0, AES_BLOCKSIZE);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_IV, outIv, iv->len), CRYPT_SUCCESS);
ASSERT_COMPARE("Get iv after encrypt", outIv, iv->len, iv->x, iv->len);
totalOutLen += outLen;
outLen = MAX_OUTPUT - totalOutLen;
ASSERT_EQ(CRYPT_EAL_CipherFinal(ctx, out + totalOutLen, &outLen), CRYPT_SUCCESS);
totalOutLen += outLen;
ASSERT_COMPARE("Check encrypt result", out, totalOutLen, cipherText->x, cipherText->len);
ASSERT_EQ(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_IV, outIv, iv->len), CRYPT_EAL_ERR_STATE);
EXIT:
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_EAL_AES_FUNC_TC001
* @spec -
* @title CBC,ECB,CTR,XTS: the influence of All-zero and All-F Data Keys on AES Calculation_KAT
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_AES_FUNC_TC001(int isProvider, int algId, Hex *key, Hex *iv, Hex *in, Hex *out, int enc)
{
if (IsAesAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
int32_t ret;
uint8_t outTmp[MAX_OUTPUT] = {0};
uint32_t len = MAX_OUTPUT;
uint32_t totalLen = 0;
CRYPT_EAL_CipherCtx *ctx = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
totalLen += len;
len = MAX_OUTPUT - len;
ret = CRYPT_EAL_CipherFinal(ctx, outTmp + totalLen, &len);
totalLen += len;
ASSERT_TRUE(totalLen == out->len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
/* @
* @test SDV_CRYPTO_EAL_AES_FUNC_TC005
* @spec -
* @title CBC,ECB,CTR,XTS: after reinit, re-encrypt and decrypt data_reinit function test
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_CRYPTO_EAL_AES_FUNC_TC005(int isProvider, int algId, Hex *key, Hex *iv, Hex *in, Hex *out, int enc)
{
if (IsAesAlgDisabled(algId)) {
SKIP_TEST();
}
TestMemInit();
int32_t ret;
uint8_t outTmp[MAX_OUTPUT] = {0};
uint32_t len = MAX_OUTPUT;
uint32_t finLen;
CRYPT_EAL_CipherCtx *ctx = TestCipherNewCtx(NULL, algId, "provider=default", isProvider);
ASSERT_TRUE(ctx != NULL);
ret = CRYPT_EAL_CipherInit(ctx, key->x, key->len, iv->x, iv->len, enc);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
finLen = MAX_OUTPUT - len;
ret = CRYPT_EAL_CipherFinal(ctx, outTmp + len, &finLen);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
(void)memset_s(outTmp, MAX_OUTPUT, 0, MAX_OUTPUT);
len = MAX_OUTPUT;
ret = CRYPT_EAL_CipherReinit(ctx, iv->x, iv->len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ret = CRYPT_EAL_CipherUpdate(ctx, in->x, in->len, outTmp, &len);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
finLen = MAX_OUTPUT - len;
ret = CRYPT_EAL_CipherFinal(ctx, outTmp + len, &finLen);
ASSERT_TRUE(ret == CRYPT_SUCCESS);
ASSERT_TRUE(memcmp(outTmp, out->x, out->len) == 0);
EXIT:
CRYPT_EAL_CipherDeinit(ctx);
CRYPT_EAL_CipherFreeCtx(ctx);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/crypto/aes/test_suite_sdv_eal_aes.c
|
C
|
unknown
| 54,113
|