openharmony/third_party_openhitls
1
0
Fork 0
mirror of https://github.com/openharmony/third_party_openhitls.git synced 2026-07-01 10:05:26 -04:00
Code Issues Packages Projects Releases Wiki Activity

merge master into master

Browse Source 
同步openhitls代码

Created-by: Dongjianwei001
Commit-by: 离标量;bala
Merged-by: openharmony_ci
Description: ### 一、内容说明（相关的Issue）

代码同步

### 二、建议测试周期和提测地址  
  建议测试完成时间：xxxx.xx.xx  
  投产上线时间：xxxx.xx.xx  
  提测地址：CI环境/压测环境  
  测试账号：  

### 三、变更内容
  * 3.1 关联PR列表

  * 3.2 数据库和部署说明  
    1. 常规更新 
    2. 重启unicorn
    3. 重启sidekiq
    4. 迁移任务：是否有迁移任务，没有写 "无"
    5. rake脚本：`bundle exec xxx RAILS_ENV = production`；没有写 "无"

  * 3.4 其他技术优化内容（做了什么，变更了什么）
    - 重构了 xxxx 代码
    - xxxx 算法优化


  * 3.5 废弃通知（什么字段、方法弃用？）



  * 3.6  后向不兼容变更（是否有无法向后兼容的变更？）


  
### 四、研发自测点（自测哪些？冒烟用例全部自测？）
  自测测试结论：


### 五、测试关注点（需要提醒QA重点关注的、可能会忽略的地方）
  检查点：

| 需求名称 | 是否影响xx公共模块 | 是否需要xx功能 | 需求升级是否依赖其他子产品 |
|------|------------|----------|---------------|
| xxx  | 否          | 需要       | 不需要           |
|      |            |          |               |

  接口测试：

  性能测试：

  并发测试：

  其他：



See merge request: openharmony/third_party_openhitls!16
This commit is contained in:
openharmony_ci
2025-07-15 14:15:10 +08:00
parent b769d98e47 65581d2202
commit 930fe248c7
90 changed files with 1115 additions and 1109 deletions
Download Patch File Download Diff File Expand all files Collapse all files
bsl/init/bsl_init.c
+2 -2
View File
@@ -32,10 +32,10 @@ int32_t BSL_GLOBAL_DeInit(void)
BSL_ERR_RemoveErrStringBatch();
BSL_ERR_RemoveErrorStack(true);
BSL_ERR_DeInit();
#ifdef HITLS_BSL_HASH
#if defined HITLS_BSL_OBJ && defined HITLS_BSL_HASH
BSL_OBJ_FreeSignHashTable();
BSL_OBJ_FreeHashTable();
#endif // HITLS_BSL_HASH
#endif // HITLS_BSL_OBJ && HITLS_BSL_HASH
return BSL_SUCCESS;
}
bsl/list/src/bsl_list_ex.c
+25 -20
View File
@@ -140,31 +140,36 @@ void BSL_LIST_DetachNode(BslList *pstList, BslListNode **pstListNode)
BslListNode *pstCurrentNode = pstList->first;
while (pstCurrentNode != NULL) {
if (pstCurrentNode == *pstListNode) {
// found matching node, delete this node and adjust the list
if ((pstCurrentNode->next) != NULL) {
pstCurrentNode->next->prev = pstCurrentNode->prev;
*pstListNode = pstCurrentNode->next; // update the current node and point it to the next node
} else {
pstList->last = pstCurrentNode->prev;
*pstListNode = pstList->last;
if (pstCurrentNode != *pstListNode) {
pstCurrentNode = pstCurrentNode->next;
continue;
}
// found matching node, delete this node and adjust the list
if ((pstCurrentNode->next) != NULL) {
pstCurrentNode->next->prev = pstCurrentNode->prev;
if (*pstListNode == pstList->curr) {
pstList->curr = pstCurrentNode->next;
}
if ((pstCurrentNode->prev) != NULL) {
pstCurrentNode->prev->next = pstCurrentNode->next;
} else {
pstList->first = pstCurrentNode->next;
*pstListNode = pstCurrentNode->next; // update the current node and point it to the next node
} else {
pstList->last = pstCurrentNode->prev;
if (*pstListNode == pstList->curr) {
pstList->curr = pstCurrentNode->prev;
}
pstList->count--;
BSL_SAL_FREE(pstCurrentNode);
return;
*pstListNode = pstList->last;
}
pstCurrentNode = pstCurrentNode->next;
}
if ((pstCurrentNode->prev) != NULL) {
pstCurrentNode->prev->next = pstCurrentNode->next;
} else {
pstList->first = pstCurrentNode->next;
}
pstList->count--;
BSL_SAL_FREE(pstCurrentNode);
return;
}
return;
}
#endif /* HITLS_BSL_LIST */
bsl/obj/include/bsl_obj_internal.h
+1 -1
View File
@@ -45,7 +45,7 @@ typedef struct {
BslCid BSL_OBJ_GetHashIdFromSignId(BslCid signAlg);
BslCid BSL_OBJ_GetAsymIdFromSignId(BslCid signAlg);
BslCid BSL_OBJ_GetAsymAlgIdFromSignId(BslCid signAlg);
const char *BSL_OBJ_GetOidNameFromOid(const BslOidString *oid);
bsl/obj/src/bsl_cid_op.c
+7 -4
View File
@@ -146,7 +146,7 @@ BslCid BSL_OBJ_GetHashIdFromSignId(BslCid signAlg)
#endif
}
BslCid BSL_OBJ_GetAsymIdFromSignId(BslCid signAlg)
BslCid BSL_OBJ_GetAsymAlgIdFromSignId(BslCid signAlg)
{
if (signAlg == BSL_CID_UNKNOWN) {
return BSL_CID_UNKNOWN;
@@ -187,6 +187,9 @@ BslCid BSL_OBJ_GetAsymIdFromSignId(BslCid signAlg)
BslCid BSL_OBJ_GetSignIdFromHashAndAsymId(BslCid asymAlg, BslCid hashAlg)
{
if (asymAlg == BSL_CID_ED25519) {
return BSL_CID_ED25519;
}
if (asymAlg == BSL_CID_UNKNOWN || hashAlg == BSL_CID_UNKNOWN) {
return BSL_CID_UNKNOWN;
}
@@ -271,8 +274,8 @@ static int32_t InsertSignIdMapping(int32_t signId, int32_t asymId, int32_t hashI
(void)BSL_SAL_ThreadUnlock(g_signHashRwLock);
return BSL_SUCCESS;
}
ret = BSL_HASH_Insert(g_signHashTable, (uintptr_t)signId, sizeof(BslCid),
(uintptr_t)&newSignIdMap, sizeof(BSL_SignIdMap));
ret = BSL_HASH_Insert(g_signHashTable, (uintptr_t)signId, sizeof(BslCid),
(uintptr_t)&newSignIdMap, sizeof(BSL_SignIdMap));
if (ret != BSL_SUCCESS) {
(void)BSL_SAL_ThreadUnlock(g_signHashRwLock);
BSL_ERR_PUSH_ERROR(BSL_OBJ_ERR_INSERT_HASH_TABLE);
@@ -280,7 +283,7 @@ static int32_t InsertSignIdMapping(int32_t signId, int32_t asymId, int32_t hashI
}
asymAndHashKey = ((uint64_t)asymId << 32) | ((uint64_t)hashId & 0xFFFFFFFF);
ret = BSL_HASH_Insert(g_signHashTable, (uintptr_t)asymAndHashKey, sizeof(uintptr_t),
(uintptr_t)&newSignIdMap, sizeof(BSL_SignIdMap));
(uintptr_t)&newSignIdMap, sizeof(BSL_SignIdMap));
if (ret != BSL_SUCCESS) {
BSL_HASH_Erase(g_signHashTable, (uintptr_t)signId);
(void)BSL_SAL_ThreadUnlock(g_signHashRwLock);
bsl/obj/src/bsl_obj.c
+18 -13
View File
@@ -220,16 +220,16 @@ static int32_t GetOidIndex(int32_t inputCid)
return -1;
}
BslCid BSL_OBJ_GetCIDFromOid(BslOidString *oid)
BslCid BSL_OBJ_GetCID(const BslOidString *oidstr)
{
if (oid == NULL || oid->octs == NULL) {
if (oidstr == NULL || oidstr->octs == NULL) {
return BSL_CID_UNKNOWN;
}
/* First, search in the g_oidTable */
for (uint32_t i = 0; i < g_tableSize; i++) {
if (g_oidTable[i].strOid.octetLen == oid->octetLen) {
if (memcmp(g_oidTable[i].strOid.octs, oid->octs, oid->octetLen) == 0) {
if (g_oidTable[i].strOid.octetLen == oidstr->octetLen) {
if (memcmp(g_oidTable[i].strOid.octs, oidstr->octs, oidstr->octetLen) == 0) {
return g_oidTable[i].cid;
}
}
@@ -256,8 +256,8 @@ BslCid BSL_OBJ_GetCIDFromOid(BslOidString *oid)
while (iter != end) {
BslOidInfo *oidInfo = (BslOidInfo *)BSL_HASH_IterValue(g_oidHashTable, iter);
if (oidInfo != NULL && oidInfo->strOid.octetLen == oid->octetLen &&
memcmp(oidInfo->strOid.octs, oid->octs, oid->octetLen) == 0) {
if (oidInfo != NULL && oidInfo->strOid.octetLen == oidstr->octetLen &&
memcmp(oidInfo->strOid.octs, oidstr->octs, oidstr->octetLen) == 0) {
cid = oidInfo->cid;
break;
}
@@ -269,15 +269,15 @@ BslCid BSL_OBJ_GetCIDFromOid(BslOidString *oid)
#endif // HITLS_BSL_HASH
}
BslOidString *BSL_OBJ_GetOidFromCID(BslCid inputCid)
BslOidString *BSL_OBJ_GetOID(BslCid ulCID)
{
if (inputCid == BSL_CID_UNKNOWN) {
if (ulCID == BSL_CID_UNKNOWN) {
BSL_ERR_PUSH_ERROR(BSL_INVALID_ARG);
return NULL;
}
/* First, search in the g_oidTable */
int32_t index = GetOidIndex(inputCid);
int32_t index = GetOidIndex(ulCID);
if (index != -1) {
return &g_oidTable[index].strOid;
}
@@ -300,7 +300,7 @@ BslOidString *BSL_OBJ_GetOidFromCID(BslCid inputCid)
}
/* Since g_oidHashTable is keyed by cid, we can directly look up the entry */
ret = BSL_HASH_At(g_oidHashTable, (uintptr_t)inputCid, (uintptr_t *)&oidInfo);
ret = BSL_HASH_At(g_oidHashTable, (uintptr_t)ulCID, (uintptr_t *)&oidInfo);
(void)BSL_SAL_ThreadUnlock(g_oidHashRwLock);
BslOidString *oidString = (ret == BSL_SUCCESS && oidInfo != NULL) ? &oidInfo->strOid : NULL;
if (ret != BSL_SUCCESS) {
@@ -458,9 +458,9 @@ static int32_t InsertOidInfoToHashTable(int32_t cid, BslOidInfo *oidInfo)
}
// Main function for creating and registering OIDs
int32_t BSL_OBJ_Create(const BslOidString *oid, const char *oidName, int32_t cid)
int32_t BSL_OBJ_Create(char *octs, uint32_t octetLen, const char *oidName, int32_t cid)
{
if (oid == NULL || oidName == NULL || cid == BSL_CID_UNKNOWN) {
if (octs == NULL || octetLen == 0 || oidName == NULL || cid == BSL_CID_UNKNOWN) {
BSL_ERR_PUSH_ERROR(BSL_INVALID_ARG);
return BSL_INVALID_ARG;
}
@@ -468,6 +468,11 @@ int32_t BSL_OBJ_Create(const BslOidString *oid, const char *oidName, int32_t cid
if (IsOidCidInStaticTable(cid)) {
return BSL_SUCCESS;
}
const BslOidString oid = {
.octs = octs,
.octetLen = octetLen,
.flags = 6
};
int32_t ret = BSL_SAL_ThreadRunOnce(&g_oidHashInitOnce, InitOidHashTableOnce);
if (ret != BSL_SUCCESS) {
@@ -484,7 +489,7 @@ int32_t BSL_OBJ_Create(const BslOidString *oid, const char *oidName, int32_t cid
}
BslOidInfo *oidInfo = NULL;
ret = CreateOidInfo(oid, oidName, cid, &oidInfo);
ret = CreateOidInfo(&oid, oidName, cid, &oidInfo);
if (ret != BSL_SUCCESS) {
return ret;
}
bsl/params/src/bsl_params.c
-4
View File
@@ -99,10 +99,6 @@ static int32_t SetOtherValues(BSL_Param *param, uint32_t type, void *val, uint32
*(uint32_t *)param->value = *(uint32_t *)val;
param->useLen = len;
return BSL_SUCCESS;
case BSL_PARAM_TYPE_OCTETS:
(void)memcpy_s(param->value, len, val, len);
param->useLen = len;
return BSL_SUCCESS;
case BSL_PARAM_TYPE_BOOL:
*(bool *)param->value = *(bool *)val;
param->useLen = len;
codecs/include/decode_local.h
+5 -5
View File
@@ -32,14 +32,14 @@ extern "C" {
/**
* @brief Decoder context structure
*/
typedef struct _Decoder_Method {
typedef struct CRYPT_DECODER_Method {
CRYPT_DECODER_IMPL_NewCtx newCtx; /* New context function */
CRYPT_DECODER_IMPL_SetParam setParam; /* Set parameter function */
CRYPT_DECODER_IMPL_GetParam getParam; /* Get parameter function */
CRYPT_DECODER_IMPL_Decode decode; /* Decode function */
CRYPT_DECODER_IMPL_FreeOutData freeOutData; /* Free output data function */
CRYPT_DECODER_IMPL_FreeCtx freeCtx; /* Free context function */
} Decoder_Method;
} CRYPT_DECODER_Method;
struct CRYPT_DecoderCtx {
/* To get the provider manager context when query */
@@ -50,7 +50,7 @@ struct CRYPT_DecoderCtx {
const char *outFormat; /* Output data format */
const char *outType; /* Output data type */
void *decoderCtx; /* Decoder internal context */
Decoder_Method *method; /* Decoder method */
CRYPT_DECODER_Method *method; /* Decoder method */
int32_t decoderState; /* Decoder state */
};
@@ -60,7 +60,7 @@ typedef struct {
BSL_Param *data; /* Data */
} DataInfo;
typedef struct _CRYPT_DecoderNode {
typedef struct CRYPT_DECODER_Node {
DataInfo inData; /* Input data */
DataInfo outData; /* Output data */
CRYPT_DECODER_Ctx *decoderCtx; /* Decoder context */
@@ -68,7 +68,7 @@ typedef struct _CRYPT_DecoderNode {
#define MAX_CRYPT_DECODE_FORMAT_TYPE_SIZE 128
struct _CRYPT_DECODER_PoolCtx {
struct CRYPT_DECODER_PoolCtx {
CRYPT_EAL_LibCtx *libCtx; /* EAL library context */
const char *attrName; /* Attribute name */
const char *inputFormat; /* Input data format */
codecs/src/decode.c
+2 -5
View File
@@ -68,7 +68,7 @@ int32_t CRYPT_DECODE_ParseDecoderAttr(const char *attrName, DECODER_AttrInfo *in
static int32_t SetDecoderMethod(CRYPT_DECODER_Ctx *ctx, const CRYPT_EAL_Func *funcs)
{
int32_t index = 0;
Decoder_Method *method = BSL_SAL_Calloc(1, sizeof(Decoder_Method));
CRYPT_DECODER_Method *method = BSL_SAL_Calloc(1, sizeof(CRYPT_DECODER_Method));
if (method == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
@@ -116,12 +116,10 @@ CRYPT_DECODER_Ctx *CRYPT_DECODE_NewDecoderCtxByMethod(const CRYPT_EAL_Func *func
}
int32_t ret = CRYPT_EAL_ProviderCtrl(mgrCtx, CRYPT_PROVIDER_GET_USER_CTX, &provCtx, sizeof(provCtx));
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto ERR;
}
ret = SetDecoderMethod(ctx, funcs);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto ERR;
}
if (ctx->method->newCtx == NULL || ctx->method->setParam == NULL) {
@@ -143,7 +141,6 @@ CRYPT_DECODER_Ctx *CRYPT_DECODE_NewDecoderCtxByMethod(const CRYPT_EAL_Func *func
if (attrName != NULL) {
ret = CRYPT_DECODE_ParseDecoderAttr(attrName, &attrInfo);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto ERR;
}
}
@@ -164,7 +161,7 @@ CRYPT_DECODER_Ctx *CRYPT_DECODE_ProviderNewCtx(CRYPT_EAL_LibCtx *libCtx, int32_t
{
const CRYPT_EAL_Func *funcsDecoder = NULL;
CRYPT_EAL_ProvMgrCtx *mgrCtx = NULL;
int32_t ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, CRYPT_EAL_OPERAID_DECODER, keyType, attrName,
int32_t ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, CRYPT_EAL_OPERAID_DECODER, keyType, attrName,
&funcsDecoder, &mgrCtx);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
codecs/src/decode_chain.c
+2 -8
View File
@@ -110,7 +110,7 @@ void CRYPT_DECODE_PoolFreeCtx(CRYPT_DECODER_PoolCtx *poolCtx)
static int32_t SetDecodeType(void *val, size_t valLen, const char **targetValue)
{
if (valLen == 0 ||valLen > MAX_CRYPT_DECODE_FORMAT_TYPE_SIZE) {
if (valLen == 0 || valLen > MAX_CRYPT_DECODE_FORMAT_TYPE_SIZE) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
@@ -419,7 +419,6 @@ int32_t CRYPT_DECODE_ProviderProcessAll(CRYPT_EAL_LibCtx *ctx, CRYPT_DECODE_Prov
};
int32_t ret = CRYPT_EAL_ProviderProcessAll(ctx, ProcessEachProviderDecoder, &processArgs);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
@@ -438,7 +437,6 @@ int32_t CRYPT_DECODE_PoolDecode(CRYPT_DECODER_PoolCtx *poolCtx, const BSL_Param
}
int32_t ret = CRYPT_DECODE_ProviderProcessAll(poolCtx->libCtx, CollectDecoder, poolCtx);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
if (BSL_LIST_COUNT(poolCtx->decoders) == 0) {
@@ -457,11 +455,7 @@ int32_t CRYPT_DECODE_PoolDecode(CRYPT_DECODER_PoolCtx *poolCtx, const BSL_Param
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = DecodeWithKeyChain(poolCtx, outParam);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
return DecodeWithKeyChain(poolCtx, outParam);
}
#endif /* HITLS_CRYPTO_CODECS && HITLS_CRYPTO_PROVIDER */
crypto/bn/include/crypt_bn.h
+1 -1
View File
@@ -848,7 +848,7 @@ int32_t BN_RandRange(BN_BigNum *r, const BN_BigNum *p);
/**
* @ingroup bn
* @brief generate random BigNum
*
*
* @param libCtx [IN] provider libCtx
* @param r [OUT] Generate a random number.
* @param p [IN] Compare data so that the generated r < p
crypto/bn/src/bn_rand.c
+1 -1
View File
@@ -143,7 +143,7 @@ static int32_t InputCheck(BN_BigNum *r, const BN_BigNum *p)
int32_t BN_RandRange(BN_BigNum *r, const BN_BigNum *p)
{
return BN_RandRangeEx(NULL, r, p);
return BN_RandRangeEx(NULL, r, p);
}
int32_t BN_RandRangeEx(void *libCtx, BN_BigNum *r, const BN_BigNum *p)
crypto/codecskey/include/crypt_decode_key_impl.h
+42 -42
View File
@@ -33,65 +33,65 @@ typedef struct {
int32_t DECODER_CommonGetParam(const DECODER_CommonCtx *commonCtx, BSL_Param *param);
void *DECODER_EPki2Pki_NewCtx(void *provCtx);
int32_t DECODER_EPki2Pki_GetParam(void *ctx, BSL_Param *param);
int32_t DECODER_EPki2Pki_SetParam(void *ctx, const BSL_Param *param);
int32_t DECODER_EPki2Pki_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
void DECODER_EPki2Pki_FreeOutData(void *ctx, BSL_Param *outParam);
void DECODER_EPki2Pki_FreeCtx(void *ctx);
void *DECODER_EPKI2PKI_NewCtx(void *provCtx);
int32_t DECODER_EPKI2PKI_GetParam(void *ctx, BSL_Param *param);
int32_t DECODER_EPKI2PKI_SetParam(void *ctx, const BSL_Param *param);
int32_t DECODER_EPKI2PKI_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
void DECODER_EPKI2PKI_FreeOutData(void *ctx, BSL_Param *outParam);
void DECODER_EPKI2PKI_FreeCtx(void *ctx);
int32_t DECODER_Der2Key_GetParam(void *ctx, BSL_Param *param);
int32_t DECODER_Der2Key_SetParam(void *ctx, const BSL_Param *param);
void DECODER_Der2Key_FreeOutData(void *ctx, BSL_Param *outParam);
void DECODER_Der2Key_FreeCtx(void *ctx);
int32_t DECODER_DER2KEY_GetParam(void *ctx, BSL_Param *param);
int32_t DECODER_DER2KEY_SetParam(void *ctx, const BSL_Param *param);
void DECODER_DER2KEY_FreeOutData(void *ctx, BSL_Param *outParam);
void DECODER_DER2KEY_FreeCtx(void *ctx);
#ifdef HITLS_CRYPTO_RSA
void *DECODER_RsaDer2Key_NewCtx(void *provCtx);
int32_t DECODER_RsaPrvKeyDer2Key_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_RsaPubKeyDer2Key_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_RsaSubPubKeyDer2Key_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_RsaSubPubKeyWithOutSeqDer2Key_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_RsaPkcs8Der2Key_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
void *DECODER_RsaDer2KeyNewCtx(void *provCtx);
int32_t DECODER_RsaPrvKeyDer2KeyDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_RsaPubKeyDer2KeyDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_RsaSubPubKeyDer2KeyDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_RsaSubPubKeyWithOutSeqDer2KeyDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_RsaPkcs8Der2KeyDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
#endif
#ifdef HITLS_CRYPTO_ECDSA
void *DECODER_EcdsaDer2Key_NewCtx(void *provCtx);
int32_t DECODER_EcdsaPrvKeyDer2Key_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_EcdsaSubPubKeyDer2Key_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_EcdsaSubPubKeyWithOutSeqDer2Key_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_EcdsaPkcs8Der2Key_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
void *DECODER_EcdsaDer2KeyNewCtx(void *provCtx);
int32_t DECODER_EcdsaPrvKeyDer2KeyDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_EcdsaSubPubKeyDer2KeyDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_EcdsaSubPubKeyWithOutSeqDer2KeyDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_EcdsaPkcs8Der2KeyDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
#endif
#ifdef HITLS_CRYPTO_SM2
void *DECODER_Sm2Der2Key_NewCtx(void *provCtx);
int32_t DECODER_Sm2PrvKeyDer2Key_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_Sm2SubPubKeyDer2Key_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_Sm2SubPubKeyWithOutSeqDer2Key_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_Sm2Pkcs8Der2Key_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
void *DECODER_Sm2Der2KeyNewCtx(void *provCtx);
int32_t DECODER_Sm2PrvKeyDer2KeyDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_Sm2SubPubKeyDer2KeyDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_Sm2SubPubKeyWithOutSeqDer2KeyDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_Sm2Pkcs8Der2KeyDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
#endif
#ifdef HITLS_CRYPTO_ED25519
void *DECODER_Ed25519Der2Key_NewCtx(void *provCtx);
int32_t DECODER_Ed25519SubPubKeyDer2Key_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_Ed25519SubPubKeyWithOutSeqDer2Key_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_Ed25519Pkcs8Der2Key_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
void *DECODER_Ed25519Der2KeyNewCtx(void *provCtx);
int32_t DECODER_Ed25519SubPubKeyDer2KeyDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_Ed25519SubPubKeyWithOutSeqDer2KeyDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
int32_t DECODER_Ed25519Pkcs8Der2KeyDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
#endif
#ifdef HITLS_BSL_PEM
void *DECODER_Pem2Der_NewCtx(void *provCtx);
int32_t DECODER_Pem2Der_GetParam(void *ctx, BSL_Param *param);
int32_t DECODER_Pem2Der_SetParam(void *ctx, const BSL_Param *param);
int32_t DECODER_Pem2Der_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
void DECODER_Pem2Der_FreeOutData(void *ctx, BSL_Param *outParam);
void DECODER_Pem2Der_FreeCtx(void *ctx);
void *DECODER_Pem2DerNewCtx(void *provCtx);
int32_t DECODER_Pem2DerGetParam(void *ctx, BSL_Param *param);
int32_t DECODER_Pem2DerSetParam(void *ctx, const BSL_Param *param);
int32_t DECODER_Pem2DerDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
void DECODER_Pem2DerFreeOutData(void *ctx, BSL_Param *outParam);
void DECODER_Pem2DerFreeCtx(void *ctx);
#endif
void *DECODER_LowKeyObject2PkeyObject_NewCtx(void *provCtx);
int32_t DECODER_LowKeyObject2PkeyObject_SetParam(void *ctx, const BSL_Param *param);
int32_t DECODER_LowKeyObject2PkeyObject_GetParam(void *ctx, BSL_Param *param);
int32_t DECODER_LowKeyObject2PkeyObject_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
void DECODER_LowKeyObject2PkeyObject_FreeOutData(void *ctx, BSL_Param *outParam);
void DECODER_LowKeyObject2PkeyObject_FreeCtx(void *ctx);
void *DECODER_LowKeyObject2PkeyObjectNewCtx(void *provCtx);
int32_t DECODER_LowKeyObject2PkeyObjectSetParam(void *ctx, const BSL_Param *param);
int32_t DECODER_LowKeyObject2PkeyObjectGetParam(void *ctx, BSL_Param *param);
int32_t DECODER_LowKeyObject2PkeyObjectDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam);
void DECODER_LowKeyObject2PkeyObjectFreeOutData(void *ctx, BSL_Param *outParam);
void DECODER_LowKeyObject2PkeyObjectFreeCtx(void *ctx);
#endif /* HITLS_CRYPTO_CODECSKEY */
crypto/codecskey/include/crypt_encode_decode_key.h
+6
View File
@@ -68,6 +68,12 @@ int32_t CRYPT_EAL_EncodeRsaPssAlgParam(const CRYPT_RSA_PssPara *rsaPssParam, uin
#endif // HITLS_CRYPTO_KEY_ENCODE
#if defined(HITLS_CRYPTO_RSA) && defined(HITLS_CRYPTO_KEY_DECODE)
int32_t CRYPT_EAL_InitRsaPrv(const CRYPT_EAL_PkeyCtx *ealPriKey, CRYPT_PKEY_AlgId cid, CRYPT_EAL_PkeyPrv *rsaPrv);
void CRYPT_EAL_DeinitRsaPrv(CRYPT_EAL_PkeyPrv *rsaPrv);
int32_t CRYPT_EAL_GetRsaPssPara(CRYPT_EAL_PkeyCtx *ealPriKey, CRYPT_RSA_PssPara *rsaPssParam);
#endif
#ifdef HITLS_PKI_PKCS12_PARSE
// parse PKCS7-EncryptData：only support PBES2 + PBKDF2.
int32_t CRYPT_EAL_ParseAsn1PKCS7EncryptedData(CRYPT_EAL_LibCtx *libCtx, const char *attrName, BSL_Buffer *encode,
crypto/codecskey/src/crypt_decode_der2key.c
+29 -26
View File
@@ -50,12 +50,12 @@ typedef struct {
int32_t keyAlgId;
const char *outFormat;
const char *outType;
} DECODER_Der2Key_Ctx;
} DECODER_Der2KeyCtx;
DECODER_Der2Key_Ctx *DECODER_Der2Key_NewCtx(void *provCtx)
DECODER_Der2KeyCtx *DECODER_DER2KEY_NewCtx(void *provCtx)
{
(void)provCtx;
DECODER_Der2Key_Ctx *ctx = (DECODER_Der2Key_Ctx *)BSL_SAL_Calloc(1, sizeof(DECODER_Der2Key_Ctx));
DECODER_Der2KeyCtx *ctx = (DECODER_Der2KeyCtx *)BSL_SAL_Calloc(1, sizeof(DECODER_Der2KeyCtx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
@@ -66,9 +66,9 @@ DECODER_Der2Key_Ctx *DECODER_Der2Key_NewCtx(void *provCtx)
}
#define DECODER_DEFINE_DER2KEY_NEW_CTX(keyType, keyId, keyMethod, asyCipherMethod, exchMethod, signMethod, kemMethod) \
void *DECODER_##keyType##Der2Key_NewCtx(void *provCtx) \
void *DECODER_##keyType##Der2KeyNewCtx(void *provCtx) \
{ \
DECODER_Der2Key_Ctx *ctx = DECODER_Der2Key_NewCtx(provCtx); \
DECODER_Der2KeyCtx *ctx = DECODER_DER2KEY_NewCtx(provCtx); \
if (ctx == NULL) { \
return NULL; \
} \
@@ -107,9 +107,9 @@ int32_t DECODER_CommonGetParam(const DECODER_CommonCtx *commonCtx, BSL_Param *pa
return CRYPT_SUCCESS;
}
int32_t DECODER_Der2Key_GetParam(void *ctx, BSL_Param *param)
int32_t DECODER_DER2KEY_GetParam(void *ctx, BSL_Param *param)
{
DECODER_Der2Key_Ctx *decoderCtx = (DECODER_Der2Key_Ctx *)ctx;
DECODER_Der2KeyCtx *decoderCtx = (DECODER_Der2KeyCtx *)ctx;
if (decoderCtx == NULL || param == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
@@ -121,9 +121,9 @@ int32_t DECODER_Der2Key_GetParam(void *ctx, BSL_Param *param)
return DECODER_CommonGetParam(&commonCtx, param);
}
int32_t DECODER_Der2Key_SetParam(void *ctx, const BSL_Param *param)
int32_t DECODER_DER2KEY_SetParam(void *ctx, const BSL_Param *param)
{
DECODER_Der2Key_Ctx *decoderCtx = (DECODER_Der2Key_Ctx *)ctx;
DECODER_Der2KeyCtx *decoderCtx = (DECODER_Der2KeyCtx *)ctx;
if (decoderCtx == NULL || param == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
@@ -141,7 +141,7 @@ int32_t DECODER_Der2Key_SetParam(void *ctx, const BSL_Param *param)
return CRYPT_SUCCESS;
}
static int32_t CheckParams(DECODER_Der2Key_Ctx *decoderCtx, const BSL_Param *inParam, BSL_Param **outParam,
static int32_t CheckParams(DECODER_Der2KeyCtx *decoderCtx, const BSL_Param *inParam, BSL_Param **outParam,
BSL_Buffer *asn1Encode)
{
if (decoderCtx == NULL || inParam == NULL || outParam == NULL) {
@@ -165,14 +165,14 @@ static int32_t CheckParams(DECODER_Der2Key_Ctx *decoderCtx, const BSL_Param *inP
#define DECODER_CHECK_PARAMS(ctx, inParam, outParam) \
void *key = NULL; \
BSL_Buffer asn1Encode = {0}; \
DECODER_Der2Key_Ctx *decoderCtx = (DECODER_Der2Key_Ctx *)ctx; \
DECODER_Der2KeyCtx *decoderCtx = (DECODER_Der2KeyCtx *)ctx; \
int32_t ret = CheckParams(decoderCtx, inParam, outParam, &asn1Encode); \
if (ret != CRYPT_SUCCESS) { \
BSL_ERR_PUSH_ERROR(ret); \
return ret; \
}
static int32_t ConstructOutputParams(DECODER_Der2Key_Ctx *decoderCtx, void *key, BSL_Param **outParam)
static int32_t ConstructOutputParams(DECODER_Der2KeyCtx *decoderCtx, void *key, BSL_Param **outParam)
{
BSL_Param *result = BSL_SAL_Calloc(7, sizeof(BSL_Param));
if (result == NULL) {
@@ -225,7 +225,7 @@ EXIT:
}
#define DECODER_DEFINE_PRVKEY_DER2KEY_DECODE(keyType, keyStructName, parseFunc) \
int32_t DECODER_##keyType##PrvKeyDer2Key_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam) \
int32_t DECODER_##keyType##PrvKeyDer2KeyDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam) \
{ \
DECODER_CHECK_PARAMS(ctx, inParam, outParam); \
ret = parseFunc(asn1Encode.data, asn1Encode.dataLen, NULL, (keyStructName **)&key); \
@@ -237,7 +237,7 @@ int32_t DECODER_##keyType##PrvKeyDer2Key_Decode(void *ctx, const BSL_Param *inPa
}
#define DECODER_DEFINE_PUBKEY_DER2KEY_DECODE(keyType, keyStructName, parseFunc) \
int32_t DECODER_##keyType##PubKeyDer2Key_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam) \
int32_t DECODER_##keyType##PubKeyDer2KeyDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam) \
{ \
DECODER_CHECK_PARAMS(ctx, inParam, outParam); \
ret = parseFunc(asn1Encode.data, asn1Encode.dataLen, NULL, (keyStructName **)&key, BSL_CID_UNKNOWN); \
@@ -249,7 +249,7 @@ int32_t DECODER_##keyType##PubKeyDer2Key_Decode(void *ctx, const BSL_Param *inPa
}
#define DECODER_DEFINE_SUBPUBKEY_DER2KEY_DECODE(keyType, keyStructName, parseFunc) \
int32_t DECODER_##keyType##SubPubKeyDer2Key_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam) \
int32_t DECODER_##keyType##SubPubKeyDer2KeyDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam) \
{ \
DECODER_CHECK_PARAMS(ctx, inParam, outParam) \
ret = parseFunc(asn1Encode.data, asn1Encode.dataLen, (keyStructName **)&key, true); \
@@ -261,7 +261,7 @@ int32_t DECODER_##keyType##SubPubKeyDer2Key_Decode(void *ctx, const BSL_Param *i
}
#define DECODER_DEFINE_SUBPUBKEY_WITHOUT_SEQ_DER2KEY_DECODE(keyType, keyStructName, parseFunc) \
int32_t DECODER_##keyType##SubPubKeyWithOutSeqDer2Key_Decode(void *ctx, const BSL_Param *inParam, \
int32_t DECODER_##keyType##SubPubKeyWithOutSeqDer2KeyDecode(void *ctx, const BSL_Param *inParam, \
BSL_Param **outParam) \
{ \
DECODER_CHECK_PARAMS(ctx, inParam, outParam) \
@@ -274,7 +274,7 @@ int32_t DECODER_##keyType##SubPubKeyWithOutSeqDer2Key_Decode(void *ctx, const BS
}
#define DECODER_DEFINE_PKCS8_DECODE(keyType, keyStructName, parseFunc) \
int32_t DECODER_##keyType##Pkcs8Der2Key_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam) \
int32_t DECODER_##keyType##Pkcs8Der2KeyDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam) \
{ \
DECODER_CHECK_PARAMS(ctx, inParam, outParam) \
ret = parseFunc(asn1Encode.data, asn1Encode.dataLen, (keyStructName **)&key); \
@@ -285,9 +285,9 @@ int32_t DECODER_##keyType##Pkcs8Der2Key_Decode(void *ctx, const BSL_Param *inPar
return ConstructOutputParams(decoderCtx, key, outParam); \
}
void DECODER_Der2Key_FreeOutData(void *ctx, BSL_Param *outData)
void DECODER_DER2KEY_FreeOutData(void *ctx, BSL_Param *outData)
{
DECODER_Der2Key_Ctx *decoderCtx = ctx;
DECODER_Der2KeyCtx *decoderCtx = ctx;
if (decoderCtx == NULL || outData == NULL) {
return;
}
@@ -302,12 +302,12 @@ void DECODER_Der2Key_FreeOutData(void *ctx, BSL_Param *outData)
BSL_SAL_Free(outData);
}
void DECODER_Der2Key_FreeCtx(void *ctx)
void DECODER_DER2KEY_FreeCtx(void *ctx)
{
if (ctx == NULL) {
return;
}
DECODER_Der2Key_Ctx *decoderCtx = (DECODER_Der2Key_Ctx *)ctx;
DECODER_Der2KeyCtx *decoderCtx = (DECODER_Der2KeyCtx *)ctx;
if (decoderCtx->method != NULL) {
BSL_SAL_Free(decoderCtx->method);
}
@@ -316,17 +316,20 @@ void DECODER_Der2Key_FreeCtx(void *ctx)
#endif
#ifdef HITLS_CRYPTO_RSA
DECODER_DEFINE_DER2KEY_NEW_CTX(Rsa, CRYPT_PKEY_RSA, g_defKeyMgmtRsa, g_defAsymCipherRsa, NULL, g_defSignRsa, NULL)
DECODER_DEFINE_DER2KEY_NEW_CTX(Rsa, CRYPT_PKEY_RSA, g_defEalKeyMgmtRsa, g_defEalAsymCipherRsa, NULL, \
g_defEalSignRsa, NULL)
#endif
#ifdef HITLS_CRYPTO_ECDSA
DECODER_DEFINE_DER2KEY_NEW_CTX(Ecdsa, CRYPT_PKEY_ECDSA, g_defKeyMgmtEcdsa, NULL, NULL, g_defSignEcdsa, NULL)
DECODER_DEFINE_DER2KEY_NEW_CTX(Ecdsa, CRYPT_PKEY_ECDSA, g_defEalKeyMgmtEcdsa, NULL, NULL, \
g_defEalSignEcdsa, NULL)
#endif
#ifdef HITLS_CRYPTO_SM2
DECODER_DEFINE_DER2KEY_NEW_CTX(Sm2, CRYPT_PKEY_SM2, g_defKeyMgmtSm2, g_defAsymCipherSm2, g_defExchSm2, g_defSignSm2, \
NULL)
DECODER_DEFINE_DER2KEY_NEW_CTX(Sm2, CRYPT_PKEY_SM2, g_defEalKeyMgmtSm2, g_defEalAsymCipherSm2, g_defEalExchSm2, \
g_defEalSignSm2, NULL)
#endif
#ifdef HITLS_CRYPTO_ED25519
DECODER_DEFINE_DER2KEY_NEW_CTX(Ed25519, CRYPT_PKEY_ED25519, g_defKeyMgmtEd25519, NULL, NULL, g_defSignEd25519, NULL)
DECODER_DEFINE_DER2KEY_NEW_CTX(Ed25519, CRYPT_PKEY_ED25519, g_defEalKeyMgmtEd25519, NULL, NULL, \
g_defEalSignEd25519, NULL)
#endif
#ifdef HITLS_CRYPTO_RSA
crypto/codecskey/src/crypt_decode_ecc.c
+2 -2
View File
@@ -46,7 +46,7 @@ typedef struct {
static int32_t GetParaId(uint8_t *octs, uint32_t octsLen)
{
BslOidString oidStr = {octsLen, (char *)octs, 0};
BslCid cid = BSL_OBJ_GetCIDFromOid(&oidStr);
BslCid cid = BSL_OBJ_GetCID(&oidStr);
if (cid == BSL_CID_UNKNOWN) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_ERR_ALGID);
return CRYPT_PKEY_PARAID_MAX;
@@ -257,7 +257,7 @@ int32_t CRYPT_SM2_ParseSubPubkeyAsn1Buff(uint8_t *buff, uint32_t buffLen, CRYPT_
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
if (subPubkeyInfo.keyType != BSL_CID_EC_PUBLICKEY) {
if (subPubkeyInfo.keyType != BSL_CID_EC_PUBLICKEY && subPubkeyInfo.keyType != BSL_CID_SM2PRIME256) {
BSL_ERR_PUSH_ERROR(CRYPT_DECODE_ERR_KEY_TYPE_NOT_MATCH);
return CRYPT_DECODE_ERR_KEY_TYPE_NOT_MATCH;
}
crypto/codecskey/src/crypt_decode_epki2pki.c
+12 -12
View File
@@ -26,17 +26,17 @@
#include "crypt_encode_decode_local.h"
#include "crypt_decode_key_impl.h"
typedef struct _DECODER_EPki2Pki_Ctx {
typedef struct DECODER_EPki2PkiCtx {
CRYPT_EAL_LibCtx *libCtx;
const char *attrName;
const char *outFormat;
const char *outType;
} DECODER_EPki2Pki_Ctx;
} DECODER_EPki2PkiCtx;
void *DECODER_EPki2Pki_NewCtx(void *provCtx)
void *DECODER_EPKI2PKI_NewCtx(void *provCtx)
{
(void)provCtx;
DECODER_EPki2Pki_Ctx *ctx = (DECODER_EPki2Pki_Ctx *)BSL_SAL_Calloc(1, sizeof(DECODER_EPki2Pki_Ctx));
DECODER_EPki2PkiCtx *ctx = (DECODER_EPki2PkiCtx *)BSL_SAL_Calloc(1, sizeof(DECODER_EPki2PkiCtx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
@@ -46,9 +46,9 @@ void *DECODER_EPki2Pki_NewCtx(void *provCtx)
return ctx;
}
int32_t DECODER_EPki2Pki_GetParam(void *ctx, BSL_Param *param)
int32_t DECODER_EPKI2PKI_GetParam(void *ctx, BSL_Param *param)
{
DECODER_EPki2Pki_Ctx *decoderCtx = (DECODER_EPki2Pki_Ctx *)ctx;
DECODER_EPki2PkiCtx *decoderCtx = (DECODER_EPki2PkiCtx *)ctx;
if (decoderCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
@@ -60,9 +60,9 @@ int32_t DECODER_EPki2Pki_GetParam(void *ctx, BSL_Param *param)
return DECODER_CommonGetParam(&commonCtx, param);
}
int32_t DECODER_EPki2Pki_SetParam(void *ctx, const BSL_Param *param)
int32_t DECODER_EPKI2PKI_SetParam(void *ctx, const BSL_Param *param)
{
DECODER_EPki2Pki_Ctx *decoderCtx = (DECODER_EPki2Pki_Ctx *)ctx;
DECODER_EPki2PkiCtx *decoderCtx = (DECODER_EPki2PkiCtx *)ctx;
if (decoderCtx == NULL || param == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
@@ -86,9 +86,9 @@ int32_t DECODER_EPki2Pki_SetParam(void *ctx, const BSL_Param *param)
return CRYPT_SUCCESS;
}
int32_t DECODER_EPki2Pki_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam)
int32_t DECODER_EPKI2PKI_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam)
{
DECODER_EPki2Pki_Ctx *decoderCtx = (DECODER_EPki2Pki_Ctx *)ctx;
DECODER_EPki2PkiCtx *decoderCtx = (DECODER_EPki2PkiCtx *)ctx;
if (decoderCtx == NULL || inParam == NULL || outParam == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
@@ -115,7 +115,7 @@ int32_t DECODER_EPki2Pki_Decode(void *ctx, const BSL_Param *inParam, BSL_Param *
return CRYPT_DECODE_ConstructBufferOutParam(outParam, decode.data, decode.dataLen);
}
void DECODER_EPki2Pki_FreeCtx(void *ctx)
void DECODER_EPKI2PKI_FreeCtx(void *ctx)
{
if (ctx == NULL) {
return;
@@ -123,7 +123,7 @@ void DECODER_EPki2Pki_FreeCtx(void *ctx)
BSL_SAL_Free(ctx);
}
void DECODER_EPki2Pki_FreeOutData(void *ctx, BSL_Param *outParam)
void DECODER_EPKI2PKI_FreeOutData(void *ctx, BSL_Param *outParam)
{
(void)ctx;
if (outParam == NULL) {
crypto/codecskey/src/crypt_decode_lowkey2pkey.c
+23 -32
View File
@@ -21,6 +21,7 @@
#include "crypt_params_key.h"
#include "crypt_types.h"
#include "crypt_errno.h"
#include "crypt_utils.h"
#include "eal_pkey.h"
#include "crypt_decode_key_impl.h"
#include "bsl_err_internal.h"
@@ -30,12 +31,12 @@ typedef struct {
const char *targetAttrName;
const char *outFormat;
const char *outType;
} DECODER_Lowkey2Pkey_Ctx;
} DECODER_Lowkey2PkeyCtx;
void *DECODER_LowKeyObject2PkeyObject_NewCtx(void *provCtx)
void *DECODER_LowKeyObject2PkeyObjectNewCtx(void *provCtx)
{
(void)provCtx;
DECODER_Lowkey2Pkey_Ctx *ctx = (DECODER_Lowkey2Pkey_Ctx *)BSL_SAL_Calloc(1, sizeof(DECODER_Lowkey2Pkey_Ctx));
DECODER_Lowkey2PkeyCtx *ctx = (DECODER_Lowkey2PkeyCtx *)BSL_SAL_Calloc(1, sizeof(DECODER_Lowkey2PkeyCtx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
@@ -46,9 +47,9 @@ void *DECODER_LowKeyObject2PkeyObject_NewCtx(void *provCtx)
return (void *)ctx;
}
int32_t DECODER_LowKeyObject2PkeyObject_SetParam(void *ctx, const BSL_Param *param)
int32_t DECODER_LowKeyObject2PkeyObjectSetParam(void *ctx, const BSL_Param *param)
{
DECODER_Lowkey2Pkey_Ctx *decoderCtx = (DECODER_Lowkey2Pkey_Ctx *)ctx;
DECODER_Lowkey2PkeyCtx *decoderCtx = (DECODER_Lowkey2PkeyCtx *)ctx;
if (decoderCtx == NULL || param == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
@@ -73,9 +74,9 @@ int32_t DECODER_LowKeyObject2PkeyObject_SetParam(void *ctx, const BSL_Param *par
return CRYPT_SUCCESS;
}
int32_t DECODER_LowKeyObject2PkeyObject_GetParam(void *ctx, BSL_Param *param)
int32_t DECODER_LowKeyObject2PkeyObjectGetParam(void *ctx, BSL_Param *param)
{
DECODER_Lowkey2Pkey_Ctx *decoderCtx = (DECODER_Lowkey2Pkey_Ctx *)ctx;
DECODER_Lowkey2PkeyCtx *decoderCtx = (DECODER_Lowkey2PkeyCtx *)ctx;
if (decoderCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
@@ -86,10 +87,10 @@ int32_t DECODER_LowKeyObject2PkeyObject_GetParam(void *ctx, BSL_Param *param)
};
return DECODER_CommonGetParam(&commonCtx, param);
}
typedef struct _LowKeyObjectMethodInfo {
typedef struct LowKeyObjectMethodInfo {
CRYPT_EAL_ImplPkeyMgmtExport export;
CRYPT_EAL_ImplPkeyMgmtDupCtx dupCtx;
CRYPT_EAL_ImplPkeyMgmtFreeCtx freeCtx;
CRYPT_EAL_ImplPkeyMgmtFreeCtx freeCtx;
} LowKeyObjectMethodInfo;
static int32_t GetLowKeyObjectInfo(const BSL_Param *inParam, void **object, int32_t *objectType,
@@ -123,7 +124,7 @@ static int32_t GetLowKeyObjectInfo(const BSL_Param *inParam, void **object, int3
if (lowObjectRef->value == NULL || lowObjectRefType->value == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
}
*object = (void *)(uintptr_t)lowObjectRef->value;
*objectType = *((int32_t *)(uintptr_t)lowObjectRefType->value);
method->export = (CRYPT_EAL_ImplPkeyMgmtExport)(uintptr_t)exportFunc->value;
@@ -196,8 +197,8 @@ static int32_t TransLowKeyToTargetLowKey(CRYPT_EAL_PkeyMgmtInfo *pkeyAlgInfo, co
return CRYPT_NULL_INPUT;
}
BSL_Param param[3] = {
{CRYPT_PARAM_PKEY_PROCESS_FUNC, BSL_PARAM_TYPE_FUNC_PTR, ImportTargetPkey, 0, 0},
{CRYPT_PARAM_PKEY_PROCESS_ARGS, BSL_PARAM_TYPE_CTX_PTR, &importTargetPkeyArgs, 0, 0},
{CRYPT_PARAM_PKEY_PROCESS_FUNC, BSL_PARAM_TYPE_FUNC_PTR, ImportTargetPkey, 0, 0},
{CRYPT_PARAM_PKEY_PROCESS_ARGS, BSL_PARAM_TYPE_CTX_PTR, &importTargetPkeyArgs, 0, 0},
BSL_PARAM_END
};
int32_t ret = method->export(lowObjectRef, param);
@@ -244,38 +245,28 @@ static int32_t ConstructOutObjectParam(BSL_Param **outParam, void *object)
}
/* input is pem format buffer, output is der format buffer */
int32_t DECODER_LowKeyObject2PkeyObject_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam)
int32_t DECODER_LowKeyObject2PkeyObjectDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam)
{
if (ctx == NULL || inParam == NULL || outParam == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
DECODER_Lowkey2Pkey_Ctx *decoderCtx = (DECODER_Lowkey2Pkey_Ctx *)ctx;
DECODER_Lowkey2PkeyCtx *decoderCtx = (DECODER_Lowkey2PkeyCtx *)ctx;
void *lowObjectRef = NULL;
int32_t lowObjectRefType = 0;
CRYPT_EAL_ProvMgrCtx *lastDecoderProviderCtx = NULL;
LowKeyObjectMethodInfo method = {0};
void *targetKeyRef = NULL;
CRYPT_EAL_PkeyMgmtInfo pkeyAlgInfo = {0};
int32_t ret = GetLowKeyObjectInfo(inParam, &lowObjectRef, &lowObjectRefType, &method);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
int32_t ret = 0;
RETURN_RET_IF_ERR(GetLowKeyObjectInfo(inParam, &lowObjectRef, &lowObjectRefType, &method), ret);
if (method.freeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
ret = GetProviderInfo(inParam, &lastDecoderProviderCtx);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = CRYPT_EAL_GetPkeyAlgInfo(decoderCtx->libCtx, lowObjectRefType, decoderCtx->targetAttrName, &pkeyAlgInfo);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
RETURN_RET_IF_ERR(GetProviderInfo(inParam, &lastDecoderProviderCtx), ret);
RETURN_RET_IF_ERR(CRYPT_EAL_GetPkeyAlgInfo(decoderCtx->libCtx, lowObjectRefType, decoderCtx->targetAttrName,
&pkeyAlgInfo), ret);
if (pkeyAlgInfo.mgrCtx != lastDecoderProviderCtx) {
ret = TransLowKeyToTargetLowKey(&pkeyAlgInfo, &method, lowObjectRef, &targetKeyRef);
} else {
@@ -304,9 +295,9 @@ EXIT:
return ret;
}
void DECODER_LowKeyObject2PkeyObject_FreeOutData(void *ctx, BSL_Param *outParam)
void DECODER_LowKeyObject2PkeyObjectFreeOutData(void *ctx, BSL_Param *outParam)
{
DECODER_Lowkey2Pkey_Ctx *decoderCtx = (DECODER_Lowkey2Pkey_Ctx *)ctx;
DECODER_Lowkey2PkeyCtx *decoderCtx = (DECODER_Lowkey2PkeyCtx *)ctx;
if (outParam == NULL || decoderCtx == NULL) {
return;
}
@@ -320,7 +311,7 @@ void DECODER_LowKeyObject2PkeyObject_FreeOutData(void *ctx, BSL_Param *outParam)
BSL_SAL_Free(outParam);
}
void DECODER_LowKeyObject2PkeyObject_FreeCtx(void *ctx)
void DECODER_LowKeyObject2PkeyObjectFreeCtx(void *ctx)
{
if (ctx == NULL) {
return;
crypto/codecskey/src/crypt_decode_pem2der.c
+10 -10
View File
@@ -31,12 +31,12 @@ typedef struct {
void *provCtx;
const char *outFormat;
const char *outType;
} DECODER_Pem2Der_Ctx;
} DECODER_Pem2DerCtx;
void *DECODER_Pem2Der_NewCtx(void *provCtx)
void *DECODER_Pem2DerNewCtx(void *provCtx)
{
(void)provCtx;
DECODER_Pem2Der_Ctx *ctx = (DECODER_Pem2Der_Ctx *)BSL_SAL_Calloc(1, sizeof(DECODER_Pem2Der_Ctx));
DECODER_Pem2DerCtx *ctx = (DECODER_Pem2DerCtx *)BSL_SAL_Calloc(1, sizeof(DECODER_Pem2DerCtx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
@@ -47,9 +47,9 @@ void *DECODER_Pem2Der_NewCtx(void *provCtx)
return ctx;
}
int32_t DECODER_Pem2Der_GetParam(void *ctx, BSL_Param *param)
int32_t DECODER_Pem2DerGetParam(void *ctx, BSL_Param *param)
{
DECODER_Pem2Der_Ctx *decoderCtx = (DECODER_Pem2Der_Ctx *)ctx;
DECODER_Pem2DerCtx *decoderCtx = (DECODER_Pem2DerCtx *)ctx;
if (decoderCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
@@ -61,7 +61,7 @@ int32_t DECODER_Pem2Der_GetParam(void *ctx, BSL_Param *param)
return DECODER_CommonGetParam(&commonCtx, param);
}
int32_t DECODER_Pem2Der_SetParam(void *ctx, const BSL_Param *param)
int32_t DECODER_Pem2DerSetParam(void *ctx, const BSL_Param *param)
{
(void)ctx;
(void)param;
@@ -69,7 +69,7 @@ int32_t DECODER_Pem2Der_SetParam(void *ctx, const BSL_Param *param)
}
/* input is pem format buffer, output is der format buffer */
int32_t DECODER_Pem2Der_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam)
int32_t DECODER_Pem2DerDecode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam)
{
if (ctx == NULL || inParam == NULL || outParam == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
@@ -77,7 +77,7 @@ int32_t DECODER_Pem2Der_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **
}
BSL_PEM_Symbol symbol = {0};
char *dataType = NULL;
DECODER_Pem2Der_Ctx *decoderCtx = (DECODER_Pem2Der_Ctx *)ctx;
DECODER_Pem2DerCtx *decoderCtx = (DECODER_Pem2DerCtx *)ctx;
const BSL_Param *input = BSL_PARAM_FindConstParam(inParam, CRYPT_PARAM_DECODE_BUFFER_DATA);
if (input == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
@@ -106,7 +106,7 @@ int32_t DECODER_Pem2Der_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **
return CRYPT_DECODE_ConstructBufferOutParam(outParam, asn1Encode, asn1Len);
}
void DECODER_Pem2Der_FreeOutData(void *ctx, BSL_Param *outParam)
void DECODER_Pem2DerFreeOutData(void *ctx, BSL_Param *outParam)
{
(void)ctx;
if (outParam == NULL) {
@@ -122,7 +122,7 @@ void DECODER_Pem2Der_FreeOutData(void *ctx, BSL_Param *outParam)
BSL_SAL_Free(outParam);
}
void DECODER_Pem2Der_FreeCtx(void *ctx)
void DECODER_Pem2DerFreeCtx(void *ctx)
{
if (ctx == NULL) {
return;
crypto/codecskey/src/crypt_decode_pkey.c
+2 -11
View File
@@ -40,12 +40,10 @@ static int32_t SetDecodePoolParamForKey(CRYPT_DECODER_PoolCtx *poolCtx, char *ta
int32_t ret = CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_FORMAT, targetFormat,
strlen(targetFormat));
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_TARGET_TYPE, targetType, strlen(targetType));
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
@@ -70,10 +68,8 @@ static int32_t GetObjectFromOutData(BSL_Param *outData, void **object)
int32_t CRYPT_EAL_ProviderDecodeBuffKeyInner(CRYPT_EAL_LibCtx *libCtx, const char *attrName, int32_t keyType,
const char *format, const char *type, BSL_Buffer *encode, const BSL_Buffer *pwd, CRYPT_EAL_PkeyCtx **ealPKey)
{
CRYPT_DECODER_PoolCtx *poolCtx = NULL;
char *targetType = "HIGH_KEY";
char *targetFormat = "OBJECT";
int32_t ret;
uint32_t index = 0;
BSL_Param *outParam = NULL;
bool isFreeOutData = false;
@@ -83,14 +79,12 @@ int32_t CRYPT_EAL_ProviderDecodeBuffKeyInner(CRYPT_EAL_LibCtx *libCtx, const cha
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
poolCtx = CRYPT_DECODE_PoolNewCtx(libCtx, attrName, keyType, format, type);
CRYPT_DECODER_PoolCtx *poolCtx = CRYPT_DECODE_PoolNewCtx(libCtx, attrName, keyType, format, type);
if (poolCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
ret = SetDecodePoolParamForKey(poolCtx, targetType, targetFormat);
int32_t ret = SetDecodePoolParamForKey(poolCtx, targetType, targetFormat);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
(void)BSL_PARAM_InitValue(&input[index++], CRYPT_PARAM_DECODE_BUFFER_DATA, BSL_PARAM_TYPE_OCTETS, encode->data,
@@ -101,12 +95,10 @@ int32_t CRYPT_EAL_ProviderDecodeBuffKeyInner(CRYPT_EAL_LibCtx *libCtx, const cha
}
ret = CRYPT_DECODE_PoolDecode(poolCtx, input, &outParam);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = GetObjectFromOutData(outParam, (void **)(&tmpPKey));
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
int32_t algId = CRYPT_EAL_PkeyGetId(tmpPKey);
@@ -117,7 +109,6 @@ int32_t CRYPT_EAL_ProviderDecodeBuffKeyInner(CRYPT_EAL_LibCtx *libCtx, const cha
}
ret = CRYPT_DECODE_PoolCtrl(poolCtx, CRYPT_DECODE_POOL_CMD_SET_FLAG_FREE_OUT_DATA, &isFreeOutData, sizeof(bool));
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
*ealPKey = tmpPKey;
crypto/codecskey/src/crypt_decode_rsa.c
+1 -1
View File
@@ -141,7 +141,7 @@ int32_t CRYPT_RSA_ParsePrikeyAsn1Buff(uint8_t *buff, uint32_t buffLen, BSL_ASN1_
return DecodeRsaPrikeyAsn1Buff(buff, buffLen, rsaPssParam, BSL_CID_UNKNOWN, rsaPriKey);
}
int32_t CRYPT_RSA_ParsePubkeyAsn1Buff( uint8_t *buff, uint32_t buffLen, BSL_ASN1_Buffer *param,
int32_t CRYPT_RSA_ParsePubkeyAsn1Buff(uint8_t *buff, uint32_t buffLen, BSL_ASN1_Buffer *param,
CRYPT_RSA_Ctx **rsaPubKey, BslCid cid)
{
// decode n and e
crypto/codecskey/src/crypt_encode_decode.c
+8 -8
View File
@@ -45,7 +45,7 @@ int32_t CRYPT_EAL_GetEncodeFormat(const char *format)
static const struct {
const char *formatStr;
int32_t formatInt;
} formatMap[] = {
} FORMAT_MAP[] = {
{"ASN1", BSL_FORMAT_ASN1},
{"PEM", BSL_FORMAT_PEM},
{"PFX_COM", BSL_FORMAT_PFX_COM},
@@ -53,9 +53,9 @@ int32_t CRYPT_EAL_GetEncodeFormat(const char *format)
{"OBJECT", BSL_FORMAT_OBJECT}
};
for (size_t i = 0; i < sizeof(formatMap) / sizeof(formatMap[0]); i++) {
if (strcmp(format, formatMap[i].formatStr) == 0) {
return formatMap[i].formatInt;
for (size_t i = 0; i < sizeof(FORMAT_MAP) / sizeof(FORMAT_MAP[0]); i++) {
if (strcmp(format, FORMAT_MAP[i].formatStr) == 0) {
return FORMAT_MAP[i].formatInt;
}
}
@@ -493,7 +493,7 @@ int32_t CRYPT_EAL_GetEncodeType(const char *type)
static const struct {
const char *typeStr;
int32_t typeInt;
} typeMap[] = {
} TYPE_MAP[] = {
{"PRIKEY_PKCS8_UNENCRYPT", CRYPT_PRIKEY_PKCS8_UNENCRYPT},
{"PRIKEY_PKCS8_ENCRYPT", CRYPT_PRIKEY_PKCS8_ENCRYPT},
{"PRIKEY_RSA", CRYPT_PRIKEY_RSA},
@@ -503,9 +503,9 @@ int32_t CRYPT_EAL_GetEncodeType(const char *type)
{"PUBKEY_SUBKEY_WITHOUT_SEQ", CRYPT_PUBKEY_SUBKEY_WITHOUT_SEQ}
};
for (size_t i = 0; i < sizeof(typeMap) / sizeof(typeMap[0]); i++) {
if (strcmp(type, typeMap[i].typeStr) == 0) {
return typeMap[i].typeInt;
for (size_t i = 0; i < sizeof(TYPE_MAP) / sizeof(TYPE_MAP[0]); i++) {
if (strcmp(type, TYPE_MAP[i].typeStr) == 0) {
return TYPE_MAP[i].typeInt;
}
}
crypto/codecskey/src/crypt_encode_decode_local.c
+80 -80
View File
@@ -51,6 +51,65 @@ static BSL_ASN1_TemplateItem g_pk8EncPriKeyTempl[] = {
};
#endif // HITLS_CRYPTO_KEY_EPKI && HITLS_CRYPTO_KEY_ENCODE
#if defined(HITLS_CRYPTO_RSA) && defined(HITLS_CRYPTO_KEY_DECODE)
int32_t CRYPT_EAL_GetRsaPssPara(CRYPT_EAL_PkeyCtx *ealPriKey, CRYPT_RSA_PssPara *rsaPssParam)
{
int32_t ret;
ret = CRYPT_EAL_PkeyCtrl(ealPriKey, CRYPT_CTRL_GET_RSA_SALTLEN, &rsaPssParam->saltLen,
sizeof(rsaPssParam->saltLen));
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = CRYPT_EAL_PkeyCtrl(ealPriKey, CRYPT_CTRL_GET_RSA_MD, &rsaPssParam->mdId, sizeof(rsaPssParam->mdId));
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = CRYPT_EAL_PkeyCtrl(ealPriKey, CRYPT_CTRL_GET_RSA_MGF, &rsaPssParam->mgfId, sizeof(rsaPssParam->mgfId));
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
}
int32_t CRYPT_EAL_InitRsaPrv(const CRYPT_EAL_PkeyCtx *ealPriKey, CRYPT_PKEY_AlgId cid, CRYPT_EAL_PkeyPrv *rsaPrv)
{
uint32_t bnLen = CRYPT_EAL_PkeyGetKeyLen(ealPriKey);
if (bnLen == 0) {
return CRYPT_EAL_ALG_NOT_SUPPORT;
}
uint8_t *pri = (uint8_t *)BSL_SAL_Malloc(bnLen * 8); // 8 items
if (pri == NULL) {
return CRYPT_MEM_ALLOC_FAIL;
}
rsaPrv->id = cid;
rsaPrv->key.rsaPrv.d = pri;
rsaPrv->key.rsaPrv.n = pri + bnLen;
rsaPrv->key.rsaPrv.p = pri + bnLen * 2; // 2nd buffer
rsaPrv->key.rsaPrv.q = pri + bnLen * 3; // 3rd buffer
rsaPrv->key.rsaPrv.dP = pri + bnLen * 4; // 4th buffer
rsaPrv->key.rsaPrv.dQ = pri + bnLen * 5; // 5th buffer
rsaPrv->key.rsaPrv.qInv = pri + bnLen * 6; // 6th buffer
rsaPrv->key.rsaPrv.e = pri + bnLen * 7; // 7th buffer
rsaPrv->key.rsaPrv.dLen = bnLen;
rsaPrv->key.rsaPrv.nLen = bnLen;
rsaPrv->key.rsaPrv.pLen = bnLen;
rsaPrv->key.rsaPrv.qLen = bnLen;
rsaPrv->key.rsaPrv.dPLen = bnLen;
rsaPrv->key.rsaPrv.dQLen = bnLen;
rsaPrv->key.rsaPrv.qInvLen = bnLen;
rsaPrv->key.rsaPrv.eLen = bnLen;
return CRYPT_SUCCESS;
}
void CRYPT_EAL_DeinitRsaPrv(CRYPT_EAL_PkeyPrv *rsaPrv)
{
BSL_SAL_ClearFree(rsaPrv->key.rsaPrv.d, rsaPrv->key.rsaPrv.dLen * 8); // 8 items
}
#endif
#ifdef HITLS_CRYPTO_KEY_DECODE
#ifdef HITLS_CRYPTO_RSA
static int32_t ProcRsaPssParam(BSL_ASN1_Buffer *rsaPssParam, CRYPT_EAL_PkeyCtx *ealPriKey)
@@ -200,8 +259,7 @@ static int32_t EccEalKeyNew(BSL_ASN1_Buffer *ecParamOid, int32_t *alg, CRYPT_EAL
{
int32_t algId;
BslOidString oidStr = {ecParamOid->len, (char *)ecParamOid->buff, 0};
CRYPT_PKEY_ParaId paraId = (CRYPT_PKEY_ParaId)BSL_OBJ_GetCIDFromOid(&oidStr);
CRYPT_PKEY_ParaId paraId = (CRYPT_PKEY_ParaId)BSL_OBJ_GetCID(&oidStr);
if (paraId == CRYPT_ECC_SM2) {
algId = CRYPT_PKEY_SM2;
} else if (IsEcdsaEcParaId(paraId)) {
@@ -287,7 +345,7 @@ static int32_t ParseEccPrikeyAsn1(BSL_ASN1_Buffer *encode, BSL_ASN1_Buffer *pk8A
return ret;
}
// the tag of public key is BSL_ASN1_TAG_BITSTRING, 1 denote unusedBits
CRYPT_EAL_PkeyPub pub = {.id = algId, .key.eccPub = {.data = pubkey->buff + 1,.len = pubkey->len - 1}};
CRYPT_EAL_PkeyPub pub = {.id = algId, .key.eccPub = {.data = pubkey->buff + 1, .len = pubkey->len - 1}};
ret = CRYPT_EAL_PkeySetPub(pctx, &pub);
if (ret != CRYPT_SUCCESS) {
CRYPT_EAL_PkeyFreeCtx(pctx);
@@ -401,8 +459,7 @@ int32_t ParseSubPubkeyAsn1(BSL_ASN1_Buffer *encode, CRYPT_EAL_PkeyCtx **ealPubKe
return ret;
}
BslOidString oidStr = {oid->len, (char *)oid->buff, 0};
BslCid cid = BSL_OBJ_GetCIDFromOid(&oidStr);
BslCid cid = BSL_OBJ_GetCID(&oidStr);
#if defined(HITLS_CRYPTO_ECDSA) || defined(HITLS_CRYPTO_SM2)
if (cid == BSL_CID_EC_PUBLICKEY || cid == BSL_CID_SM2PRIME256) {
return ParseEccPubkeyAsn1Buff(&bitPubkey, algParam, ealPubKey);
@@ -472,27 +529,6 @@ int32_t CRYPT_EAL_ParseAsn1SubPubkey(uint8_t *buff, uint32_t buffLen, void **eal
#ifdef HITLS_CRYPTO_KEY_ENCODE
#ifdef HITLS_CRYPTO_RSA
static int32_t GetPssParamInfo(CRYPT_EAL_PkeyCtx *ealPriKey, CRYPT_RSA_PssPara *rsaPssParam)
{
int32_t ret;
ret = CRYPT_EAL_PkeyCtrl(ealPriKey, CRYPT_CTRL_GET_RSA_SALTLEN, &rsaPssParam->saltLen,
sizeof(rsaPssParam->saltLen));
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = CRYPT_EAL_PkeyCtrl(ealPriKey, CRYPT_CTRL_GET_RSA_MD, &rsaPssParam->mdId, sizeof(rsaPssParam->mdId));
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = CRYPT_EAL_PkeyCtrl(ealPriKey, CRYPT_CTRL_GET_RSA_MGF, &rsaPssParam->mgfId, sizeof(rsaPssParam->mgfId));
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
}
static int32_t EncodePssParam(CRYPT_EAL_PkeyCtx *ealPubKey, BSL_ASN1_Buffer *pssParam)
{
if (pssParam == NULL) {
@@ -509,7 +545,7 @@ static int32_t EncodePssParam(CRYPT_EAL_PkeyCtx *ealPubKey, BSL_ASN1_Buffer *pss
return CRYPT_SUCCESS;
}
CRYPT_RSA_PssPara rsaPssParam = {0};
ret = GetPssParamInfo(ealPubKey, &rsaPssParam);
ret = CRYPT_EAL_GetRsaPssPara(ealPubKey, &rsaPssParam);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
@@ -580,7 +616,7 @@ static int32_t EncodeRsaPrvKey(CRYPT_EAL_PkeyCtx *ealPriKey, BSL_ASN1_Buffer *pk
BSL_Buffer tmp = {0};
switch (pad) {
case CRYPT_EMSA_PSS:
ret = GetPssParamInfo(ealPriKey, &rsaPssParam);
ret = CRYPT_EAL_GetRsaPssPara(ealPriKey, &rsaPssParam);
if (ret != BSL_SUCCESS) {
return ret;
}
@@ -611,37 +647,6 @@ static int32_t EncodeRsaPrvKey(CRYPT_EAL_PkeyCtx *ealPriKey, BSL_ASN1_Buffer *pk
return CRYPT_SUCCESS;
}
static int32_t InitRsaPrvCtx(const CRYPT_EAL_PkeyCtx *ealPriKey, CRYPT_PKEY_AlgId cid, CRYPT_EAL_PkeyPrv *rsaPrv)
{
uint32_t bnLen = CRYPT_EAL_PkeyGetKeyLen(ealPriKey);
if (bnLen == 0) {
return CRYPT_EAL_ALG_NOT_SUPPORT;
}
uint8_t *pri = (uint8_t *)BSL_SAL_Malloc(bnLen * 8); // 8 items
if (pri == NULL) {
return CRYPT_MEM_ALLOC_FAIL;
}
rsaPrv->id = cid;
rsaPrv->key.rsaPrv.d = pri;
rsaPrv->key.rsaPrv.n = pri + bnLen;
rsaPrv->key.rsaPrv.p = pri + bnLen * 2; // 2nd buffer
rsaPrv->key.rsaPrv.q = pri + bnLen * 3; // 3rd buffer
rsaPrv->key.rsaPrv.dP = pri + bnLen * 4; // 4th buffer
rsaPrv->key.rsaPrv.dQ = pri + bnLen * 5; // 5th buffer
rsaPrv->key.rsaPrv.qInv = pri + bnLen * 6; // 6th buffer
rsaPrv->key.rsaPrv.e = pri + bnLen * 7; // 7th buffer
rsaPrv->key.rsaPrv.dLen = bnLen;
rsaPrv->key.rsaPrv.nLen = bnLen;
rsaPrv->key.rsaPrv.pLen = bnLen;
rsaPrv->key.rsaPrv.qLen = bnLen;
rsaPrv->key.rsaPrv.dPLen = bnLen;
rsaPrv->key.rsaPrv.dQLen = bnLen;
rsaPrv->key.rsaPrv.qInvLen = bnLen;
rsaPrv->key.rsaPrv.eLen = bnLen;
return CRYPT_SUCCESS;
}
static void SetRsaPrv2Arr(const CRYPT_EAL_PkeyPrv *rsaPrv, BSL_ASN1_Buffer *asn1)
{
asn1[CRYPT_RSA_PRV_D_IDX].buff = rsaPrv->key.rsaPrv.d;
@@ -671,25 +676,20 @@ static void SetRsaPrv2Arr(const CRYPT_EAL_PkeyPrv *rsaPrv, BSL_ASN1_Buffer *asn1
asn1[CRYPT_RSA_PRV_QINV_IDX].tag = BSL_ASN1_TAG_INTEGER;
}
static void DeinitRsaPrvCtx(CRYPT_EAL_PkeyPrv *rsaPrv)
{
BSL_SAL_ClearFree(rsaPrv->key.rsaPrv.d, rsaPrv->key.rsaPrv.dLen * 8); // 8 items
}
int32_t EncodeRsaPrikeyAsn1Buff(CRYPT_EAL_PkeyCtx *ealPriKey, CRYPT_PKEY_AlgId cid, BSL_Buffer *encode)
{
int32_t ret;
BSL_ASN1_Buffer asn1[CRYPT_RSA_PRV_OTHER_PRIME_IDX + 1] = {0};
CRYPT_EAL_PkeyPrv rsaPrv = {0};
ret = InitRsaPrvCtx(ealPriKey, cid, &rsaPrv);
ret = CRYPT_EAL_InitRsaPrv(ealPriKey, cid, &rsaPrv);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = CRYPT_EAL_PkeyGetPrv(ealPriKey, &rsaPrv);
if (ret != CRYPT_SUCCESS) {
DeinitRsaPrvCtx(&rsaPrv);
CRYPT_EAL_DeinitRsaPrv(&rsaPrv);
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
@@ -699,7 +699,7 @@ int32_t EncodeRsaPrikeyAsn1Buff(CRYPT_EAL_PkeyCtx *ealPriKey, CRYPT_PKEY_AlgId c
asn1[CRYPT_RSA_PRV_VERSION_IDX].len = sizeof(version);
asn1[CRYPT_RSA_PRV_VERSION_IDX].tag = BSL_ASN1_TAG_INTEGER;
ret = CRYPT_ENCODE_RsaPrikeyAsn1Buff(asn1, CRYPT_RSA_PRV_OTHER_PRIME_IDX + 1, encode);
DeinitRsaPrvCtx(&rsaPrv);
CRYPT_EAL_DeinitRsaPrv(&rsaPrv);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
@@ -773,8 +773,8 @@ int32_t EncodeEccPrikeyAsn1Buff(CRYPT_EAL_PkeyCtx *ealPriKey, BSL_ASN1_Buffer *p
{BSL_ASN1_TAG_INTEGER, sizeof(version), &version}, {0}, {0}, {0}};
CRYPT_PKEY_AlgId cid = CRYPT_EAL_PkeyGetId(ealPriKey);
BslOidString *oid = cid == CRYPT_PKEY_SM2 ? BSL_OBJ_GetOidFromCID((BslCid)CRYPT_ECC_SM2)
: BSL_OBJ_GetOidFromCID((BslCid)CRYPT_EAL_PkeyGetParaId(ealPriKey));
BslOidString *oid = cid == CRYPT_PKEY_SM2 ? BSL_OBJ_GetOID((BslCid)CRYPT_ECC_SM2)
: BSL_OBJ_GetOID((BslCid)CRYPT_EAL_PkeyGetParaId(ealPriKey));
if (oid == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
return CRYPT_ERR_ALGID;
@@ -796,9 +796,9 @@ static int32_t EncodeEccPubkeyAsn1Buff(CRYPT_EAL_PkeyCtx *ealPubKey, BSL_ASN1_Bu
{
int32_t ret;
CRYPT_PKEY_ParaId paraId = CRYPT_EAL_PkeyGetParaId(ealPubKey);
BslOidString *oid = BSL_OBJ_GetOidFromCID((BslCid)paraId);
BslOidString *oid = BSL_OBJ_GetOID((BslCid)paraId);
if (CRYPT_EAL_PkeyGetId(ealPubKey) == CRYPT_PKEY_SM2) {
oid = BSL_OBJ_GetOidFromCID((BslCid)CRYPT_ECC_SM2);
oid = BSL_OBJ_GetOID((BslCid)CRYPT_ECC_SM2);
}
if (oid == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
@@ -1022,7 +1022,7 @@ static int32_t CRYPT_EAL_SubPubkeyGetInfo(CRYPT_EAL_PkeyCtx *ealPubKey, BSL_ASN1
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
BslOidString *oidStr = BSL_OBJ_GetOidFromCID((BslCid)cid);
BslOidString *oidStr = BSL_OBJ_GetOID((BslCid)cid);
if (oidStr == NULL) {
BSL_SAL_FREE(bitTmp.data);
ret = CRYPT_ERR_ALGID;
@@ -1074,7 +1074,7 @@ int32_t EncodeHashAlg(CRYPT_MD_AlgId mdId, BSL_ASN1_Buffer *asn)
return CRYPT_SUCCESS;
}
BslOidString *oidStr = BSL_OBJ_GetOidFromCID((BslCid)mdId);
BslOidString *oidStr = BSL_OBJ_GetOID((BslCid)mdId);
if (oidStr == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
return CRYPT_ERR_ALGID;
@@ -1107,13 +1107,13 @@ static int32_t EncodeMgfAlg(CRYPT_MD_AlgId mgfId, BSL_ASN1_Buffer *asn)
asn->len = 0;
return CRYPT_SUCCESS;
}
BslOidString *mgfStr = BSL_OBJ_GetOidFromCID(BSL_CID_MGF1);
BslOidString *mgfStr = BSL_OBJ_GetOID(BSL_CID_MGF1);
if (mgfStr == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
return CRYPT_ERR_ALGID;
}
BslOidString *oidStr = BSL_OBJ_GetOidFromCID((BslCid)mgfId);
BslOidString *oidStr = BSL_OBJ_GetOID((BslCid)mgfId);
if (oidStr == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
return CRYPT_ERR_ALGID;
@@ -1130,7 +1130,7 @@ static int32_t EncodeMgfAlg(CRYPT_MD_AlgId mgfId, BSL_ASN1_Buffer *asn)
BSL_ASN1_Buffer asnArr[3] = {
{BSL_ASN1_TAG_OBJECT_ID, mgfStr->octetLen, (uint8_t *)mgfStr->octs},
{BSL_ASN1_TAG_OBJECT_ID, oidStr->octetLen, (uint8_t *)oidStr->octs},
{BSL_ASN1_TAG_NULL,0, NULL}, // param
{BSL_ASN1_TAG_NULL, 0, NULL}, // param
};
int32_t ret = BSL_ASN1_EncodeTemplate(&templ, asnArr, 3, &(asn->buff), &(asn->len));
if (ret != CRYPT_SUCCESS) {
@@ -1296,14 +1296,14 @@ static int32_t ParsePKCS7EncryptedContentInfo(CRYPT_EAL_LibCtx *libCtx, const ch
}
BslOidString typeOidStr = {asn1[HITLS_P7_ENC_CONTINFO_TYPE_IDX].len,
(char *)asn1[HITLS_P7_ENC_CONTINFO_TYPE_IDX].buff, 0};
BslCid cid = BSL_OBJ_GetCIDFromOid(&typeOidStr);
BslCid cid = BSL_OBJ_GetCID(&typeOidStr);
if (cid != BSL_CID_PKCS7_SIMPLEDATA) {
BSL_ERR_PUSH_ERROR(CRYPT_DECODE_UNSUPPORTED_PKCS7_TYPE);
return CRYPT_DECODE_UNSUPPORTED_PKCS7_TYPE;
}
BslOidString encOidStr = {asn1[HITLS_P7_ENC_CONTINFO_ENCALG_IDX].len,
(char *)asn1[HITLS_P7_ENC_CONTINFO_ENCALG_IDX].buff, 0};
cid = BSL_OBJ_GetCIDFromOid(&encOidStr);
cid = BSL_OBJ_GetCID(&encOidStr);
if (cid != BSL_CID_PBES2) {
BSL_ERR_PUSH_ERROR(CRYPT_DECODE_UNSUPPORTED_ENCRYPT_TYPE);
return CRYPT_DECODE_UNSUPPORTED_ENCRYPT_TYPE;
@@ -1311,7 +1311,7 @@ static int32_t ParsePKCS7EncryptedContentInfo(CRYPT_EAL_LibCtx *libCtx, const ch
// parse sym alg id
BslOidString symOidStr = {asn1[HITLS_P7_ENC_CONTINFO_SYMALG_IDX].len,
(char *)asn1[HITLS_P7_ENC_CONTINFO_SYMALG_IDX].buff, 0};
BslCid symId = BSL_OBJ_GetCIDFromOid(&symOidStr);
BslCid symId = BSL_OBJ_GetCID(&symOidStr);
if (symId == BSL_CID_UNKNOWN) {
BSL_ERR_PUSH_ERROR(CRYPT_DECODE_UNKNOWN_OID);
return CRYPT_DECODE_UNKNOWN_OID;
@@ -1394,7 +1394,7 @@ static int32_t EncodePKCS7EncryptedContentInfo(CRYPT_EAL_LibCtx *libCtx, const c
return ret;
}
do {
BslOidString *oidStr = BSL_OBJ_GetOidFromCID(BSL_CID_PKCS7_SIMPLEDATA);
BslOidString *oidStr = BSL_OBJ_GetOID(BSL_CID_PKCS7_SIMPLEDATA);
if (oidStr == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
ret = CRYPT_ERR_ALGID;
crypto/codecskey/src/crypt_encode_decode_local.h
+4 -4
View File
@@ -123,8 +123,8 @@ int32_t CRYPT_DECODE_ParseEncDataAsn1(CRYPT_EAL_LibCtx *libctx, const char *attr
int32_t CRYPT_EAL_ParseAsn1SubPubkey(uint8_t *buff, uint32_t buffLen, void **ealPubKey, bool isComplete);
int32_t CRYPT_DECODE_AlgoIdAsn1Buff(uint8_t *buff, uint32_t buffLen, BSL_ASN1_DecTemplCallBack keyInfoCb, BSL_ASN1_Buffer *algoId,
uint32_t algoIdNum);
int32_t CRYPT_DECODE_AlgoIdAsn1Buff(uint8_t *buff, uint32_t buffLen, BSL_ASN1_DecTemplCallBack keyInfoCb,
BSL_ASN1_Buffer *algoId, uint32_t algoIdNum);
int32_t CRYPT_DECODE_ConstructBufferOutParam(BSL_Param **outParam, uint8_t *buffer, uint32_t bufferLen);
@@ -137,11 +137,11 @@ int32_t CRYPT_DECODE_RsaPubkeyAsn1Buff(uint8_t *buff, uint32_t buffLen, BSL_ASN1
int32_t CRYPT_DECODE_RsaPrikeyAsn1Buff(uint8_t *buff, uint32_t buffLen, BSL_ASN1_Buffer *asn1, uint32_t asn1Num);
int32_t CRYPT_RSA_ParsePubkeyAsn1Buff( uint8_t *buff, uint32_t buffLen, BSL_ASN1_Buffer *param,
int32_t CRYPT_RSA_ParsePubkeyAsn1Buff(uint8_t *buff, uint32_t buffLen, BSL_ASN1_Buffer *param,
CRYPT_RSA_Ctx **rsaPubKey, BslCid cid);
int32_t CRYPT_RSA_ParsePkcs8Key(uint8_t *buff, uint32_t buffLen, CRYPT_RSA_Ctx **rsaPriKey);
int32_t CRYPT_RSA_ParseSubPubkeyAsn1Buff( uint8_t *buff, uint32_t buffLen, CRYPT_RSA_Ctx **pubKey, bool isComplete);
int32_t CRYPT_RSA_ParseSubPubkeyAsn1Buff(uint8_t *buff, uint32_t buffLen, CRYPT_RSA_Ctx **pubKey, bool isComplete);
int32_t CRYPT_RSA_ParsePrikeyAsn1Buff(uint8_t *buff, uint32_t buffLen, BSL_ASN1_Buffer *rsaPssParam,
CRYPT_RSA_Ctx **rsaPriKey);
crypto/codecskey/src/crypt_encode_decode_utils.c
+75 -73
View File
@@ -49,21 +49,21 @@
static BSL_ASN1_TemplateItem g_rsaPrvTempl[] = {
{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 */
{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 */
};
/**
@@ -75,8 +75,8 @@ static BSL_ASN1_TemplateItem g_rsaPrvTempl[] = {
*/
static BSL_ASN1_TemplateItem g_rsaPubTempl[] = {
{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 */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* n */
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* e */
};
#ifdef HITLS_CRYPTO_KEY_DECODE
@@ -93,23 +93,23 @@ static BSL_ASN1_TemplateItem g_rsaPubTempl[] = {
*/
static BSL_ASN1_TemplateItem g_rsaPssTempl[] = {
{BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_TAG_CONSTRUCTED | CRYPT_ASN1_CTX_SPECIFIC_TAG_RSAPSS_HASH,
BSL_ASN1_FLAG_DEFAULT, 0},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
{BSL_ASN1_TAG_OBJECT_ID, 0, 2},
{BSL_ASN1_TAG_ANY, BSL_ASN1_FLAG_OPTIONAL, 2},
BSL_ASN1_FLAG_DEFAULT, 0},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
{BSL_ASN1_TAG_OBJECT_ID, 0, 2},
{BSL_ASN1_TAG_ANY, BSL_ASN1_FLAG_OPTIONAL, 2},
{BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_TAG_CONSTRUCTED | CRYPT_ASN1_CTX_SPECIFIC_TAG_RSAPSS_MASKGEN,
BSL_ASN1_FLAG_DEFAULT, 0},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
{BSL_ASN1_TAG_OBJECT_ID, 0, 2},
{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},
BSL_ASN1_FLAG_DEFAULT, 0},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
{BSL_ASN1_TAG_OBJECT_ID, 0, 2},
{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},
{BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_TAG_CONSTRUCTED | CRYPT_ASN1_CTX_SPECIFIC_TAG_RSAPSS_SALTLEN,
BSL_ASN1_FLAG_DEFAULT, 0},
{BSL_ASN1_TAG_INTEGER, 0, 1},
BSL_ASN1_FLAG_DEFAULT, 0},
{BSL_ASN1_TAG_INTEGER, 0, 1},
{BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_TAG_CONSTRUCTED | CRYPT_ASN1_CTX_SPECIFIC_TAG_RSAPSS_TRAILED,
BSL_ASN1_FLAG_DEFAULT, 0},
{BSL_ASN1_TAG_INTEGER, 0, 1}
BSL_ASN1_FLAG_DEFAULT, 0},
{BSL_ASN1_TAG_INTEGER, 0, 1}
};
typedef enum {
@@ -143,14 +143,14 @@ typedef enum {
static BSL_ASN1_TemplateItem g_ecPriKeyTempl[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0}, // ignore seq header
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* version */
{BSL_ASN1_TAG_OCTETSTRING, 0, 1}, /* private key */
{BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_EC_PRIKEY_PARAM,
BSL_ASN1_FLAG_OPTIONAL, 1},
{BSL_ASN1_TAG_OBJECT_ID, 0, 2},
{BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_EC_PRIKEY_PUBKEY,
BSL_ASN1_FLAG_OPTIONAL, 1},
{BSL_ASN1_TAG_BITSTRING, 0, 2},
{BSL_ASN1_TAG_INTEGER, 0, 1}, /* version */
{BSL_ASN1_TAG_OCTETSTRING, 0, 1}, /* private key */
{BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_EC_PRIKEY_PARAM,
BSL_ASN1_FLAG_OPTIONAL, 1},
{BSL_ASN1_TAG_OBJECT_ID, 0, 2},
{BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_EC_PRIKEY_PUBKEY,
BSL_ASN1_FLAG_OPTIONAL, 1},
{BSL_ASN1_TAG_BITSTRING, 0, 2},
};
#endif
@@ -165,9 +165,9 @@ static BSL_ASN1_TemplateItem g_ecPriKeyTempl[] = {
*/
static BSL_ASN1_TemplateItem g_pk8PriKeyTempl[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0}, // ignore seq header
{BSL_ASN1_TAG_INTEGER, 0, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_HEADERONLY, 1},
{BSL_ASN1_TAG_OCTETSTRING, 0, 1},
{BSL_ASN1_TAG_INTEGER, 0, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_HEADERONLY, 1},
{BSL_ASN1_TAG_OCTETSTRING, 0, 1},
};
typedef enum {
@@ -187,24 +187,24 @@ typedef enum {
*/
static BSL_ASN1_TemplateItem g_pk8EncPriKeyTempl[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1}, // EncryptionAlgorithmIdentifier
{BSL_ASN1_TAG_OBJECT_ID, 0, 2},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 2},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_HEADERONLY, 3}, // derivation param
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 3}, // enc scheme
{BSL_ASN1_TAG_OBJECT_ID, 0, 4}, // alg
{BSL_ASN1_TAG_OCTETSTRING, 0, 4}, // iv
{BSL_ASN1_TAG_OCTETSTRING, 0, 1}, // EncryptedData
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1}, // EncryptionAlgorithmIdentifier
{BSL_ASN1_TAG_OBJECT_ID, 0, 2},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 2},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_HEADERONLY, 3}, // derivation param
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 3}, // enc scheme
{BSL_ASN1_TAG_OBJECT_ID, 0, 4}, // alg
{BSL_ASN1_TAG_OCTETSTRING, 0, 4}, // iv
{BSL_ASN1_TAG_OCTETSTRING, 0, 1}, // EncryptedData
};
#endif
static BSL_ASN1_TemplateItem g_pbkdf2DerParamTempl[] = {
{BSL_ASN1_TAG_OBJECT_ID, 0, 0}, // derive alg
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_OCTETSTRING, 0, 1}, // salt
{BSL_ASN1_TAG_INTEGER, 0, 1}, // iteration
{BSL_ASN1_TAG_INTEGER, BSL_ASN1_FLAG_OPTIONAL, 1}, // keyLen
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_DEFAULT | BSL_ASN1_FLAG_HEADERONLY, 1}, // prf
{BSL_ASN1_TAG_OCTETSTRING, 0, 1}, // salt
{BSL_ASN1_TAG_INTEGER, 0, 1}, // iteration
{BSL_ASN1_TAG_INTEGER, BSL_ASN1_FLAG_OPTIONAL, 1}, // keyLen
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_DEFAULT | BSL_ASN1_FLAG_HEADERONLY, 1}, // prf
};
#endif // HITLS_CRYPTO_KEY_EPKI
/**
@@ -217,8 +217,8 @@ static BSL_ASN1_TemplateItem g_pbkdf2DerParamTempl[] = {
*/
static BSL_ASN1_TemplateItem g_subKeyInfoTempl[] = {
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_HEADERONLY, 1},
{BSL_ASN1_TAG_BITSTRING, 0, 1},
{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_HEADERONLY, 1},
{BSL_ASN1_TAG_BITSTRING, 0, 1},
};
static BSL_ASN1_TemplateItem g_subKeyInfoInnerTempl[] = {
@@ -398,7 +398,7 @@ int32_t CRYPT_EAL_ParseRsaPssAlgParam(BSL_ASN1_Buffer *param, CRYPT_RSA_PssPara
if (asns[CRYPT_RSAPSS_HASH_IDX].tag != 0) {
BslOidString hashOid = {asns[CRYPT_RSAPSS_HASH_IDX].len, (char *)asns[CRYPT_RSAPSS_HASH_IDX].buff, 0};
para->mdId = (CRYPT_MD_AlgId)BSL_OBJ_GetCIDFromOid(&hashOid);
para->mdId = (CRYPT_MD_AlgId)BSL_OBJ_GetCID(&hashOid);
if (para->mdId == (CRYPT_MD_AlgId)BSL_CID_UNKNOWN) {
BSL_ERR_PUSH_ERROR(CRYPT_DECODE_ERR_RSSPSS_MD);
return CRYPT_DECODE_ERR_RSSPSS_MD;
@@ -406,7 +406,7 @@ int32_t CRYPT_EAL_ParseRsaPssAlgParam(BSL_ASN1_Buffer *param, CRYPT_RSA_PssPara
}
if (asns[CRYPT_RSAPSS_MGF1PARAM_IDX].tag != 0) {
BslOidString mgf1 = {asns[CRYPT_RSAPSS_MGF1PARAM_IDX].len, (char *)asns[CRYPT_RSAPSS_MGF1PARAM_IDX].buff, 0};
para->mgfId = (CRYPT_MD_AlgId)BSL_OBJ_GetCIDFromOid(&mgf1);
para->mgfId = (CRYPT_MD_AlgId)BSL_OBJ_GetCID(&mgf1);
if (para->mgfId == (CRYPT_MD_AlgId)BSL_CID_UNKNOWN) {
BSL_ERR_PUSH_ERROR(CRYPT_DECODE_ERR_RSSPSS_MGF1MD);
return CRYPT_DECODE_ERR_RSSPSS_MGF1MD;
@@ -445,8 +445,8 @@ static int32_t DecSubKeyInfoCb(int32_t type, uint32_t idx, void *data, void *exp
switch (type) {
case BSL_ASN1_TYPE_GET_ANY_TAG: {
BslOidString oidStr = {param->len, (char *)param->buff, 0};
BslCid cid = BSL_OBJ_GetCIDFromOid(&oidStr);
if (cid == BSL_CID_EC_PUBLICKEY) {
BslCid cid = BSL_OBJ_GetCID(&oidStr);
if (cid == BSL_CID_EC_PUBLICKEY || cid == BSL_CID_SM2PRIME256) {
// note: any It can be encoded empty or it can be null
*(uint8_t *)expVal = BSL_ASN1_TAG_OBJECT_ID;
} else if (cid == BSL_CID_RSASSAPSS) {
@@ -525,7 +525,7 @@ int32_t CRYPT_DECODE_SubPubkey(uint8_t *buff, uint32_t buffLen, BSL_ASN1_DecTemp
return ret;
}
BslOidString oidStr = {oid->len, (char *)oid->buff, 0};
BslCid cid = BSL_OBJ_GetCIDFromOid(&oidStr);
BslCid cid = BSL_OBJ_GetCID(&oidStr);
if (cid == BSL_CID_UNKNOWN) {
BSL_ERR_PUSH_ERROR(CRYPT_DECODE_UNKNOWN_OID);
return CRYPT_DECODE_UNKNOWN_OID;
@@ -541,12 +541,13 @@ static int32_t ParsePk8PriParamAsn1(BSL_ASN1_Buffer *encode, BSL_ASN1_DecTemplCa
{
BSL_ASN1_Buffer *algo = &encode[CRYPT_PK8_PRIKEY_ALGID_IDX]; // AlgorithmIdentifier
BSL_ASN1_Buffer algoId[BSL_ASN1_TAG_ALGOID_ANY_IDX + 1] = {0};
int32_t ret = CRYPT_DECODE_AlgoIdAsn1Buff(algo->buff, algo->len, keyInfoCb, algoId, BSL_ASN1_TAG_ALGOID_ANY_IDX + 1);
int32_t ret = CRYPT_DECODE_AlgoIdAsn1Buff(algo->buff, algo->len, keyInfoCb,
algoId, BSL_ASN1_TAG_ALGOID_ANY_IDX + 1);
if (ret != CRYPT_SUCCESS) {
return ret;
}
BslOidString oidStr = {algoId[0].len, (char *)algoId[0].buff, 0};
BslCid cid = BSL_OBJ_GetCIDFromOid(&oidStr);
BslCid cid = BSL_OBJ_GetCID(&oidStr);
if (cid == BSL_CID_UNKNOWN) {
BSL_ERR_PUSH_ERROR(CRYPT_DECODE_UNKNOWN_OID);
return CRYPT_DECODE_UNKNOWN_OID;
@@ -610,7 +611,7 @@ static int32_t ParseDeriveKeyPrfAlgId(BSL_ASN1_Buffer *asn, int32_t *prfId, BSL_
}
BslOidString oidStr = {algoId[BSL_ASN1_TAG_ALGOID_IDX].len,
(char *)algoId[BSL_ASN1_TAG_ALGOID_IDX].buff, 0};
*prfId = BSL_OBJ_GetCIDFromOid(&oidStr);
*prfId = BSL_OBJ_GetCID(&oidStr);
if (*prfId == BSL_CID_UNKNOWN) {
BSL_ERR_PUSH_ERROR(CRYPT_DECODE_PKCS8_INVALID_ALGO_PARAM);
return CRYPT_DECODE_PKCS8_INVALID_ALGO_PARAM;
@@ -636,7 +637,7 @@ static int32_t ParseDeriveKeyParam(BSL_Buffer *derivekeyData, uint32_t *iter, ui
}
BslOidString oidStr = {derParam[CRYPT_PKCS_ENC_DERALG_IDX].len,
(char *)derParam[CRYPT_PKCS_ENC_DERALG_IDX].buff, 0};
BslCid cid = BSL_OBJ_GetCIDFromOid(&oidStr);
BslCid cid = BSL_OBJ_GetCID(&oidStr);
if (cid != BSL_CID_PBKDF2) { // only pbkdf2 is supported
BSL_ERR_PUSH_ERROR(CRYPT_DECODE_PKCS8_INVALID_ALGO_PARAM);
return CRYPT_DECODE_PKCS8_INVALID_ALGO_PARAM;
@@ -737,7 +738,7 @@ int32_t CRYPT_DECODE_Pkcs8PrvDecrypt(CRYPT_EAL_LibCtx *libctx, const char *attrN
BslOidString encOidStr = {asn1[CRYPT_PKCS_ENCPRIKEY_ENCALG_IDX].len,
(char *)asn1[CRYPT_PKCS_ENCPRIKEY_ENCALG_IDX].buff, 0};
BslCid cid = BSL_OBJ_GetCIDFromOid(&encOidStr);
BslCid cid = BSL_OBJ_GetCID(&encOidStr);
if (cid != BSL_CID_PBES2) {
BSL_ERR_PUSH_ERROR(CRYPT_DECODE_UNKNOWN_OID);
return CRYPT_DECODE_UNKNOWN_OID;
@@ -745,7 +746,7 @@ int32_t CRYPT_DECODE_Pkcs8PrvDecrypt(CRYPT_EAL_LibCtx *libctx, const char *attrN
// parse sym alg id
BslOidString symOidStr = {asn1[CRYPT_PKCS_ENCPRIKEY_SYMALG_IDX].len,
(char *)asn1[CRYPT_PKCS_ENCPRIKEY_SYMALG_IDX].buff, 0};
BslCid symId = BSL_OBJ_GetCIDFromOid(&symOidStr);
BslCid symId = BSL_OBJ_GetCID(&symOidStr);
if (symId == BSL_CID_UNKNOWN) {
BSL_ERR_PUSH_ERROR(CRYPT_DECODE_UNKNOWN_OID);
return CRYPT_DECODE_UNKNOWN_OID;
@@ -801,7 +802,8 @@ int32_t CRYPT_ENCODE_EccPrikeyAsn1Buff(BSL_ASN1_Buffer *asn1, uint32_t asn1Num,
int32_t CRYPT_ENCODE_RsaPubkeyAsn1Buff(BSL_ASN1_Buffer *pubAsn1, BSL_Buffer *encodePub)
{
BSL_ASN1_Template pubTempl = {g_rsaPubTempl, sizeof(g_rsaPubTempl) / sizeof(g_rsaPubTempl[0])};
int32_t ret = BSL_ASN1_EncodeTemplate(&pubTempl, pubAsn1, CRYPT_RSA_PUB_E_IDX + 1, &encodePub->data, &encodePub->dataLen);
int32_t ret = BSL_ASN1_EncodeTemplate(&pubTempl, pubAsn1, CRYPT_RSA_PUB_E_IDX + 1,
&encodePub->data, &encodePub->dataLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
@@ -862,7 +864,7 @@ static int32_t EncodeDeriveKeyParam(CRYPT_EAL_LibCtx *libCtx, CRYPT_Pbkdf2Param
{
BSL_ASN1_Buffer derParam[CRYPT_PKCS_ENC_DERPRF_IDX + 1] = {0};
/* deralg */
BslOidString *oidPbkdf = BSL_OBJ_GetOidFromCID((BslCid)param->pbkdfId);
BslOidString *oidPbkdf = BSL_OBJ_GetOID((BslCid)param->pbkdfId);
if (oidPbkdf == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
return CRYPT_ERR_ALGID;
@@ -894,7 +896,7 @@ static int32_t EncodeDeriveKeyParam(CRYPT_EAL_LibCtx *libCtx, CRYPT_Pbkdf2Param
BSL_SAL_FREE(derParam[CRYPT_PKCS_ENC_DERITER_IDX].buff);
return ret;
}
BslOidString *oidHmac = BSL_OBJ_GetOidFromCID((BslCid)param->hmacId);
BslOidString *oidHmac = BSL_OBJ_GetOID((BslCid)param->hmacId);
if (oidHmac == NULL) {
BSL_SAL_FREE(derParam[CRYPT_PKCS_ENC_DERITER_IDX].buff);
BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
@@ -977,7 +979,7 @@ static int32_t EncodeEncryptedData(CRYPT_EAL_LibCtx *libCtx, const char *attrNam
static int32_t GenRandIv(CRYPT_EAL_LibCtx *libCtx, CRYPT_Pbkdf2Param *pkcsParam, BSL_ASN1_Buffer *asn1)
{
int32_t ret;
BslOidString *oidSym = BSL_OBJ_GetOidFromCID((BslCid)pkcsParam->symId);
BslOidString *oidSym = BSL_OBJ_GetOID((BslCid)pkcsParam->symId);
if (oidSym == NULL) {
return CRYPT_ERR_ALGID;
}
@@ -1016,7 +1018,7 @@ int32_t CRYPT_ENCODE_PkcsEncryptedBuff(CRYPT_EAL_LibCtx *libCtx, const char *att
CRYPT_Pbkdf2Param *pkcsParam, BSL_Buffer *unEncrypted, BSL_ASN1_Buffer *asn1)
{
int32_t ret;
BslOidString *oidPbes = BSL_OBJ_GetOidFromCID((BslCid)pkcsParam->pbesId);
BslOidString *oidPbes = BSL_OBJ_GetOID((BslCid)pkcsParam->pbesId);
if (oidPbes == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
return CRYPT_ERR_ALGID;
@@ -1073,7 +1075,7 @@ int32_t CRYPT_ENCODE_Pkcs8Info(CRYPT_ENCODE_DECODE_Pk8PrikeyInfo *pk8PrikeyInfo,
BSL_ASN1_Buffer algo = {0};
BSL_ASN1_Buffer algoId[BSL_ASN1_TAG_ALGOID_ANY_IDX + 1] = {0};
do {
BslOidString *oidStr = BSL_OBJ_GetOidFromCID((BslCid)pk8PrikeyInfo->keyType);
BslOidString *oidStr = BSL_OBJ_GetOID((BslCid)pk8PrikeyInfo->keyType);
if (oidStr == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
ret = CRYPT_ERR_ALGID;
crypto/curve25519/include/crypt_curve25519.h
+3 -3
View File
@@ -45,9 +45,9 @@ CRYPT_CURVE25519_Ctx *CRYPT_X25519_NewCtx(void);
/**
* @ingroup curve25519
* @brief curve25519 Create a key pair structure and allocate memory space.
*
*
* @param libCtx [IN] Library context
*
*
* @retval (CRYPT_CURVE25519_Ctx *) Pointer to the key pair structure
* @retval NULL Invalid null pointer
*/
@@ -69,7 +69,7 @@ CRYPT_CURVE25519_Ctx *CRYPT_ED25519_NewCtx(void);
* @brief curve25519 Create a key pair structure for ED25519 algorithm and allocate memory space.
*
* @param libCtx [IN] Library context
*
*
* @retval (CRYPT_CURVE25519_Ctx *) Pointer to the key pair structure
* @retval NULL Invalid null pointer
*/
crypto/curve25519/src/curve25519.c
-3
View File
@@ -835,7 +835,6 @@ int32_t CRYPT_CURVE25519_Export(const CRYPT_CURVE25519_Ctx *ctx, BSL_Param *para
BSL_Param ed25519Params[3] = {0}; // 3: pub key + priv key + end marker
int32_t ret = CRYPT_GetPkeyProcessParams(params, &processCb, &args);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
@@ -850,7 +849,6 @@ int32_t CRYPT_CURVE25519_Export(const CRYPT_CURVE25519_Ctx *ctx, BSL_Param *para
ret = CRYPT_CURVE25519_GetPubKey(ctx, ed25519Params);
if (ret != CRYPT_SUCCESS) {
BSL_SAL_Free(buffer);
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ed25519Params[index].valueLen = ed25519Params[index].useLen;
@@ -862,7 +860,6 @@ int32_t CRYPT_CURVE25519_Export(const CRYPT_CURVE25519_Ctx *ctx, BSL_Param *para
ret = CRYPT_CURVE25519_GetPrvKey(ctx, ed25519Params);
if (ret != CRYPT_SUCCESS) {
BSL_SAL_Free(buffer);
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ed25519Params[index].valueLen = ed25519Params[index].useLen;
crypto/dh/include/crypt_dh.h
+1 -1
View File
@@ -52,7 +52,7 @@ CRYPT_DH_Ctx *CRYPT_DH_NewCtx(void);
* @brief dh Allocate the context of dh.
*
* @param libCtx [IN] Library context
*
*
* @retval (CRYPT_DH_Ctx *) Pointer to the memory space of the allocated context
* @retval NULL Invalid null pointer
*/
crypto/drbg/src/drbg.c
-2
View File
@@ -316,13 +316,11 @@ int32_t DRBG_Instantiate(DRBG_Ctx *ctx, const uint8_t *person, uint32_t persLen,
ret = DRBG_GetNonce(ctx, &nonce, &addEntropy);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto ERR_NONCE;
}
ret = DRBG_GetEntropy(ctx, &entropy, addEntropy);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto ERR_ENTROPY;
}
crypto/eal/include/eal_pkey.h
+5 -5
View File
@@ -32,11 +32,11 @@ typedef struct {
typedef struct {
CRYPT_EAL_ProvMgrCtx *mgrCtx;
CRYPT_EAL_Func *funcsAsyCipher;
CRYPT_EAL_Func *funcsExch;
CRYPT_EAL_Func *funcSign;
CRYPT_EAL_Func *funcKem;
CRYPT_EAL_Func *funcsKeyMgmt;
const CRYPT_EAL_Func *funcsAsyCipher;
const CRYPT_EAL_Func *funcsExch;
const CRYPT_EAL_Func *funcSign;
const CRYPT_EAL_Func *funcKem;
const CRYPT_EAL_Func *funcsKeyMgmt;
} CRYPT_EAL_AsyAlgFuncsInfo;
/**
crypto/eal/src/eal_pkey_gen.c
+9 -9
View File
@@ -1527,17 +1527,17 @@ int32_t CRYPT_EAL_ProviderGetAsyAlgFuncs(CRYPT_EAL_LibCtx *libCtx, int32_t algId
int32_t ret = CRYPT_PROVIDER_NOT_SUPPORT;
if (pkeyOperType == CRYPT_EAL_PKEY_UNKNOWN_OPERATE) {
RETURN_RET_IF_ERR(ProviderGetTargetFuncs(libCtx, CRYPT_EAL_OPERAID_ASYMCIPHER, algId,
attrName, (const CRYPT_EAL_Func **)(uintptr_t)&funcs->funcsAsyCipher, &funcs->mgrCtx), ret);
attrName, &funcs->funcsAsyCipher, &funcs->mgrCtx), ret);
RETURN_RET_IF_ERR(ProviderGetTargetFuncs(libCtx, CRYPT_EAL_OPERAID_KEYEXCH, algId,
attrName, (const CRYPT_EAL_Func **)(uintptr_t)&funcs->funcsExch, &funcs->mgrCtx), ret);
attrName, &funcs->funcsExch, &funcs->mgrCtx), ret);
RETURN_RET_IF_ERR(ProviderGetTargetFuncs(libCtx, CRYPT_EAL_OPERAID_SIGN, algId,
attrName, (const CRYPT_EAL_Func **)(uintptr_t)&funcs->funcSign, &funcs->mgrCtx), ret);
attrName, &funcs->funcSign, &funcs->mgrCtx), ret);
RETURN_RET_IF_ERR(ProviderGetTargetFuncs(libCtx, CRYPT_EAL_OPERAID_KEM, algId,
attrName, (const CRYPT_EAL_Func **)(uintptr_t)&funcs->funcKem, &funcs->mgrCtx), ret);
attrName, &funcs->funcKem, &funcs->mgrCtx), ret);
}
if ((pkeyOperType & CRYPT_EAL_PKEY_CIPHER_OPERATE) == CRYPT_EAL_PKEY_CIPHER_OPERATE) {
ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, CRYPT_EAL_OPERAID_ASYMCIPHER, algId, attrName,
(const CRYPT_EAL_Func **)(uintptr_t)&funcs->funcsAsyCipher, &funcs->mgrCtx);
&funcs->funcsAsyCipher, &funcs->mgrCtx);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
@@ -1545,7 +1545,7 @@ int32_t CRYPT_EAL_ProviderGetAsyAlgFuncs(CRYPT_EAL_LibCtx *libCtx, int32_t algId
}
if ((pkeyOperType & CRYPT_EAL_PKEY_EXCH_OPERATE) == CRYPT_EAL_PKEY_EXCH_OPERATE) {
ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, CRYPT_EAL_OPERAID_KEYEXCH, algId, attrName,
(const CRYPT_EAL_Func **)(uintptr_t)&funcs->funcsExch, &funcs->mgrCtx);
&funcs->funcsExch, &funcs->mgrCtx);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
@@ -1553,7 +1553,7 @@ int32_t CRYPT_EAL_ProviderGetAsyAlgFuncs(CRYPT_EAL_LibCtx *libCtx, int32_t algId
}
if ((pkeyOperType & CRYPT_EAL_PKEY_SIGN_OPERATE) == CRYPT_EAL_PKEY_SIGN_OPERATE) {
ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, CRYPT_EAL_OPERAID_SIGN, algId, attrName,
(const CRYPT_EAL_Func **)(uintptr_t)&funcs->funcSign, &funcs->mgrCtx);
&funcs->funcSign, &funcs->mgrCtx);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
@@ -1561,14 +1561,14 @@ int32_t CRYPT_EAL_ProviderGetAsyAlgFuncs(CRYPT_EAL_LibCtx *libCtx, int32_t algId
}
if ((pkeyOperType & CRYPT_EAL_PKEY_KEM_OPERATE) == CRYPT_EAL_PKEY_KEM_OPERATE) {
ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, CRYPT_EAL_OPERAID_KEM, algId, attrName,
(const CRYPT_EAL_Func **)(uintptr_t)&funcs->funcKem, &funcs->mgrCtx);
&funcs->funcKem, &funcs->mgrCtx);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
}
ret = CRYPT_EAL_ProviderGetFuncsAndMgrCtx(libCtx, CRYPT_EAL_OPERAID_KEYMGMT, algId, attrName,
(const CRYPT_EAL_Func **)(uintptr_t)&funcs->funcsKeyMgmt, &funcs->mgrCtx);
&funcs->funcsKeyMgmt, &funcs->mgrCtx);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
crypto/eal/src/eal_rand.c
+24 -24
View File
@@ -474,7 +474,7 @@ static CRYPT_EAL_RndCtx *EAL_RandNewDrbg(CRYPT_RAND_AlgId id, CRYPT_RandSeedMeth
}
randCtx->isDefaultSeed = false;
if (seedMeth == NULL || (seedMeth->getEntropy == NULL && seedMeth->getNonce == NULL)) {
if (seedMeth == NULL || seedMeth->getEntropy == NULL) {
#ifdef HITLS_CRYPTO_ENTROPY
ret = EAL_GetDefaultSeed(&seedMethTmp, &seedTmp);
if (ret != CRYPT_SUCCESS) {
@@ -568,29 +568,11 @@ int32_t CRYPT_EAL_RandInit(CRYPT_RAND_AlgId id, CRYPT_RandSeedMethod *seedMeth,
EAL_RandDeinit(ctx);
return ret;
}
CRYPT_RandRegist((CRYPT_EAL_RandFunc)CRYPT_EAL_Randbytes); // provide a random number generation function for BigNum.
CRYPT_RandRegist((CRYPT_EAL_RandFunc)CRYPT_EAL_Randbytes);
g_globalRndCtx = ctx;
return CRYPT_SUCCESS;
}
int32_t CRYPT_EAL_DrbgInstantiate(CRYPT_EAL_RndCtx *rndCtx, const uint8_t *pers, uint32_t persLen)
{
if (rndCtx == NULL || rndCtx->meth == NULL || rndCtx->meth->inst == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret;
RETURN_RAND_LOCK(rndCtx, ret);
ret = rndCtx->meth->inst(rndCtx->ctx, pers, persLen, NULL);
if (ret != CRYPT_SUCCESS) {
RAND_UNLOCK(rndCtx);
return ret;
}
rndCtx->working = true;
RAND_UNLOCK(rndCtx);
return ret;
}
int32_t CRYPT_EAL_RandbytesWithAdin(uint8_t *byte, uint32_t len, uint8_t *addin, uint32_t addinLen)
{
if (g_globalRndCtx == NULL) {
@@ -630,6 +612,24 @@ bool CRYPT_EAL_RandIsValidAlgId(CRYPT_RAND_AlgId id)
}
#endif // end of HITLS_CRYPTO_DRBG
int32_t CRYPT_EAL_DrbgInstantiate(CRYPT_EAL_RndCtx *rndCtx, const uint8_t *pers, uint32_t persLen)
{
if (rndCtx == NULL || rndCtx->meth == NULL || rndCtx->meth->inst == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret;
RETURN_RAND_LOCK(rndCtx, ret);
ret = rndCtx->meth->inst(rndCtx->ctx, pers, persLen, NULL);
if (ret != CRYPT_SUCCESS) {
RAND_UNLOCK(rndCtx);
return ret;
}
rndCtx->working = true;
RAND_UNLOCK(rndCtx);
return ret;
}
CRYPT_EAL_RndCtx *CRYPT_EAL_DrbgNew(CRYPT_RAND_AlgId id, CRYPT_RandSeedMethod *seedMeth, void *seedCtx)
{
if (seedMeth == NULL && seedCtx != NULL) {
@@ -819,7 +819,7 @@ int32_t CRYPT_EAL_ProviderRandInitCtxInner(CRYPT_EAL_LibCtx *libCtx, int32_t alg
return ret;
}
ctx->working = true;
CRYPT_RandRegistEx((CRYPT_EAL_RandFuncEx)CRYPT_EAL_RandbytesEx); // provide a random number generation function for BigNum.
CRYPT_RandRegistEx((CRYPT_EAL_RandFuncEx)CRYPT_EAL_RandbytesEx);
localLibCtx->drbg = ctx;
return CRYPT_SUCCESS;
}
@@ -920,7 +920,7 @@ int32_t CRYPT_EAL_RandbytesWithAdinEx(CRYPT_EAL_LibCtx *libCtx,
BSL_ERR_PUSH_ERROR(CRYPT_PROVIDER_INVALID_LIB_CTX);
return CRYPT_PROVIDER_INVALID_LIB_CTX;
}
return CRYPT_EAL_DrbgbytesWithAdin(localCtx->drbg, byte, len, addin, addinLen);
return EAL_DrbgbytesWithAdin((CRYPT_EAL_RndCtx *)localCtx->drbg, byte, len, addin, addinLen);
}
#endif
@@ -935,7 +935,7 @@ int32_t CRYPT_EAL_RandbytesEx(CRYPT_EAL_LibCtx *libCtx, uint8_t *byte, uint32_t
BSL_ERR_PUSH_ERROR(CRYPT_PROVIDER_INVALID_LIB_CTX);
return CRYPT_PROVIDER_INVALID_LIB_CTX;
}
return CRYPT_EAL_DrbgbytesWithAdin(localCtx->drbg, byte, len, NULL, 0);
return EAL_DrbgbytesWithAdin((CRYPT_EAL_RndCtx *)localCtx->drbg, byte, len, NULL, 0);
#else
(void) libCtx;
return CRYPT_EAL_Randbytes(byte, len);
@@ -954,7 +954,7 @@ int32_t CRYPT_EAL_RandSeedEx(CRYPT_EAL_LibCtx *libCtx)
BSL_ERR_PUSH_ERROR(CRYPT_PROVIDER_INVALID_LIB_CTX);
return CRYPT_PROVIDER_INVALID_LIB_CTX;
}
return CRYPT_EAL_DrbgSeedWithAdin(localCtx->drbg, NULL, 0);
return EAL_DrbgSeedWithAdin((CRYPT_EAL_RndCtx *)localCtx->drbg, NULL, 0);
#else
(void) libCtx;
return CRYPT_EAL_RandSeed();
crypto/hpke/src/hpke.c
+1 -1
View File
@@ -1575,7 +1575,7 @@ int32_t CRYPT_EAL_HpkeGenerateKeyPair(CRYPT_EAL_LibCtx *libCtx, const char *attr
}
uint8_t ikmNew[HPKE_KEM_MAX_PRIVATE_KEY_LEN];
ret = CRYPT_EAL_RandbytesEx(NULL, ikmNew, ikmNewLen);
ret = CRYPT_EAL_RandbytesEx(libCtx, ikmNew, ikmNewLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
crypto/include/crypt_local_types.h
+1 -2
View File
@@ -20,6 +20,7 @@
#include "crypt_types.h"
#include "bsl_params.h"
#include "crypt_params_key.h"
#include "crypt_eal_provider.h"
#ifdef __cplusplus
extern "C" {
@@ -31,8 +32,6 @@ extern "C" {
/* length function */
typedef int32_t (*GetLenFunc)(const void *ctx);
typedef int32_t (*CRYPT_EAL_ProcessFuncCb)(const BSL_Param *param, void *args);
/* Prototype of the MD algorithm operation functions */
typedef void* (*MdNewCtx)(void);
typedef void* (*MdProvNewCtx)(void *provCtx, int32_t algId);
crypto/include/crypt_utils.h
+9 -1
View File
@@ -152,6 +152,14 @@ do { \
} \
} while (0)
#define RETURN_RET_IF_ERR_EX(func, ret) \
do { \
(ret) = (func); \
if ((ret) != CRYPT_SUCCESS) { \
return ret; \
} \
} while (0)
#define BREAK_IF(condition) \
do { \
if (condition) { \
@@ -251,7 +259,7 @@ do { \
* @param size [IN] Size of hash data
* @param out [OUT] Output hash value
*/
int32_t CalcHash(const EAL_MdMethod *hashMethod, const CRYPT_ConstData *hashData, uint32_t size,
int32_t CRYPT_CalcHash(const EAL_MdMethod *hashMethod, const CRYPT_ConstData *hashData, uint32_t size,
uint8_t *out, uint32_t *outlen);
/**
crypto/mldsa/src/ml_dsa.c
+1 -1
View File
@@ -560,7 +560,7 @@ static int32_t MLDSAPreHashEncode(CRYPT_ML_DSA_Ctx *ctx, int32_t hashId, const u
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
BslOidString *oidInfo = BSL_OBJ_GetOidFromCID(hashId);
BslOidString *oidInfo = BSL_OBJ_GetOID(hashId);
RETURN_RET_IF(oidInfo == NULL, CRYPT_ERR_ALGID);
const EAL_MdMethod *hashMethod = EAL_MdFindMethod(hashId);
crypto/provider/include/crypt_default_provderimpl.h
+83 -83
View File
@@ -30,98 +30,98 @@
extern "C" {
#endif // __cplusplus
extern const CRYPT_EAL_Func g_defMdMd5[];
extern const CRYPT_EAL_Func g_defMdSha1[];
extern const CRYPT_EAL_Func g_defMdSha224[];
extern const CRYPT_EAL_Func g_defMdSha256[];
extern const CRYPT_EAL_Func g_defMdSha384[];
extern const CRYPT_EAL_Func g_defMdSha512[];
extern const CRYPT_EAL_Func g_defMdSha3224[];
extern const CRYPT_EAL_Func g_defMdSha3256[];
extern const CRYPT_EAL_Func g_defMdSha3384[];
extern const CRYPT_EAL_Func g_defMdSha3512[];
extern const CRYPT_EAL_Func g_defMdShake512[];
extern const CRYPT_EAL_Func g_defMdShake128[];
extern const CRYPT_EAL_Func g_defMdShake256[];
extern const CRYPT_EAL_Func g_defMdSm3[];
extern const CRYPT_EAL_Func g_defEalMdMd5[];
extern const CRYPT_EAL_Func g_defEalMdSha1[];
extern const CRYPT_EAL_Func g_defEalMdSha224[];
extern const CRYPT_EAL_Func g_defEalMdSha256[];
extern const CRYPT_EAL_Func g_defEalMdSha384[];
extern const CRYPT_EAL_Func g_defEalMdSha512[];
extern const CRYPT_EAL_Func g_defEalMdSha3224[];
extern const CRYPT_EAL_Func g_defEalMdSha3256[];
extern const CRYPT_EAL_Func g_defEalMdSha3384[];
extern const CRYPT_EAL_Func g_defEalMdSha3512[];
extern const CRYPT_EAL_Func g_defEalMdShake512[];
extern const CRYPT_EAL_Func g_defEalMdShake128[];
extern const CRYPT_EAL_Func g_defEalMdShake256[];
extern const CRYPT_EAL_Func g_defEalMdSm3[];
extern const CRYPT_EAL_Func g_defKdfScrypt[];
extern const CRYPT_EAL_Func g_defKdfPBKdf2[];
extern const CRYPT_EAL_Func g_defKdfKdfTLS12[];
extern const CRYPT_EAL_Func g_defKdfHkdf[];
extern const CRYPT_EAL_Func g_defEalKdfScrypt[];
extern const CRYPT_EAL_Func g_defEalKdfPBKdf2[];
extern const CRYPT_EAL_Func g_defEalKdfKdfTLS12[];
extern const CRYPT_EAL_Func g_defEalKdfHkdf[];
extern const CRYPT_EAL_Func g_defKeyMgmtDsa[];
extern const CRYPT_EAL_Func g_defKeyMgmtEd25519[];
extern const CRYPT_EAL_Func g_defKeyMgmtX25519[];
extern const CRYPT_EAL_Func g_defKeyMgmtRsa[];
extern const CRYPT_EAL_Func g_defKeyMgmtDh[];
extern const CRYPT_EAL_Func g_defKeyMgmtEcdsa[];
extern const CRYPT_EAL_Func g_defKeyMgmtEcdh[];
extern const CRYPT_EAL_Func g_defKeyMgmtSm2[];
extern const CRYPT_EAL_Func g_defKeyMgmtPaillier[];
extern const CRYPT_EAL_Func g_defKeyMgmtSlhDsa[];
extern const CRYPT_EAL_Func g_defKeyMgmtElGamal[];
extern const CRYPT_EAL_Func g_defKeyMgmtMlKem[];
extern const CRYPT_EAL_Func g_defKeyMgmtMlDsa[];
extern const CRYPT_EAL_Func g_defKeyMgmtHybridKem[];
extern const CRYPT_EAL_Func g_defEalKeyMgmtDsa[];
extern const CRYPT_EAL_Func g_defEalKeyMgmtEd25519[];
extern const CRYPT_EAL_Func g_defEalKeyMgmtX25519[];
extern const CRYPT_EAL_Func g_defEalKeyMgmtRsa[];
extern const CRYPT_EAL_Func g_defEalKeyMgmtDh[];
extern const CRYPT_EAL_Func g_defEalKeyMgmtEcdsa[];
extern const CRYPT_EAL_Func g_defEalKeyMgmtEcdh[];
extern const CRYPT_EAL_Func g_defEalKeyMgmtSm2[];
extern const CRYPT_EAL_Func g_defEalKeyMgmtPaillier[];
extern const CRYPT_EAL_Func g_defEalKeyMgmtSlhDsa[];
extern const CRYPT_EAL_Func g_defEalKeyMgmtElGamal[];
extern const CRYPT_EAL_Func g_defEalKeyMgmtMlKem[];
extern const CRYPT_EAL_Func g_defEalKeyMgmtMlDsa[];
extern const CRYPT_EAL_Func g_defEalKeyMgmtHybridKem[];
extern const CRYPT_EAL_Func g_defExchX25519[];
extern const CRYPT_EAL_Func g_defExchDh[];
extern const CRYPT_EAL_Func g_defExchEcdh[];
extern const CRYPT_EAL_Func g_defExchSm2[];
extern const CRYPT_EAL_Func g_defEalExchX25519[];
extern const CRYPT_EAL_Func g_defEalExchDh[];
extern const CRYPT_EAL_Func g_defEalExchEcdh[];
extern const CRYPT_EAL_Func g_defEalExchSm2[];
extern const CRYPT_EAL_Func g_defAsymCipherRsa[];
extern const CRYPT_EAL_Func g_defAsymCipherSm2[];
extern const CRYPT_EAL_Func g_defAsymCipherPaillier[];
extern const CRYPT_EAL_Func g_defAsymCipherElGamal[];
extern const CRYPT_EAL_Func g_defEalAsymCipherRsa[];
extern const CRYPT_EAL_Func g_defEalAsymCipherSm2[];
extern const CRYPT_EAL_Func g_defEalAsymCipherPaillier[];
extern const CRYPT_EAL_Func g_defEalAsymCipherElGamal[];
extern const CRYPT_EAL_Func g_defSignDsa[];
extern const CRYPT_EAL_Func g_defSignEd25519[];
extern const CRYPT_EAL_Func g_defSignRsa[];
extern const CRYPT_EAL_Func g_defSignEcdsa[];
extern const CRYPT_EAL_Func g_defSignSm2[];
extern const CRYPT_EAL_Func g_defSignMlDsa[];
extern const CRYPT_EAL_Func g_defMacHmac[];
extern const CRYPT_EAL_Func g_defSignSlhDsa[];
extern const CRYPT_EAL_Func g_defMacCmac[];
extern const CRYPT_EAL_Func g_defMacCbcMac[];
extern const CRYPT_EAL_Func g_defMacGmac[];
extern const CRYPT_EAL_Func g_defMacSiphash[];
extern const CRYPT_EAL_Func g_defEalSignDsa[];
extern const CRYPT_EAL_Func g_defEalSignEd25519[];
extern const CRYPT_EAL_Func g_defEalSignRsa[];
extern const CRYPT_EAL_Func g_defEalSignEcdsa[];
extern const CRYPT_EAL_Func g_defEalSignSm2[];
extern const CRYPT_EAL_Func g_defEalSignMlDsa[];
extern const CRYPT_EAL_Func g_defEalMacHmac[];
extern const CRYPT_EAL_Func g_defEalSignSlhDsa[];
extern const CRYPT_EAL_Func g_defEalMacCmac[];
extern const CRYPT_EAL_Func g_defEalMacCbcMac[];
extern const CRYPT_EAL_Func g_defEalMacGmac[];
extern const CRYPT_EAL_Func g_defEalMacSiphash[];
extern const CRYPT_EAL_Func g_defRand[];
extern const CRYPT_EAL_Func g_defEalRand[];
extern const CRYPT_EAL_Func g_defCbc[];
extern const CRYPT_EAL_Func g_defCcm[];
extern const CRYPT_EAL_Func g_defCfb[];
extern const CRYPT_EAL_Func g_defChaCha[];
extern const CRYPT_EAL_Func g_defCtr[];
extern const CRYPT_EAL_Func g_defEcb[];
extern const CRYPT_EAL_Func g_defGcm[];
extern const CRYPT_EAL_Func g_defOfb[];
extern const CRYPT_EAL_Func g_defXts[];
extern const CRYPT_EAL_Func g_defMlKem[];
extern const CRYPT_EAL_Func g_defHybridKeyKem[];
extern const CRYPT_EAL_Func g_defEalCbc[];
extern const CRYPT_EAL_Func g_defEalCcm[];
extern const CRYPT_EAL_Func g_defEalCfb[];
extern const CRYPT_EAL_Func g_defEalChaCha[];
extern const CRYPT_EAL_Func g_defEalCtr[];
extern const CRYPT_EAL_Func g_defEalEcb[];
extern const CRYPT_EAL_Func g_defEalGcm[];
extern const CRYPT_EAL_Func g_defEalOfb[];
extern const CRYPT_EAL_Func g_defEalXts[];
extern const CRYPT_EAL_Func g_defEalMlKem[];
extern const CRYPT_EAL_Func g_defEalHybridKeyKem[];
extern const CRYPT_EAL_Func g_defPrvP8Enc2P8[];
extern const CRYPT_EAL_Func g_defPem2Der[];
extern const CRYPT_EAL_Func g_defRsaPrvDer2Key[];
extern const CRYPT_EAL_Func g_defEcdsaPrvDer2Key[];
extern const CRYPT_EAL_Func g_defSm2PrvDer2Key[];
extern const CRYPT_EAL_Func g_defP8Der2RsaKey[];
extern const CRYPT_EAL_Func g_defP8Der2EcdsaKey[];
extern const CRYPT_EAL_Func g_defP8Der2Sm2Key[];
extern const CRYPT_EAL_Func g_defP8Der2Ed25519Key[];
extern const CRYPT_EAL_Func g_defSubPubKeyDer2RsaKey[];
extern const CRYPT_EAL_Func g_defSubPubKeyDer2EcdsaKey[];
extern const CRYPT_EAL_Func g_defSubPubKeyDer2Sm2Key[];
extern const CRYPT_EAL_Func g_defSubPubKeyDer2Ed25519Key[];
extern const CRYPT_EAL_Func g_defSubPubKeyWithoutSeqDer2RsaKey[];
extern const CRYPT_EAL_Func g_defSubPubKeyWithoutSeqDer2EcdsaKey[];
extern const CRYPT_EAL_Func g_defSubPubKeyWithoutSeqDer2Sm2Key[];
extern const CRYPT_EAL_Func g_defSubPubKeyWithoutSeqDer2Ed25519Key[];
extern const CRYPT_EAL_Func g_defLowKeyObject2PkeyObject[];
extern const CRYPT_EAL_Func g_defRsaPubDer2Key[];
extern const CRYPT_EAL_Func g_defEalPrvP8Enc2P8[];
extern const CRYPT_EAL_Func g_defEalPem2Der[];
extern const CRYPT_EAL_Func g_defEalRsaPrvDer2Key[];
extern const CRYPT_EAL_Func g_defEalEcdsaPrvDer2Key[];
extern const CRYPT_EAL_Func g_defEalSm2PrvDer2Key[];
extern const CRYPT_EAL_Func g_defEalP8Der2RsaKey[];
extern const CRYPT_EAL_Func g_defEalP8Der2EcdsaKey[];
extern const CRYPT_EAL_Func g_defEalP8Der2Sm2Key[];
extern const CRYPT_EAL_Func g_defEalP8Der2Ed25519Key[];
extern const CRYPT_EAL_Func g_defEalSubPubKeyDer2RsaKey[];
extern const CRYPT_EAL_Func g_defEalSubPubKeyDer2EcdsaKey[];
extern const CRYPT_EAL_Func g_defEalSubPubKeyDer2Sm2Key[];
extern const CRYPT_EAL_Func g_defEalSubPubKeyDer2Ed25519Key[];
extern const CRYPT_EAL_Func g_defEalSubPubKeyWithoutSeqDer2RsaKey[];
extern const CRYPT_EAL_Func g_defEalSubPubKeyWithoutSeqDer2EcdsaKey[];
extern const CRYPT_EAL_Func g_defEalSubPubKeyWithoutSeqDer2Sm2Key[];
extern const CRYPT_EAL_Func g_defEalSubPubKeyWithoutSeqDer2Ed25519Key[];
extern const CRYPT_EAL_Func g_defEalLowKeyObject2PkeyObject[];
extern const CRYPT_EAL_Func g_defEalRsaPubDer2Key[];
#ifdef __cplusplus
}
crypto/provider/src/default/crypt_default_cipher.c
+9 -9
View File
@@ -82,7 +82,7 @@ static void *CRYPT_EAL_DefCipherNewCtx(void *provCtx, int32_t algId)
return NULL;
}
const CRYPT_EAL_Func g_defCbc[] = {
const CRYPT_EAL_Func g_defEalCbc[] = {
#ifdef HITLS_CRYPTO_CBC
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)CRYPT_EAL_DefCipherNewCtx},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_CBC_InitCtxEx},
@@ -95,7 +95,7 @@ const CRYPT_EAL_Func g_defCbc[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defCcm[] = {
const CRYPT_EAL_Func g_defEalCcm[] = {
#ifdef HITLS_CRYPTO_CCM
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)CRYPT_EAL_DefCipherNewCtx},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_CCM_InitCtx},
@@ -108,7 +108,7 @@ const CRYPT_EAL_Func g_defCcm[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defCfb[] = {
const CRYPT_EAL_Func g_defEalCfb[] = {
#ifdef HITLS_CRYPTO_CFB
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)CRYPT_EAL_DefCipherNewCtx},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_CFB_InitCtxEx},
@@ -121,7 +121,7 @@ const CRYPT_EAL_Func g_defCfb[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defChaCha[] = {
const CRYPT_EAL_Func g_defEalChaCha[] = {
#if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)CRYPT_EAL_DefCipherNewCtx},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_CHACHA20POLY1305_InitCtx},
@@ -134,7 +134,7 @@ const CRYPT_EAL_Func g_defChaCha[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defCtr[] = {
const CRYPT_EAL_Func g_defEalCtr[] = {
#ifdef HITLS_CRYPTO_CTR
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)CRYPT_EAL_DefCipherNewCtx},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_CTR_InitCtxEx},
@@ -147,7 +147,7 @@ const CRYPT_EAL_Func g_defCtr[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defEcb[] = {
const CRYPT_EAL_Func g_defEalEcb[] = {
#ifdef HITLS_CRYPTO_ECB
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)CRYPT_EAL_DefCipherNewCtx},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_ECB_InitCtxEx},
@@ -160,7 +160,7 @@ const CRYPT_EAL_Func g_defEcb[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defGcm[] = {
const CRYPT_EAL_Func g_defEalGcm[] = {
#ifdef HITLS_CRYPTO_GCM
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)CRYPT_EAL_DefCipherNewCtx},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_GCM_InitCtxEx},
@@ -173,7 +173,7 @@ const CRYPT_EAL_Func g_defGcm[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defOfb[] = {
const CRYPT_EAL_Func g_defEalOfb[] = {
#ifdef HITLS_CRYPTO_OFB
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)CRYPT_EAL_DefCipherNewCtx},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_OFB_InitCtxEx},
@@ -186,7 +186,7 @@ const CRYPT_EAL_Func g_defOfb[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defXts[] = {
const CRYPT_EAL_Func g_defEalXts[] = {
#ifdef HITLS_CRYPTO_XTS
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)CRYPT_EAL_DefCipherNewCtx},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_XTS_InitCtxEx},
crypto/provider/src/default/crypt_default_decode.c
+133 -133
View File
@@ -18,192 +18,192 @@
#include "crypt_eal_pkey.h"
#include "crypt_decode_key_impl.h"
const CRYPT_EAL_Func g_defPrvP8Enc2P8[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_EPki2Pki_NewCtx},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_EPki2Pki_SetParam},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_EPki2Pki_GetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_EPki2Pki_Decode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_EPki2Pki_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_EPki2Pki_FreeCtx},
const CRYPT_EAL_Func g_defEalPrvP8Enc2P8[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_EPKI2PKI_NewCtx},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_EPKI2PKI_SetParam},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_EPKI2PKI_GetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_EPKI2PKI_Decode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_EPKI2PKI_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_EPKI2PKI_FreeCtx},
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defPem2Der[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_Pem2Der_NewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_Pem2Der_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_Pem2Der_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_Pem2Der_Decode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_Pem2Der_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_Pem2Der_FreeCtx},
const CRYPT_EAL_Func g_defEalPem2Der[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_Pem2DerNewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_Pem2DerGetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_Pem2DerSetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_Pem2DerDecode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_Pem2DerFreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_Pem2DerFreeCtx},
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defRsaPrvDer2Key[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_RsaDer2Key_NewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_Der2Key_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_Der2Key_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_RsaPrvKeyDer2Key_Decode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_Der2Key_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_Der2Key_FreeCtx},
const CRYPT_EAL_Func g_defEalRsaPrvDer2Key[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_RsaDer2KeyNewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_DER2KEY_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_DER2KEY_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_RsaPrvKeyDer2KeyDecode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_DER2KEY_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_DER2KEY_FreeCtx},
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defRsaPubDer2Key[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_RsaDer2Key_NewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_Der2Key_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_Der2Key_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_RsaPubKeyDer2Key_Decode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_Der2Key_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_Der2Key_FreeCtx},
const CRYPT_EAL_Func g_defEalRsaPubDer2Key[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_RsaDer2KeyNewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_DER2KEY_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_DER2KEY_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_RsaPubKeyDer2KeyDecode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_DER2KEY_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_DER2KEY_FreeCtx},
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defEcdsaPrvDer2Key[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_EcdsaDer2Key_NewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_Der2Key_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_Der2Key_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_EcdsaPrvKeyDer2Key_Decode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_Der2Key_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_Der2Key_FreeCtx},
const CRYPT_EAL_Func g_defEalEcdsaPrvDer2Key[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_EcdsaDer2KeyNewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_DER2KEY_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_DER2KEY_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_EcdsaPrvKeyDer2KeyDecode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_DER2KEY_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_DER2KEY_FreeCtx},
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defSm2PrvDer2Key[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_Sm2Der2Key_NewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_Der2Key_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_Der2Key_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_Sm2PrvKeyDer2Key_Decode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_Der2Key_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_Der2Key_FreeCtx},
const CRYPT_EAL_Func g_defEalSm2PrvDer2Key[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_Sm2Der2KeyNewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_DER2KEY_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_DER2KEY_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_Sm2PrvKeyDer2KeyDecode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_DER2KEY_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_DER2KEY_FreeCtx},
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defP8Der2RsaKey[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_RsaDer2Key_NewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_Der2Key_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_Der2Key_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_RsaPkcs8Der2Key_Decode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_Der2Key_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_Der2Key_FreeCtx},
const CRYPT_EAL_Func g_defEalP8Der2RsaKey[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_RsaDer2KeyNewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_DER2KEY_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_DER2KEY_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_RsaPkcs8Der2KeyDecode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_DER2KEY_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_DER2KEY_FreeCtx},
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defP8Der2EcdsaKey[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_EcdsaDer2Key_NewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_Der2Key_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_Der2Key_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_EcdsaPkcs8Der2Key_Decode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_Der2Key_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_Der2Key_FreeCtx},
const CRYPT_EAL_Func g_defEalP8Der2EcdsaKey[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_EcdsaDer2KeyNewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_DER2KEY_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_DER2KEY_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_EcdsaPkcs8Der2KeyDecode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_DER2KEY_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_DER2KEY_FreeCtx},
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defP8Der2Sm2Key[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_Sm2Der2Key_NewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_Der2Key_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_Der2Key_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_Sm2Pkcs8Der2Key_Decode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_Der2Key_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_Der2Key_FreeCtx},
const CRYPT_EAL_Func g_defEalP8Der2Sm2Key[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_Sm2Der2KeyNewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_DER2KEY_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_DER2KEY_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_Sm2Pkcs8Der2KeyDecode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_DER2KEY_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_DER2KEY_FreeCtx},
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defP8Der2Ed25519Key[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_Ed25519Der2Key_NewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_Der2Key_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_Der2Key_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_Ed25519Pkcs8Der2Key_Decode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_Der2Key_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_Der2Key_FreeCtx},
const CRYPT_EAL_Func g_defEalP8Der2Ed25519Key[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_Ed25519Der2KeyNewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_DER2KEY_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_DER2KEY_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_Ed25519Pkcs8Der2KeyDecode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_DER2KEY_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_DER2KEY_FreeCtx},
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defSubPubKeyDer2RsaKey[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_RsaDer2Key_NewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_Der2Key_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_Der2Key_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_RsaSubPubKeyDer2Key_Decode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_Der2Key_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_Der2Key_FreeCtx},
const CRYPT_EAL_Func g_defEalSubPubKeyDer2RsaKey[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_RsaDer2KeyNewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_DER2KEY_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_DER2KEY_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_RsaSubPubKeyDer2KeyDecode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_DER2KEY_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_DER2KEY_FreeCtx},
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defSubPubKeyDer2EcdsaKey[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_EcdsaDer2Key_NewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_Der2Key_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_Der2Key_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_EcdsaSubPubKeyDer2Key_Decode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_Der2Key_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_Der2Key_FreeCtx},
const CRYPT_EAL_Func g_defEalSubPubKeyDer2EcdsaKey[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_EcdsaDer2KeyNewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_DER2KEY_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_DER2KEY_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_EcdsaSubPubKeyDer2KeyDecode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_DER2KEY_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_DER2KEY_FreeCtx},
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defSubPubKeyDer2Sm2Key[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_Sm2Der2Key_NewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_Der2Key_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_Der2Key_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_Sm2SubPubKeyDer2Key_Decode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_Der2Key_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_Der2Key_FreeCtx},
const CRYPT_EAL_Func g_defEalSubPubKeyDer2Sm2Key[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_Sm2Der2KeyNewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_DER2KEY_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_DER2KEY_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_Sm2SubPubKeyDer2KeyDecode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_DER2KEY_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_DER2KEY_FreeCtx},
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defSubPubKeyDer2Ed25519Key[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_Ed25519Der2Key_NewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_Der2Key_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_Der2Key_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_Ed25519SubPubKeyDer2Key_Decode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_Der2Key_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_Der2Key_FreeCtx},
const CRYPT_EAL_Func g_defEalSubPubKeyDer2Ed25519Key[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_Ed25519Der2KeyNewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_DER2KEY_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_DER2KEY_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_Ed25519SubPubKeyDer2KeyDecode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_DER2KEY_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_DER2KEY_FreeCtx},
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defSubPubKeyWithoutSeqDer2RsaKey[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_RsaDer2Key_NewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_Der2Key_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_Der2Key_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_RsaSubPubKeyWithOutSeqDer2Key_Decode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_Der2Key_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_Der2Key_FreeCtx},
const CRYPT_EAL_Func g_defEalSubPubKeyWithoutSeqDer2RsaKey[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_RsaDer2KeyNewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_DER2KEY_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_DER2KEY_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_RsaSubPubKeyWithOutSeqDer2KeyDecode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_DER2KEY_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_DER2KEY_FreeCtx},
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defSubPubKeyWithoutSeqDer2EcdsaKey[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_EcdsaDer2Key_NewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_Der2Key_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_Der2Key_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_EcdsaSubPubKeyWithOutSeqDer2Key_Decode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_Der2Key_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_Der2Key_FreeCtx},
const CRYPT_EAL_Func g_defEalSubPubKeyWithoutSeqDer2EcdsaKey[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_EcdsaDer2KeyNewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_DER2KEY_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_DER2KEY_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_EcdsaSubPubKeyWithOutSeqDer2KeyDecode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_DER2KEY_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_DER2KEY_FreeCtx},
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defSubPubKeyWithoutSeqDer2Sm2Key[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_Sm2Der2Key_NewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_Der2Key_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_Der2Key_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_Sm2SubPubKeyWithOutSeqDer2Key_Decode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_Der2Key_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_Der2Key_FreeCtx},
const CRYPT_EAL_Func g_defEalSubPubKeyWithoutSeqDer2Sm2Key[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_Sm2Der2KeyNewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_DER2KEY_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_DER2KEY_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_Sm2SubPubKeyWithOutSeqDer2KeyDecode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_DER2KEY_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_DER2KEY_FreeCtx},
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defSubPubKeyWithoutSeqDer2Ed25519Key[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_Ed25519Der2Key_NewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_Der2Key_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_Der2Key_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_Ed25519SubPubKeyWithOutSeqDer2Key_Decode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_Der2Key_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_Der2Key_FreeCtx},
const CRYPT_EAL_Func g_defEalSubPubKeyWithoutSeqDer2Ed25519Key[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_Ed25519Der2KeyNewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_DER2KEY_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_DER2KEY_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_Ed25519SubPubKeyWithOutSeqDer2KeyDecode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_DER2KEY_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_DER2KEY_FreeCtx},
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defLowKeyObject2PkeyObject[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_LowKeyObject2PkeyObject_NewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_LowKeyObject2PkeyObject_GetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_LowKeyObject2PkeyObject_SetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_LowKeyObject2PkeyObject_Decode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_LowKeyObject2PkeyObject_FreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_LowKeyObject2PkeyObject_FreeCtx},
const CRYPT_EAL_Func g_defEalLowKeyObject2PkeyObject[] = {
{CRYPT_DECODER_IMPL_NEWCTX, (CRYPT_DECODER_IMPL_NewCtx)DECODER_LowKeyObject2PkeyObjectNewCtx},
{CRYPT_DECODER_IMPL_GETPARAM, (CRYPT_DECODER_IMPL_GetParam)DECODER_LowKeyObject2PkeyObjectGetParam},
{CRYPT_DECODER_IMPL_SETPARAM, (CRYPT_DECODER_IMPL_SetParam)DECODER_LowKeyObject2PkeyObjectSetParam},
{CRYPT_DECODER_IMPL_DECODE, (CRYPT_DECODER_IMPL_Decode)DECODER_LowKeyObject2PkeyObjectDecode},
{CRYPT_DECODER_IMPL_FREEOUTDATA, (CRYPT_DECODER_IMPL_FreeOutData)DECODER_LowKeyObject2PkeyObjectFreeOutData},
{CRYPT_DECODER_IMPL_FREECTX, (CRYPT_DECODER_IMPL_FreeCtx)DECODER_LowKeyObject2PkeyObjectFreeCtx},
CRYPT_EAL_FUNC_END,
};
crypto/provider/src/default/crypt_default_kdf.c
+4 -4
View File
@@ -64,7 +64,7 @@ int32_t CRYPT_EAL_DefKdfCtrl(void *ctx, int32_t cmd, void *val, uint32_t valLen)
return CRYPT_NOT_SUPPORT;
}
const CRYPT_EAL_Func g_defKdfScrypt[] = {
const CRYPT_EAL_Func g_defEalKdfScrypt[] = {
#ifdef HITLS_CRYPTO_SCRYPT
{CRYPT_EAL_IMPLKDF_NEWCTX, (CRYPT_EAL_ImplKdfNewCtx)CRYPT_EAL_DefKdfNewCtx},
{CRYPT_EAL_IMPLKDF_SETPARAM, (CRYPT_EAL_ImplKdfSetParam)CRYPT_SCRYPT_SetParam},
@@ -76,7 +76,7 @@ const CRYPT_EAL_Func g_defKdfScrypt[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defKdfPBKdf2[] = {
const CRYPT_EAL_Func g_defEalKdfPBKdf2[] = {
#ifdef HITLS_CRYPTO_PBKDF2
{CRYPT_EAL_IMPLKDF_NEWCTX, (CRYPT_EAL_ImplKdfNewCtx)CRYPT_EAL_DefKdfNewCtx},
{CRYPT_EAL_IMPLKDF_SETPARAM, (CRYPT_EAL_ImplKdfSetParam)CRYPT_PBKDF2_SetParam},
@@ -88,7 +88,7 @@ const CRYPT_EAL_Func g_defKdfPBKdf2[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defKdfKdfTLS12[] = {
const CRYPT_EAL_Func g_defEalKdfKdfTLS12[] = {
#ifdef HITLS_CRYPTO_KDFTLS12
{CRYPT_EAL_IMPLKDF_NEWCTX, (CRYPT_EAL_ImplKdfNewCtx)CRYPT_EAL_DefKdfNewCtx},
{CRYPT_EAL_IMPLKDF_SETPARAM, (CRYPT_EAL_ImplKdfSetParam)CRYPT_KDFTLS12_SetParam},
@@ -100,7 +100,7 @@ const CRYPT_EAL_Func g_defKdfKdfTLS12[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defKdfHkdf[] = {
const CRYPT_EAL_Func g_defEalKdfHkdf[] = {
#ifdef HITLS_CRYPTO_HKDF
{CRYPT_EAL_IMPLKDF_NEWCTX, (CRYPT_EAL_ImplKdfNewCtx)CRYPT_EAL_DefKdfNewCtx},
{CRYPT_EAL_IMPLKDF_SETPARAM, (CRYPT_EAL_ImplKdfSetParam)CRYPT_HKDF_SetParam},
crypto/provider/src/default/crypt_default_kem.c
+2 -2
View File
@@ -24,7 +24,7 @@
#include "crypt_hybridkem.h"
#endif
const CRYPT_EAL_Func g_defMlKem[] = {
const CRYPT_EAL_Func g_defEalMlKem[] = {
#ifdef HITLS_CRYPTO_MLKEM
{CRYPT_EAL_IMPLPKEYKEM_ENCAPSULATE, (CRYPT_EAL_ImplPkeyKemEncapsulate)CRYPT_ML_KEM_Encaps},
{CRYPT_EAL_IMPLPKEYKEM_DECAPSULATE, (CRYPT_EAL_ImplPkeyKemDecapsulate)CRYPT_ML_KEM_Decaps},
@@ -32,7 +32,7 @@ const CRYPT_EAL_Func g_defMlKem[] = {
CRYPT_EAL_FUNC_END
};
const CRYPT_EAL_Func g_defHybridKeyKem[] = {
const CRYPT_EAL_Func g_defEalHybridKeyKem[] = {
#ifdef HITLS_CRYPTO_HYBRIDKEM
{CRYPT_EAL_IMPLPKEYKEM_ENCAPSULATE, (CRYPT_EAL_ImplPkeyKemEncapsulate)CRYPT_HYBRID_KEM_Encaps},
{CRYPT_EAL_IMPLPKEYKEM_DECAPSULATE, (CRYPT_EAL_ImplPkeyKemDecapsulate)CRYPT_HYBRID_KEM_Decaps},
crypto/provider/src/default/crypt_default_keyexch.c
+4 -4
View File
@@ -28,28 +28,28 @@ typedef struct {
int32_t index;
} CRYPT_EAL_DefPkeyCtx;
const CRYPT_EAL_Func g_defExchX25519[] = {
const CRYPT_EAL_Func g_defEalExchX25519[] = {
#ifdef HITLS_CRYPTO_X25519
{CRYPT_EAL_IMPLPKEYEXCH_EXCH, (CRYPT_EAL_ImplPkeyExch)CRYPT_CURVE25519_ComputeSharedKey},
#endif
CRYPT_EAL_FUNC_END
};
const CRYPT_EAL_Func g_defExchDh[] = {
const CRYPT_EAL_Func g_defEalExchDh[] = {
#ifdef HITLS_CRYPTO_DH
{CRYPT_EAL_IMPLPKEYEXCH_EXCH, (CRYPT_EAL_ImplPkeyExch)CRYPT_DH_ComputeShareKey},
#endif
CRYPT_EAL_FUNC_END
};
const CRYPT_EAL_Func g_defExchEcdh[] = {
const CRYPT_EAL_Func g_defEalExchEcdh[] = {
#ifdef HITLS_CRYPTO_ECDH
{CRYPT_EAL_IMPLPKEYEXCH_EXCH, (CRYPT_EAL_ImplPkeyExch)CRYPT_ECDH_ComputeShareKey},
#endif
CRYPT_EAL_FUNC_END
};
const CRYPT_EAL_Func g_defExchSm2[] = {
const CRYPT_EAL_Func g_defEalExchSm2[] = {
#if defined(HITLS_CRYPTO_SM2_EXCH)
{CRYPT_EAL_IMPLPKEYEXCH_EXCH, (CRYPT_EAL_ImplPkeyExch)CRYPT_SM2_KapComputeKey},
#endif
crypto/provider/src/default/crypt_default_keymgmt.c
+14 -14
View File
@@ -150,7 +150,7 @@ void *CRYPT_EAL_DefPkeyMgmtNewCtx(CRYPT_EAL_DefProvCtx *provCtx, int32_t algId)
return pkeyCtx;
};
const CRYPT_EAL_Func g_defKeyMgmtDsa[] = {
const CRYPT_EAL_Func g_defEalKeyMgmtDsa[] = {
#ifdef HITLS_CRYPTO_DSA
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_EAL_DefPkeyMgmtNewCtx},
{CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, (CRYPT_EAL_ImplPkeyMgmtSetParam)CRYPT_DSA_SetPara},
@@ -168,7 +168,7 @@ const CRYPT_EAL_Func g_defKeyMgmtDsa[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defKeyMgmtEd25519[] = {
const CRYPT_EAL_Func g_defEalKeyMgmtEd25519[] = {
#ifdef HITLS_CRYPTO_ED25519
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_EAL_DefPkeyMgmtNewCtx},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_ED25519_GenKey},
@@ -186,7 +186,7 @@ const CRYPT_EAL_Func g_defKeyMgmtEd25519[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defKeyMgmtX25519[] = {
const CRYPT_EAL_Func g_defEalKeyMgmtX25519[] = {
#ifdef HITLS_CRYPTO_X25519
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_EAL_DefPkeyMgmtNewCtx},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_X25519_GenKey},
@@ -202,7 +202,7 @@ const CRYPT_EAL_Func g_defKeyMgmtX25519[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defKeyMgmtRsa[] = {
const CRYPT_EAL_Func g_defEalKeyMgmtRsa[] = {
#ifdef HITLS_CRYPTO_RSA
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_EAL_DefPkeyMgmtNewCtx},
{CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, (CRYPT_EAL_ImplPkeyMgmtSetParam)CRYPT_RSA_SetPara},
@@ -221,7 +221,7 @@ const CRYPT_EAL_Func g_defKeyMgmtRsa[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defKeyMgmtDh[] = {
const CRYPT_EAL_Func g_defEalKeyMgmtDh[] = {
#ifdef HITLS_CRYPTO_DH
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_EAL_DefPkeyMgmtNewCtx},
{CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, (CRYPT_EAL_ImplPkeyMgmtSetParam)CRYPT_DH_SetPara},
@@ -239,7 +239,7 @@ const CRYPT_EAL_Func g_defKeyMgmtDh[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defKeyMgmtEcdsa[] = {
const CRYPT_EAL_Func g_defEalKeyMgmtEcdsa[] = {
#ifdef HITLS_CRYPTO_ECDSA
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_EAL_DefPkeyMgmtNewCtx},
{CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, (CRYPT_EAL_ImplPkeyMgmtSetParam)CRYPT_ECDSA_SetPara},
@@ -259,7 +259,7 @@ const CRYPT_EAL_Func g_defKeyMgmtEcdsa[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defKeyMgmtEcdh[] = {
const CRYPT_EAL_Func g_defEalKeyMgmtEcdh[] = {
#ifdef HITLS_CRYPTO_ECDH
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_EAL_DefPkeyMgmtNewCtx},
{CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, (CRYPT_EAL_ImplPkeyMgmtSetParam)CRYPT_ECDH_SetPara},
@@ -277,7 +277,7 @@ const CRYPT_EAL_Func g_defKeyMgmtEcdh[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defKeyMgmtSm2[] = {
const CRYPT_EAL_Func g_defEalKeyMgmtSm2[] = {
#ifdef HITLS_CRYPTO_SM2
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_EAL_DefPkeyMgmtNewCtx},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_SM2_Gen},
@@ -295,7 +295,7 @@ const CRYPT_EAL_Func g_defKeyMgmtSm2[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defKeyMgmtPaillier[] = {
const CRYPT_EAL_Func g_defEalKeyMgmtPaillier[] = {
#ifdef HITLS_CRYPTO_PAILLIER
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_EAL_DefPkeyMgmtNewCtx},
{CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, (CRYPT_EAL_ImplPkeyMgmtSetParam)CRYPT_PAILLIER_SetPara},
@@ -311,7 +311,7 @@ const CRYPT_EAL_Func g_defKeyMgmtPaillier[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defKeyMgmtElGamal[] = {
const CRYPT_EAL_Func g_defEalKeyMgmtElGamal[] = {
#ifdef HITLS_CRYPTO_ELGAMAL
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_EAL_DefPkeyMgmtNewCtx},
{CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, (CRYPT_EAL_ImplPkeyMgmtSetParam)CRYPT_ELGAMAL_SetPara},
@@ -327,7 +327,7 @@ const CRYPT_EAL_Func g_defKeyMgmtElGamal[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defKeyMgmtMlKem[] = {
const CRYPT_EAL_Func g_defEalKeyMgmtMlKem[] = {
#ifdef HITLS_CRYPTO_MLKEM
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_EAL_DefPkeyMgmtNewCtx},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_ML_KEM_GenKey},
@@ -343,7 +343,7 @@ const CRYPT_EAL_Func g_defKeyMgmtMlKem[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defKeyMgmtMlDsa[] = {
const CRYPT_EAL_Func g_defEalKeyMgmtMlDsa[] = {
#ifdef HITLS_CRYPTO_MLDSA
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_EAL_DefPkeyMgmtNewCtx},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_ML_DSA_GenKey},
@@ -359,7 +359,7 @@ const CRYPT_EAL_Func g_defKeyMgmtMlDsa[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defKeyMgmtSlhDsa[] = {
const CRYPT_EAL_Func g_defEalKeyMgmtSlhDsa[] = {
#ifdef HITLS_CRYPTO_SLH_DSA
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_EAL_DefPkeyMgmtNewCtx},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_SLH_DSA_Gen},
@@ -373,7 +373,7 @@ const CRYPT_EAL_Func g_defKeyMgmtSlhDsa[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defKeyMgmtHybridKem[] = {
const CRYPT_EAL_Func g_defEalKeyMgmtHybridKem[] = {
#ifdef HITLS_CRYPTO_HYBRIDKEM
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_EAL_DefPkeyMgmtNewCtx},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_HYBRID_KEM_GenKey},
crypto/provider/src/default/crypt_default_mac.c
+5 -5
View File
@@ -118,7 +118,7 @@ MAC_FUNCS(SIPHASH)
#ifdef HITLS_CRYPTO_GMAC
MAC_DEINIT_FUNC(GMAC)
#endif
const CRYPT_EAL_Func g_defMacHmac[] = {
const CRYPT_EAL_Func g_defEalMacHmac[] = {
#ifdef HITLS_CRYPTO_HMAC
{CRYPT_EAL_IMPLMAC_NEWCTX, (CRYPT_EAL_ImplMacNewCtx)CRYPT_EAL_DefMacNewCtx},
{CRYPT_EAL_IMPLMAC_INIT, (CRYPT_EAL_ImplMacInit)CRYPT_HMAC_Init},
@@ -132,7 +132,7 @@ const CRYPT_EAL_Func g_defMacHmac[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defMacCmac[] = {
const CRYPT_EAL_Func g_defEalMacCmac[] = {
#ifdef HITLS_CRYPTO_CMAC
{CRYPT_EAL_IMPLMAC_NEWCTX, (CRYPT_EAL_ImplMacNewCtx)CRYPT_EAL_DefMacNewCtx},
{CRYPT_EAL_IMPLMAC_INIT, (CRYPT_EAL_ImplMacInit)CRYPT_CMAC_Init},
@@ -146,7 +146,7 @@ const CRYPT_EAL_Func g_defMacCmac[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defMacCbcMac[] = {
const CRYPT_EAL_Func g_defEalMacCbcMac[] = {
#ifdef HITLS_CRYPTO_CBC_MAC
{CRYPT_EAL_IMPLMAC_NEWCTX, (CRYPT_EAL_ImplMacNewCtx)CRYPT_EAL_DefMacNewCtx},
{CRYPT_EAL_IMPLMAC_INIT, (CRYPT_EAL_ImplMacInit)CRYPT_CBC_MAC_Init},
@@ -160,7 +160,7 @@ const CRYPT_EAL_Func g_defMacCbcMac[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defMacGmac[] = {
const CRYPT_EAL_Func g_defEalMacGmac[] = {
#ifdef HITLS_CRYPTO_GMAC
{CRYPT_EAL_IMPLMAC_NEWCTX, (CRYPT_EAL_ImplMacNewCtx)CRYPT_EAL_DefMacNewCtx},
{CRYPT_EAL_IMPLMAC_INIT, (CRYPT_EAL_ImplMacInit)CRYPT_GMAC_Init},
@@ -174,7 +174,7 @@ const CRYPT_EAL_Func g_defMacGmac[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defMacSiphash[] = {
const CRYPT_EAL_Func g_defEalMacSiphash[] = {
#ifdef HITLS_CRYPTO_SIPHASH
{CRYPT_EAL_IMPLMAC_NEWCTX, (CRYPT_EAL_ImplMacNewCtx)CRYPT_EAL_DefMacNewCtx},
{CRYPT_EAL_IMPLMAC_INIT, (CRYPT_EAL_ImplMacInit)CRYPT_SIPHASH_Init},
crypto/provider/src/default/crypt_default_md.c
+13 -13
View File
@@ -113,7 +113,7 @@ int32_t CRYPT_EAL_DefMdCtrl(void *ctx, int32_t cmd, void *val, uint32_t valLen)
return CRYPT_NOT_SUPPORT;
}
const CRYPT_EAL_Func g_defMdMd5[] = {
const CRYPT_EAL_Func g_defEalMdMd5[] = {
#ifdef HITLS_CRYPTO_MD5
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_EAL_DefMdNewCtx},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_MD5_Init},
@@ -127,7 +127,7 @@ const CRYPT_EAL_Func g_defMdMd5[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defMdSha1[] = {
const CRYPT_EAL_Func g_defEalMdSha1[] = {
#ifdef HITLS_CRYPTO_SHA1
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_EAL_DefMdNewCtx},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHA1_Init},
@@ -141,7 +141,7 @@ const CRYPT_EAL_Func g_defMdSha1[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defMdSha224[] = {
const CRYPT_EAL_Func g_defEalMdSha224[] = {
#ifdef HITLS_CRYPTO_SHA224
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_EAL_DefMdNewCtx},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHA2_224_Init},
@@ -155,7 +155,7 @@ const CRYPT_EAL_Func g_defMdSha224[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defMdSha256[] = {
const CRYPT_EAL_Func g_defEalMdSha256[] = {
#ifdef HITLS_CRYPTO_SHA256
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_EAL_DefMdNewCtx},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHA2_256_Init},
@@ -169,7 +169,7 @@ const CRYPT_EAL_Func g_defMdSha256[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defMdSha384[] = {
const CRYPT_EAL_Func g_defEalMdSha384[] = {
#ifdef HITLS_CRYPTO_SHA384
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_EAL_DefMdNewCtx},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHA2_384_Init},
@@ -183,7 +183,7 @@ const CRYPT_EAL_Func g_defMdSha384[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defMdSha512[] = {
const CRYPT_EAL_Func g_defEalMdSha512[] = {
#ifdef HITLS_CRYPTO_SHA512
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_EAL_DefMdNewCtx},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHA2_512_Init},
@@ -197,7 +197,7 @@ const CRYPT_EAL_Func g_defMdSha512[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defMdSha3224[] = {
const CRYPT_EAL_Func g_defEalMdSha3224[] = {
#ifdef HITLS_CRYPTO_SHA3
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_EAL_DefMdNewCtx},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHA3_224_Init},
@@ -211,7 +211,7 @@ const CRYPT_EAL_Func g_defMdSha3224[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defMdSha3256[] = {
const CRYPT_EAL_Func g_defEalMdSha3256[] = {
#ifdef HITLS_CRYPTO_SHA3
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_EAL_DefMdNewCtx},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHA3_256_Init},
@@ -225,7 +225,7 @@ const CRYPT_EAL_Func g_defMdSha3256[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defMdSha3384[] = {
const CRYPT_EAL_Func g_defEalMdSha3384[] = {
#ifdef HITLS_CRYPTO_SHA3
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_EAL_DefMdNewCtx},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHA3_384_Init},
@@ -239,7 +239,7 @@ const CRYPT_EAL_Func g_defMdSha3384[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defMdSha3512[] = {
const CRYPT_EAL_Func g_defEalMdSha3512[] = {
#ifdef HITLS_CRYPTO_SHA3
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_EAL_DefMdNewCtx},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHA3_512_Init},
@@ -253,7 +253,7 @@ const CRYPT_EAL_Func g_defMdSha3512[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defMdShake128[] = {
const CRYPT_EAL_Func g_defEalMdShake128[] = {
#ifdef HITLS_CRYPTO_SHA3
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_EAL_DefMdNewCtx},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHAKE128_Init},
@@ -268,7 +268,7 @@ const CRYPT_EAL_Func g_defMdShake128[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defMdShake256[] = {
const CRYPT_EAL_Func g_defEalMdShake256[] = {
#ifdef HITLS_CRYPTO_SHA3
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_EAL_DefMdNewCtx},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHAKE256_Init},
@@ -283,7 +283,7 @@ const CRYPT_EAL_Func g_defMdShake256[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defMdSm3[] = {
const CRYPT_EAL_Func g_defEalMdSm3[] = {
#ifdef HITLS_CRYPTO_SM3
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_EAL_DefMdNewCtx},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SM3_Init},
crypto/provider/src/default/crypt_default_pkeycipher.c
+4 -4
View File
@@ -22,7 +22,7 @@
#include "crypt_paillier.h"
#include "crypt_elgamal.h"
const CRYPT_EAL_Func g_defAsymCipherRsa[] = {
const CRYPT_EAL_Func g_defEalAsymCipherRsa[] = {
#ifdef HITLS_CRYPTO_RSA_ENCRYPT
{CRYPT_EAL_IMPLPKEYCIPHER_ENCRYPT, (CRYPT_EAL_ImplPkeyEncrypt)CRYPT_RSA_Encrypt},
#endif
@@ -32,7 +32,7 @@ const CRYPT_EAL_Func g_defAsymCipherRsa[] = {
CRYPT_EAL_FUNC_END
};
const CRYPT_EAL_Func g_defAsymCipherSm2[] = {
const CRYPT_EAL_Func g_defEalAsymCipherSm2[] = {
#ifdef HITLS_CRYPTO_SM2_CRYPT
{CRYPT_EAL_IMPLPKEYCIPHER_ENCRYPT, (CRYPT_EAL_ImplPkeyEncrypt)CRYPT_SM2_Encrypt},
{CRYPT_EAL_IMPLPKEYCIPHER_DECRYPT, (CRYPT_EAL_ImplPkeyDecrypt)CRYPT_SM2_Decrypt},
@@ -40,7 +40,7 @@ const CRYPT_EAL_Func g_defAsymCipherSm2[] = {
CRYPT_EAL_FUNC_END
};
const CRYPT_EAL_Func g_defAsymCipherPaillier[] = {
const CRYPT_EAL_Func g_defEalAsymCipherPaillier[] = {
#ifdef HITLS_CRYPTO_PAILLIER
{CRYPT_EAL_IMPLPKEYCIPHER_ENCRYPT, (CRYPT_EAL_ImplPkeyEncrypt)CRYPT_PAILLIER_Encrypt},
{CRYPT_EAL_IMPLPKEYCIPHER_DECRYPT, (CRYPT_EAL_ImplPkeyDecrypt)CRYPT_PAILLIER_Decrypt},
@@ -48,7 +48,7 @@ const CRYPT_EAL_Func g_defAsymCipherPaillier[] = {
CRYPT_EAL_FUNC_END
};
const CRYPT_EAL_Func g_defAsymCipherElGamal[] = {
const CRYPT_EAL_Func g_defEalAsymCipherElGamal[] = {
#ifdef HITLS_CRYPTO_ELGAMAL
{CRYPT_EAL_IMPLPKEYCIPHER_ENCRYPT, CRYPT_ELGAMAL_Encrypt},
{CRYPT_EAL_IMPLPKEYCIPHER_DECRYPT, CRYPT_ELGAMAL_Decrypt},
crypto/provider/src/default/crypt_default_provider.c
+231 -270
View File
@@ -23,6 +23,7 @@
#include "bsl_errno.h"
#include "bsl_params.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_algid.h"
#include "crypt_errno.h"
#include "crypt_eal_implprovider.h"
@@ -37,185 +38,204 @@
#define CRYPT_EAL_DEFAULT_ATTR "provider=default"
static const CRYPT_EAL_AlgInfo g_defMds[] = {
{CRYPT_MD_MD5, g_defMdMd5, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHA1, g_defMdSha1, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHA224, g_defMdSha224, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHA256, g_defMdSha256, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHA384, g_defMdSha384, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHA512, g_defMdSha512, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHA3_224, g_defMdSha3224, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHA3_256, g_defMdSha3256, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHA3_384, g_defMdSha3384, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHA3_512, g_defMdSha3512, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHAKE128, g_defMdShake128, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHAKE256, g_defMdShake256, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SM3, g_defMdSm3, CRYPT_EAL_DEFAULT_ATTR},
static const CRYPT_EAL_AlgInfo g_defEalMds[] = {
{CRYPT_MD_MD5, g_defEalMdMd5, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHA1, g_defEalMdSha1, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHA224, g_defEalMdSha224, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHA256, g_defEalMdSha256, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHA384, g_defEalMdSha384, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHA512, g_defEalMdSha512, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHA3_224, g_defEalMdSha3224, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHA3_256, g_defEalMdSha3256, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHA3_384, g_defEalMdSha3384, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHA3_512, g_defEalMdSha3512, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHAKE128, g_defEalMdShake128, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SHAKE256, g_defEalMdShake256, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MD_SM3, g_defEalMdSm3, CRYPT_EAL_DEFAULT_ATTR},
CRYPT_EAL_ALGINFO_END
};
static const CRYPT_EAL_AlgInfo g_defKdfs[] = {
{CRYPT_KDF_SCRYPT, g_defKdfScrypt, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_KDF_PBKDF2, g_defKdfPBKdf2, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_KDF_KDFTLS12, g_defKdfKdfTLS12, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_KDF_HKDF, g_defKdfHkdf, CRYPT_EAL_DEFAULT_ATTR},
static const CRYPT_EAL_AlgInfo g_defEalKdfs[] = {
{CRYPT_KDF_SCRYPT, g_defEalKdfScrypt, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_KDF_PBKDF2, g_defEalKdfPBKdf2, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_KDF_KDFTLS12, g_defEalKdfKdfTLS12, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_KDF_HKDF, g_defEalKdfHkdf, CRYPT_EAL_DEFAULT_ATTR},
CRYPT_EAL_ALGINFO_END
};
static const CRYPT_EAL_AlgInfo g_defKeyMgmt[] = {
{CRYPT_PKEY_DSA, g_defKeyMgmtDsa, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ED25519, g_defKeyMgmtEd25519, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_X25519, g_defKeyMgmtX25519, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_RSA, g_defKeyMgmtRsa, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_DH, g_defKeyMgmtDh, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ECDSA, g_defKeyMgmtEcdsa, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ECDH, g_defKeyMgmtEcdh, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_SM2, g_defKeyMgmtSm2, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_PAILLIER, g_defKeyMgmtPaillier, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ELGAMAL, g_defKeyMgmtElGamal, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_SLH_DSA, g_defKeyMgmtSlhDsa, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ML_KEM, g_defKeyMgmtMlKem, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ML_DSA, g_defKeyMgmtMlDsa, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_HYBRID_KEM, g_defKeyMgmtHybridKem, CRYPT_EAL_DEFAULT_ATTR},
static const CRYPT_EAL_AlgInfo g_defEalKeyMgmt[] = {
{CRYPT_PKEY_DSA, g_defEalKeyMgmtDsa, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ED25519, g_defEalKeyMgmtEd25519, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_X25519, g_defEalKeyMgmtX25519, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_RSA, g_defEalKeyMgmtRsa, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_DH, g_defEalKeyMgmtDh, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ECDSA, g_defEalKeyMgmtEcdsa, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ECDH, g_defEalKeyMgmtEcdh, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_SM2, g_defEalKeyMgmtSm2, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_PAILLIER, g_defEalKeyMgmtPaillier, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ELGAMAL, g_defEalKeyMgmtElGamal, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_SLH_DSA, g_defEalKeyMgmtSlhDsa, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ML_KEM, g_defEalKeyMgmtMlKem, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ML_DSA, g_defEalKeyMgmtMlDsa, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_HYBRID_KEM, g_defEalKeyMgmtHybridKem, CRYPT_EAL_DEFAULT_ATTR},
CRYPT_EAL_ALGINFO_END
};
static const CRYPT_EAL_AlgInfo g_defAsymCiphers[] = {
{CRYPT_PKEY_RSA, g_defAsymCipherRsa, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_SM2, g_defAsymCipherSm2, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_PAILLIER, g_defAsymCipherPaillier, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ELGAMAL, g_defAsymCipherElGamal, CRYPT_EAL_DEFAULT_ATTR},
static const CRYPT_EAL_AlgInfo g_defEalAsymCiphers[] = {
{CRYPT_PKEY_RSA, g_defEalAsymCipherRsa, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_SM2, g_defEalAsymCipherSm2, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_PAILLIER, g_defEalAsymCipherPaillier, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ELGAMAL, g_defEalAsymCipherElGamal, CRYPT_EAL_DEFAULT_ATTR},
CRYPT_EAL_ALGINFO_END
};
static const CRYPT_EAL_AlgInfo g_defKeyExch[] = {
{CRYPT_PKEY_X25519, g_defExchX25519, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_DH, g_defExchDh, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ECDH, g_defExchEcdh, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_SM2, g_defExchSm2, CRYPT_EAL_DEFAULT_ATTR},
static const CRYPT_EAL_AlgInfo g_defEalKeyExch[] = {
{CRYPT_PKEY_X25519, g_defEalExchX25519, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_DH, g_defEalExchDh, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ECDH, g_defEalExchEcdh, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_SM2, g_defEalExchSm2, CRYPT_EAL_DEFAULT_ATTR},
CRYPT_EAL_ALGINFO_END
};
static const CRYPT_EAL_AlgInfo g_defSigns[] = {
{CRYPT_PKEY_DSA, g_defSignDsa, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ED25519, g_defSignEd25519, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_RSA, g_defSignRsa, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ECDSA, g_defSignEcdsa, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_SM2, g_defSignSm2, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_SLH_DSA, g_defSignSlhDsa, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ML_DSA, g_defSignMlDsa, CRYPT_EAL_DEFAULT_ATTR},
static const CRYPT_EAL_AlgInfo g_defEalSigns[] = {
{CRYPT_PKEY_DSA, g_defEalSignDsa, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ED25519, g_defEalSignEd25519, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_RSA, g_defEalSignRsa, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ECDSA, g_defEalSignEcdsa, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_SM2, g_defEalSignSm2, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_SLH_DSA, g_defEalSignSlhDsa, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_ML_DSA, g_defEalSignMlDsa, CRYPT_EAL_DEFAULT_ATTR},
CRYPT_EAL_ALGINFO_END
};
static const CRYPT_EAL_AlgInfo g_defMacs[] = {
{CRYPT_MAC_HMAC_MD5, g_defMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_HMAC_SHA1, g_defMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_HMAC_SHA224, g_defMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_HMAC_SHA256, g_defMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_HMAC_SHA384, g_defMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_HMAC_SHA512, g_defMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_HMAC_SHA3_224, g_defMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_HMAC_SHA3_256, g_defMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_HMAC_SHA3_384, g_defMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_HMAC_SHA3_512, g_defMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_HMAC_SM3, g_defMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_CMAC_AES128, g_defMacCmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_CMAC_AES192, g_defMacCmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_CMAC_AES256, g_defMacCmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_CMAC_SM4, g_defMacCmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_CBC_MAC_SM4, g_defMacCbcMac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_SIPHASH64, g_defMacSiphash, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_SIPHASH128, g_defMacSiphash, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_GMAC_AES128, g_defMacGmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_GMAC_AES192, g_defMacGmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_GMAC_AES256, g_defMacGmac, CRYPT_EAL_DEFAULT_ATTR},
static const CRYPT_EAL_AlgInfo g_defEalMacs[] = {
{CRYPT_MAC_HMAC_MD5, g_defEalMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_HMAC_SHA1, g_defEalMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_HMAC_SHA224, g_defEalMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_HMAC_SHA256, g_defEalMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_HMAC_SHA384, g_defEalMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_HMAC_SHA512, g_defEalMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_HMAC_SHA3_224, g_defEalMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_HMAC_SHA3_256, g_defEalMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_HMAC_SHA3_384, g_defEalMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_HMAC_SHA3_512, g_defEalMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_HMAC_SM3, g_defEalMacHmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_CMAC_AES128, g_defEalMacCmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_CMAC_AES192, g_defEalMacCmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_CMAC_AES256, g_defEalMacCmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_CMAC_SM4, g_defEalMacCmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_CBC_MAC_SM4, g_defEalMacCbcMac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_SIPHASH64, g_defEalMacSiphash, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_SIPHASH128, g_defEalMacSiphash, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_GMAC_AES128, g_defEalMacGmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_GMAC_AES192, g_defEalMacGmac, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_MAC_GMAC_AES256, g_defEalMacGmac, CRYPT_EAL_DEFAULT_ATTR},
CRYPT_EAL_ALGINFO_END
};
static const CRYPT_EAL_AlgInfo g_defRands[] = {
{CRYPT_RAND_SHA1, g_defRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_SHA224, g_defRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_SHA256, g_defRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_SHA384, g_defRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_SHA512, g_defRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_SM3, g_defRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_HMAC_SHA1, g_defRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_HMAC_SHA224, g_defRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_HMAC_SHA256, g_defRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_HMAC_SHA384, g_defRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_HMAC_SHA512, g_defRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_AES128_CTR, g_defRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_AES192_CTR, g_defRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_AES256_CTR, g_defRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_AES128_CTR_DF, g_defRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_AES192_CTR_DF, g_defRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_AES256_CTR_DF, g_defRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_SM4_CTR_DF, g_defRand, CRYPT_EAL_DEFAULT_ATTR},
static const CRYPT_EAL_AlgInfo g_defEalRands[] = {
{CRYPT_RAND_SHA1, g_defEalRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_SHA224, g_defEalRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_SHA256, g_defEalRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_SHA384, g_defEalRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_SHA512, g_defEalRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_SM3, g_defEalRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_HMAC_SHA1, g_defEalRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_HMAC_SHA224, g_defEalRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_HMAC_SHA256, g_defEalRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_HMAC_SHA384, g_defEalRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_HMAC_SHA512, g_defEalRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_AES128_CTR, g_defEalRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_AES192_CTR, g_defEalRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_AES256_CTR, g_defEalRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_AES128_CTR_DF, g_defEalRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_AES192_CTR_DF, g_defEalRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_AES256_CTR_DF, g_defEalRand, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_RAND_SM4_CTR_DF, g_defEalRand, CRYPT_EAL_DEFAULT_ATTR},
CRYPT_EAL_ALGINFO_END
};
static const CRYPT_EAL_AlgInfo g_defCiphers[] = {
{CRYPT_CIPHER_AES128_CBC, g_defCbc, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES192_CBC, g_defCbc, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES256_CBC, g_defCbc, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES128_CTR, g_defCtr, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES192_CTR, g_defCtr, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES256_CTR, g_defCtr, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES128_ECB, g_defEcb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES192_ECB, g_defEcb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES256_ECB, g_defEcb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES128_CCM, g_defCcm, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES192_CCM, g_defCcm, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES256_CCM, g_defCcm, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES128_GCM, g_defGcm, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES192_GCM, g_defGcm, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES256_GCM, g_defGcm, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES128_XTS, g_defXts, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES256_XTS, g_defXts, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_CHACHA20_POLY1305, g_defChaCha, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_SM4_XTS, g_defXts, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_SM4_CBC, g_defCbc, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_SM4_ECB, g_defEcb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_SM4_CTR, g_defCtr, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_SM4_GCM, g_defGcm, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_SM4_CFB, g_defCfb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_SM4_OFB, g_defOfb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES128_CFB, g_defCfb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES192_CFB, g_defCfb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES256_CFB, g_defCfb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES128_OFB, g_defOfb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES192_OFB, g_defOfb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES256_OFB, g_defOfb, CRYPT_EAL_DEFAULT_ATTR},
static const CRYPT_EAL_AlgInfo g_defEalCiphers[] = {
{CRYPT_CIPHER_AES128_CBC, g_defEalCbc, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES192_CBC, g_defEalCbc, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES256_CBC, g_defEalCbc, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES128_CTR, g_defEalCtr, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES192_CTR, g_defEalCtr, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES256_CTR, g_defEalCtr, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES128_ECB, g_defEalEcb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES192_ECB, g_defEalEcb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES256_ECB, g_defEalEcb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES128_CCM, g_defEalCcm, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES192_CCM, g_defEalCcm, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES256_CCM, g_defEalCcm, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES128_GCM, g_defEalGcm, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES192_GCM, g_defEalGcm, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES256_GCM, g_defEalGcm, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES128_XTS, g_defEalXts, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES256_XTS, g_defEalXts, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_CHACHA20_POLY1305, g_defEalChaCha, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_SM4_XTS, g_defEalXts, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_SM4_CBC, g_defEalCbc, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_SM4_ECB, g_defEalEcb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_SM4_CTR, g_defEalCtr, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_SM4_GCM, g_defEalGcm, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_SM4_CFB, g_defEalCfb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_SM4_OFB, g_defEalOfb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES128_CFB, g_defEalCfb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES192_CFB, g_defEalCfb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES256_CFB, g_defEalCfb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES128_OFB, g_defEalOfb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES192_OFB, g_defEalOfb, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_CIPHER_AES256_OFB, g_defEalOfb, CRYPT_EAL_DEFAULT_ATTR},
CRYPT_EAL_ALGINFO_END
};
static const CRYPT_EAL_AlgInfo g_defKems[] = {
{CRYPT_PKEY_ML_KEM, g_defMlKem, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_HYBRID_KEM, g_defHybridKeyKem, CRYPT_EAL_DEFAULT_ATTR},
static const CRYPT_EAL_AlgInfo g_defEalKems[] = {
{CRYPT_PKEY_ML_KEM, g_defEalMlKem, CRYPT_EAL_DEFAULT_ATTR},
{CRYPT_PKEY_HYBRID_KEM, g_defEalHybridKeyKem, CRYPT_EAL_DEFAULT_ATTR},
CRYPT_EAL_ALGINFO_END
};
static const CRYPT_EAL_AlgInfo g_defDecoders[] = {
{BSL_CID_DECODE_UNKNOWN, g_defPem2Der, "provider=default, inFormat=PEM, outFormat=ASN1"},
{BSL_CID_DECODE_UNKNOWN, g_defPrvP8Enc2P8, "provider=default, inFormat=ASN1, inType=PRIKEY_PKCS8_ENCRYPT, outFormat=ASN1, outType=PRIKEY_PKCS8_UNENCRYPT"},
{CRYPT_PKEY_RSA, g_defRsaPrvDer2Key, "provider=default, inFormat=ASN1, inType=PRIKEY_RSA, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_RSA, g_defRsaPubDer2Key, "provider=default, inFormat=ASN1, inType=PUBKEY_RSA, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_ECDSA, g_defEcdsaPrvDer2Key, "provider=default, inFormat=ASN1, inType=PRIKEY_ECC, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_SM2, g_defSm2PrvDer2Key, "provider=default, inFormat=ASN1, inType=PRIKEY_ECC, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_RSA, g_defP8Der2RsaKey, "provider=default, inFormat=ASN1, inType=PRIKEY_PKCS8_UNENCRYPT, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_ECDSA, g_defP8Der2EcdsaKey, "provider=default, inFormat=ASN1, inType=PRIKEY_PKCS8_UNENCRYPT, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_SM2, g_defP8Der2Sm2Key, "provider=default, inFormat=ASN1, inType=PRIKEY_PKCS8_UNENCRYPT, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_ED25519, g_defP8Der2Ed25519Key, "provider=default, inFormat=ASN1, inType=PRIKEY_PKCS8_UNENCRYPT, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_RSA, g_defSubPubKeyDer2RsaKey, "provider=default, inFormat=ASN1, inType=PUBKEY_SUBKEY, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_ECDSA, g_defSubPubKeyDer2EcdsaKey, "provider=default, inFormat=ASN1, inType=PUBKEY_SUBKEY, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_SM2, g_defSubPubKeyDer2Sm2Key, "provider=default, inFormat=ASN1, inType=PUBKEY_SUBKEY, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_ED25519, g_defSubPubKeyDer2Ed25519Key, "provider=default, inFormat=ASN1, inType=PUBKEY_SUBKEY, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_RSA, g_defSubPubKeyWithoutSeqDer2RsaKey, "provider=default, inFormat=ASN1, inType=PUBKEY_SUBKEY_WITHOUT_SEQ, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_ECDSA, g_defSubPubKeyWithoutSeqDer2EcdsaKey, "provider=default, inFormat=ASN1, inType=PUBKEY_SUBKEY_WITHOUT_SEQ, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_SM2, g_defSubPubKeyWithoutSeqDer2Sm2Key, "provider=default, inFormat=ASN1, inType=PUBKEY_SUBKEY_WITHOUT_SEQ, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_ED25519, g_defSubPubKeyWithoutSeqDer2Ed25519Key, "provider=default, inFormat=ASN1, inType=PUBKEY_SUBKEY_WITHOUT_SEQ, outFormat=OBJECT, outType=LOW_KEY"},
{BSL_CID_DECODE_UNKNOWN, g_defLowKeyObject2PkeyObject, "provider=default, inFormat=OBJECT, inType=LOW_KEY, outFormat=OBJECT, outType=HIGH_KEY"},
static const CRYPT_EAL_AlgInfo g_defEalDecoders[] = {
{BSL_CID_DECODE_UNKNOWN, g_defEalPem2Der,
"provider=default, inFormat=PEM, outFormat=ASN1"},
{BSL_CID_DECODE_UNKNOWN, g_defEalPrvP8Enc2P8,
"provider=default, inFormat=ASN1, inType=PRIKEY_PKCS8_ENCRYPT, outFormat=ASN1, outType=PRIKEY_PKCS8_UNENCRYPT"},
{CRYPT_PKEY_RSA, g_defEalRsaPrvDer2Key,
"provider=default, inFormat=ASN1, inType=PRIKEY_RSA, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_RSA, g_defEalRsaPubDer2Key,
"provider=default, inFormat=ASN1, inType=PUBKEY_RSA, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_ECDSA, g_defEalEcdsaPrvDer2Key,
"provider=default, inFormat=ASN1, inType=PRIKEY_ECC, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_SM2, g_defEalSm2PrvDer2Key,
"provider=default, inFormat=ASN1, inType=PRIKEY_ECC, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_RSA, g_defEalP8Der2RsaKey,
"provider=default, inFormat=ASN1, inType=PRIKEY_PKCS8_UNENCRYPT, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_ECDSA, g_defEalP8Der2EcdsaKey,
"provider=default, inFormat=ASN1, inType=PRIKEY_PKCS8_UNENCRYPT, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_SM2, g_defEalP8Der2Sm2Key,
"provider=default, inFormat=ASN1, inType=PRIKEY_PKCS8_UNENCRYPT, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_ED25519, g_defEalP8Der2Ed25519Key,
"provider=default, inFormat=ASN1, inType=PRIKEY_PKCS8_UNENCRYPT, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_RSA, g_defEalSubPubKeyDer2RsaKey,
"provider=default, inFormat=ASN1, inType=PUBKEY_SUBKEY, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_ECDSA, g_defEalSubPubKeyDer2EcdsaKey,
"provider=default, inFormat=ASN1, inType=PUBKEY_SUBKEY, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_SM2, g_defEalSubPubKeyDer2Sm2Key,
"provider=default, inFormat=ASN1, inType=PUBKEY_SUBKEY, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_ED25519, g_defEalSubPubKeyDer2Ed25519Key,
"provider=default, inFormat=ASN1, inType=PUBKEY_SUBKEY, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_RSA, g_defEalSubPubKeyWithoutSeqDer2RsaKey,
"provider=default, inFormat=ASN1, inType=PUBKEY_SUBKEY_WITHOUT_SEQ, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_ECDSA, g_defEalSubPubKeyWithoutSeqDer2EcdsaKey,
"provider=default, inFormat=ASN1, inType=PUBKEY_SUBKEY_WITHOUT_SEQ, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_SM2, g_defEalSubPubKeyWithoutSeqDer2Sm2Key,
"provider=default, inFormat=ASN1, inType=PUBKEY_SUBKEY_WITHOUT_SEQ, outFormat=OBJECT, outType=LOW_KEY"},
{CRYPT_PKEY_ED25519, g_defEalSubPubKeyWithoutSeqDer2Ed25519Key,
"provider=default, inFormat=ASN1, inType=PUBKEY_SUBKEY_WITHOUT_SEQ, outFormat=OBJECT, outType=LOW_KEY"},
{BSL_CID_DECODE_UNKNOWN, g_defEalLowKeyObject2PkeyObject,
"provider=default, inFormat=OBJECT, inType=LOW_KEY, outFormat=OBJECT, outType=HIGH_KEY"},
CRYPT_EAL_ALGINFO_END
};
@@ -225,37 +245,37 @@ static int32_t CRYPT_EAL_DefaultProvQuery(void *provCtx, int32_t operaId, const
int32_t ret = CRYPT_SUCCESS;
switch (operaId) {
case CRYPT_EAL_OPERAID_SYMMCIPHER:
*algInfos = g_defCiphers;
*algInfos = g_defEalCiphers;
break;
case CRYPT_EAL_OPERAID_KEYMGMT:
*algInfos = g_defKeyMgmt;
*algInfos = g_defEalKeyMgmt;
break;
case CRYPT_EAL_OPERAID_SIGN:
*algInfos = g_defSigns;
*algInfos = g_defEalSigns;
break;
case CRYPT_EAL_OPERAID_ASYMCIPHER:
*algInfos = g_defAsymCiphers;
*algInfos = g_defEalAsymCiphers;
break;
case CRYPT_EAL_OPERAID_KEYEXCH:
*algInfos = g_defKeyExch;
*algInfos = g_defEalKeyExch;
break;
case CRYPT_EAL_OPERAID_KEM:
*algInfos = g_defKems;
*algInfos = g_defEalKems;
break;
case CRYPT_EAL_OPERAID_HASH:
*algInfos = g_defMds;
*algInfos = g_defEalMds;
break;
case CRYPT_EAL_OPERAID_MAC:
*algInfos = g_defMacs;
*algInfos = g_defEalMacs;
break;
case CRYPT_EAL_OPERAID_KDF:
*algInfos = g_defKdfs;
*algInfos = g_defEalKdfs;
break;
case CRYPT_EAL_OPERAID_RAND:
*algInfos = g_defRands;
*algInfos = g_defEalRands;
break;
case CRYPT_EAL_OPERAID_DECODER:
*algInfos = g_defDecoders;
*algInfos = g_defEalDecoders;
break;
default:
ret = CRYPT_NOT_SUPPORT;
@@ -364,7 +384,7 @@ static const TLS_GroupInfo g_tlsGroupInfo[] = {
128, // secBits
HITLS_EC_GROUP_BRAINPOOLP256R1, // groupId
65, 32, 0, // pubkeyLen=65, sharedkeyLen=32 (256 bits)
TLS10_VERSION_BIT | TLS11_VERSION_BIT| TLS12_VERSION_BIT | DTLS_VERSION_MASK, // versionBits
TLS10_VERSION_BIT | TLS11_VERSION_BIT | TLS12_VERSION_BIT | DTLS_VERSION_MASK, // versionBits
false,
},
{
@@ -374,7 +394,7 @@ static const TLS_GroupInfo g_tlsGroupInfo[] = {
192, // secBits
HITLS_EC_GROUP_BRAINPOOLP384R1, // groupId
97, 48, 0, // pubkeyLen=97, sharedkeyLen=48 (384 bits)
TLS10_VERSION_BIT| TLS11_VERSION_BIT|TLS12_VERSION_BIT | DTLS_VERSION_MASK, // versionBits
TLS10_VERSION_BIT | TLS11_VERSION_BIT | TLS12_VERSION_BIT | DTLS_VERSION_MASK, // versionBits
false,
},
{
@@ -384,7 +404,7 @@ static const TLS_GroupInfo g_tlsGroupInfo[] = {
256, // secBits
HITLS_EC_GROUP_BRAINPOOLP512R1, // groupId
129, 64, 0, // pubkeyLen=129, sharedkeyLen=64 (512 bits)
TLS10_VERSION_BIT| TLS11_VERSION_BIT|TLS12_VERSION_BIT | DTLS_VERSION_MASK, // versionBits
TLS10_VERSION_BIT | TLS11_VERSION_BIT | TLS12_VERSION_BIT | DTLS_VERSION_MASK, // versionBits
false,
},
{
@@ -451,58 +471,29 @@ static const TLS_GroupInfo g_tlsGroupInfo[] = {
static int32_t BuildTlsGroupParam(const TLS_GroupInfo *groupInfo, BSL_Param *param)
{
int32_t ret = BSL_PARAM_InitValue(&param[0], CRYPT_PARAM_CAP_TLS_GROUP_IANA_GROUP_NAME, BSL_PARAM_TYPE_OCTETS_PTR,
(void *)(uintptr_t)groupInfo->name, (uint32_t)strlen(groupInfo->name));
if (ret != BSL_SUCCESS) {
return ret;
}
ret = BSL_PARAM_InitValue(&param[1], CRYPT_PARAM_CAP_TLS_GROUP_IANA_GROUP_ID, BSL_PARAM_TYPE_UINT16,
(void *)(uintptr_t)&(groupInfo->groupId), sizeof(groupInfo->groupId));
if (ret != BSL_SUCCESS) {
return ret;
}
ret = BSL_PARAM_InitValue(&param[2], CRYPT_PARAM_CAP_TLS_GROUP_PARA_ID, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(groupInfo->paraId), sizeof(groupInfo->paraId));
if (ret != BSL_SUCCESS) {
return ret;
}
ret = BSL_PARAM_InitValue(&param[3], CRYPT_PARAM_CAP_TLS_GROUP_ALG_ID, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(groupInfo->algId), sizeof(groupInfo->algId));
if (ret != BSL_SUCCESS) {
return ret;
}
ret = BSL_PARAM_InitValue(&param[4], CRYPT_PARAM_CAP_TLS_GROUP_SEC_BITS, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(groupInfo->secBits), sizeof(groupInfo->secBits));
if (ret != BSL_SUCCESS) {
return ret;
}
ret = BSL_PARAM_InitValue(&param[5], CRYPT_PARAM_CAP_TLS_GROUP_VERSION_BITS, BSL_PARAM_TYPE_UINT32,
(void *)(uintptr_t)&(groupInfo->versionBits), sizeof(groupInfo->versionBits));
if (ret != BSL_SUCCESS) {
return ret;
}
ret = BSL_PARAM_InitValue(&param[6], CRYPT_PARAM_CAP_TLS_GROUP_IS_KEM, BSL_PARAM_TYPE_BOOL,
(void *)(uintptr_t)&(groupInfo->isKem), sizeof(groupInfo->isKem));
if (ret != BSL_SUCCESS) {
return ret;
}
ret = BSL_PARAM_InitValue(&param[7], CRYPT_PARAM_CAP_TLS_GROUP_PUBKEY_LEN, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(groupInfo->pubkeyLen), sizeof(groupInfo->pubkeyLen));
if (ret != BSL_SUCCESS) {
return ret;
}
ret = BSL_PARAM_InitValue(&param[8], CRYPT_PARAM_CAP_TLS_GROUP_SHAREDKEY_LEN, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(groupInfo->sharedkeyLen), sizeof(groupInfo->sharedkeyLen));
if (ret != BSL_SUCCESS) {
return ret;
}
ret = BSL_PARAM_InitValue(&param[9], CRYPT_PARAM_CAP_TLS_GROUP_CIPHERTEXT_LEN, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(groupInfo->ciphertextLen), sizeof(groupInfo->ciphertextLen));
if (ret != BSL_SUCCESS) {
return ret;
}
int32_t ret = 0;
RETURN_RET_IF_ERR_EX(BSL_PARAM_InitValue(&param[0], CRYPT_PARAM_CAP_TLS_GROUP_IANA_GROUP_NAME,
BSL_PARAM_TYPE_OCTETS_PTR, (void *)(uintptr_t)groupInfo->name, (uint32_t)strlen(groupInfo->name)), ret);
RETURN_RET_IF_ERR_EX(BSL_PARAM_InitValue(&param[1], CRYPT_PARAM_CAP_TLS_GROUP_IANA_GROUP_ID, BSL_PARAM_TYPE_UINT16,
(void *)(uintptr_t)&(groupInfo->groupId), sizeof(groupInfo->groupId)), ret);
RETURN_RET_IF_ERR_EX(BSL_PARAM_InitValue(&param[2], CRYPT_PARAM_CAP_TLS_GROUP_PARA_ID, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(groupInfo->paraId), sizeof(groupInfo->paraId)), ret);
RETURN_RET_IF_ERR_EX(BSL_PARAM_InitValue(&param[3], CRYPT_PARAM_CAP_TLS_GROUP_ALG_ID, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(groupInfo->algId), sizeof(groupInfo->algId)), ret);
RETURN_RET_IF_ERR_EX(BSL_PARAM_InitValue(&param[4], CRYPT_PARAM_CAP_TLS_GROUP_SEC_BITS, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(groupInfo->secBits), sizeof(groupInfo->secBits)), ret);
RETURN_RET_IF_ERR_EX(BSL_PARAM_InitValue(&param[5], CRYPT_PARAM_CAP_TLS_GROUP_VERSION_BITS, BSL_PARAM_TYPE_UINT32,
(void *)(uintptr_t)&(groupInfo->versionBits), sizeof(groupInfo->versionBits)), ret);
RETURN_RET_IF_ERR_EX(BSL_PARAM_InitValue(&param[6], CRYPT_PARAM_CAP_TLS_GROUP_IS_KEM, BSL_PARAM_TYPE_BOOL,
(void *)(uintptr_t)&(groupInfo->isKem), sizeof(groupInfo->isKem)), ret);
RETURN_RET_IF_ERR_EX(BSL_PARAM_InitValue(&param[7], CRYPT_PARAM_CAP_TLS_GROUP_PUBKEY_LEN, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(groupInfo->pubkeyLen), sizeof(groupInfo->pubkeyLen)), ret);
RETURN_RET_IF_ERR_EX(BSL_PARAM_InitValue(&param[8], CRYPT_PARAM_CAP_TLS_GROUP_SHAREDKEY_LEN, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(groupInfo->sharedkeyLen), sizeof(groupInfo->sharedkeyLen)), ret);
RETURN_RET_IF_ERR_EX(BSL_PARAM_InitValue(&param[9], CRYPT_PARAM_CAP_TLS_GROUP_CIPHERTEXT_LEN, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(groupInfo->ciphertextLen), sizeof(groupInfo->ciphertextLen)), ret);
return BSL_SUCCESS;
return ret;
}
static int32_t CryptGetGroupCaps(CRYPT_EAL_ProcessFuncCb cb, void *args)
@@ -815,55 +806,31 @@ static const TLS_SigSchemeInfo g_signSchemeInfo[] = {
static int32_t BuildTlsSigAlgParam(const TLS_SigSchemeInfo *sigSchemeInfo, BSL_Param *param)
{
int32_t ret = BSL_PARAM_InitValue(&param[0], CRYPT_PARAM_CAP_TLS_SIGNALG_IANA_SIGN_NAME,
BSL_PARAM_TYPE_OCTETS_PTR, (void *)(uintptr_t)sigSchemeInfo->name, (uint32_t)strlen(sigSchemeInfo->name));
if (ret != BSL_SUCCESS) {
return ret;
}
ret = BSL_PARAM_InitValue(&param[1], CRYPT_PARAM_CAP_TLS_SIGNALG_IANA_SIGN_ID, BSL_PARAM_TYPE_UINT16,
(void *)(uintptr_t)&(sigSchemeInfo->signatureScheme), sizeof(sigSchemeInfo->signatureScheme));
if (ret != BSL_SUCCESS) {
return ret;
}
ret = BSL_PARAM_InitValue(&param[2], CRYPT_PARAM_CAP_TLS_SIGNALG_KEY_TYPE, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(sigSchemeInfo->keyType), sizeof(sigSchemeInfo->keyType));
if (ret != BSL_SUCCESS) {
return ret;
}
ret = BSL_PARAM_InitValue(&param[3], CRYPT_PARAM_CAP_TLS_SIGNALG_PARA_ID, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(sigSchemeInfo->paraId), sizeof(sigSchemeInfo->paraId));
if (ret != BSL_SUCCESS) {
return ret;
}
ret = BSL_PARAM_InitValue(&param[4], CRYPT_PARAM_CAP_TLS_SIGNALG_SIGNWITHMD_ID, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(sigSchemeInfo->signHashAlgId), sizeof(sigSchemeInfo->signHashAlgId));
if (ret != BSL_SUCCESS) {
return ret;
}
ret = BSL_PARAM_InitValue(&param[5], CRYPT_PARAM_CAP_TLS_SIGNALG_SIGN_ID, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(sigSchemeInfo->signAlgId), sizeof(sigSchemeInfo->signAlgId));
if (ret != BSL_SUCCESS) {
return ret;
}
ret = BSL_PARAM_InitValue(&param[6], CRYPT_PARAM_CAP_TLS_SIGNALG_MD_ID, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(sigSchemeInfo->hashAlgId), sizeof(sigSchemeInfo->hashAlgId));
if (ret != BSL_SUCCESS) {
return ret;
}
ret = BSL_PARAM_InitValue(&param[7], CRYPT_PARAM_CAP_TLS_SIGNALG_SEC_BITS, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(sigSchemeInfo->secBits), sizeof(sigSchemeInfo->secBits));
if (ret != BSL_SUCCESS) {
return ret;
}
ret = BSL_PARAM_InitValue(&param[8], CRYPT_PARAM_CAP_TLS_SIGNALG_CERT_VERSION_BITS,
int32_t ret = 0;
RETURN_RET_IF_ERR_EX(BSL_PARAM_InitValue(&param[0], CRYPT_PARAM_CAP_TLS_SIGNALG_IANA_SIGN_NAME,
BSL_PARAM_TYPE_OCTETS_PTR, (void *)(uintptr_t)sigSchemeInfo->name, (uint32_t)strlen(sigSchemeInfo->name)), ret);
RETURN_RET_IF_ERR_EX(BSL_PARAM_InitValue(&param[1], CRYPT_PARAM_CAP_TLS_SIGNALG_IANA_SIGN_ID, BSL_PARAM_TYPE_UINT16,
(void *)(uintptr_t)&(sigSchemeInfo->signatureScheme), sizeof(sigSchemeInfo->signatureScheme)), ret);
RETURN_RET_IF_ERR_EX(BSL_PARAM_InitValue(&param[2], CRYPT_PARAM_CAP_TLS_SIGNALG_KEY_TYPE, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(sigSchemeInfo->keyType), sizeof(sigSchemeInfo->keyType)), ret);
RETURN_RET_IF_ERR_EX(BSL_PARAM_InitValue(&param[3], CRYPT_PARAM_CAP_TLS_SIGNALG_PARA_ID, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(sigSchemeInfo->paraId), sizeof(sigSchemeInfo->paraId)), ret);
RETURN_RET_IF_ERR_EX(BSL_PARAM_InitValue(&param[4], CRYPT_PARAM_CAP_TLS_SIGNALG_SIGNWITHMD_ID, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(sigSchemeInfo->signHashAlgId), sizeof(sigSchemeInfo->signHashAlgId)), ret);
RETURN_RET_IF_ERR_EX(BSL_PARAM_InitValue(&param[5], CRYPT_PARAM_CAP_TLS_SIGNALG_SIGN_ID, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(sigSchemeInfo->signAlgId), sizeof(sigSchemeInfo->signAlgId)), ret);
RETURN_RET_IF_ERR_EX(BSL_PARAM_InitValue(&param[6], CRYPT_PARAM_CAP_TLS_SIGNALG_MD_ID, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(sigSchemeInfo->hashAlgId), sizeof(sigSchemeInfo->hashAlgId)), ret);
RETURN_RET_IF_ERR_EX(BSL_PARAM_InitValue(&param[7], CRYPT_PARAM_CAP_TLS_SIGNALG_SEC_BITS, BSL_PARAM_TYPE_INT32,
(void *)(uintptr_t)&(sigSchemeInfo->secBits), sizeof(sigSchemeInfo->secBits)), ret);
RETURN_RET_IF_ERR_EX(BSL_PARAM_InitValue(&param[8], CRYPT_PARAM_CAP_TLS_SIGNALG_CERT_VERSION_BITS,
BSL_PARAM_TYPE_UINT32, (void *)(uintptr_t)&(sigSchemeInfo->certVersionBits),
sizeof(sigSchemeInfo->certVersionBits));
if (ret != BSL_SUCCESS) {
return ret;
}
return BSL_PARAM_InitValue(&param[9], CRYPT_PARAM_CAP_TLS_SIGNALG_CHAIN_VERSION_BITS,
sizeof(sigSchemeInfo->certVersionBits)), ret);
RETURN_RET_IF_ERR_EX(BSL_PARAM_InitValue(&param[9], CRYPT_PARAM_CAP_TLS_SIGNALG_CHAIN_VERSION_BITS,
BSL_PARAM_TYPE_UINT32, (void *)(uintptr_t)&(sigSchemeInfo->chainVersionBits),
sizeof(sigSchemeInfo->chainVersionBits));
sizeof(sigSchemeInfo->chainVersionBits)), ret);
return ret;
}
static int32_t CryptGetSignAlgCaps(CRYPT_EAL_ProcessFuncCb cb, void *args)
@@ -900,7 +867,7 @@ static int32_t CRYPT_EAL_DefaultProvGetCaps(void *provCtx, int32_t cmd, CRYPT_EA
}
}
static CRYPT_EAL_Func g_defProvOutFuncs[] = {
static CRYPT_EAL_Func g_defEalProvOutFuncs[] = {
{CRYPT_EAL_PROVCB_QUERY, CRYPT_EAL_DefaultProvQuery},
{CRYPT_EAL_PROVCB_FREE, CRYPT_EAL_DefaultProvFree},
{CRYPT_EAL_PROVCB_CTRL, NULL},
@@ -960,15 +927,9 @@ int32_t CRYPT_EAL_DefaultProvInit(CRYPT_EAL_ProvMgrCtx *mgrCtx, BSL_Param *param
return CRYPT_PROVIDER_NOT_SUPPORT;
}
#ifdef HITLS_CRYPTO_ENTROPY_DEFAULT
ret = mgrCtrl(mgrCtx, CRYPT_EAL_MGR_GETSEEDCTX, &g_providerSeedCtx, 0);
if (ret != CRYPT_SUCCESS) {
return ret;
}
RETURN_RET_IF_ERR_EX(mgrCtrl(mgrCtx, CRYPT_EAL_MGR_GETSEEDCTX, &g_providerSeedCtx, 0), ret);
#endif
ret = mgrCtrl(mgrCtx, CRYPT_EAL_MGR_GETLIBCTX, &libCtx, 0);
if (ret != CRYPT_SUCCESS) {
return ret;
}
RETURN_RET_IF_ERR_EX(mgrCtrl(mgrCtx, CRYPT_EAL_MGR_GETLIBCTX, &libCtx, 0), ret);
CRYPT_EAL_DefProvCtx *temp = BSL_SAL_Malloc(sizeof(CRYPT_EAL_DefProvCtx));
if (temp == NULL) {
BSL_ERR_PUSH_ERROR(BSL_MALLOC_FAIL);
@@ -976,7 +937,7 @@ int32_t CRYPT_EAL_DefaultProvInit(CRYPT_EAL_ProvMgrCtx *mgrCtx, BSL_Param *param
}
temp->libCtx = libCtx;
*provCtx = temp;
*outFuncs = g_defProvOutFuncs;
*outFuncs = g_defEalProvOutFuncs;
return CRYPT_SUCCESS;
}
crypto/provider/src/default/crypt_default_rand.c
+1 -1
View File
@@ -95,7 +95,7 @@ void *CRYPT_EAL_DefRandNewCtx(void *provCtx, int32_t algId, BSL_Param *param)
return randCtx;
}
const CRYPT_EAL_Func g_defRand[] = {
const CRYPT_EAL_Func g_defEalRand[] = {
#if defined(HITLS_CRYPTO_DRBG)
{CRYPT_EAL_IMPLRAND_DRBGNEWCTX, (CRYPT_EAL_ImplRandDrbgNewCtx)CRYPT_EAL_DefRandNewCtx},
{CRYPT_EAL_IMPLRAND_DRBGINST, (CRYPT_EAL_ImplRandDrbgInst)DRBG_Instantiate},
crypto/provider/src/default/crypt_default_sign.c
+7 -7
View File
@@ -25,7 +25,7 @@
#include "crypt_slh_dsa.h"
#include "crypt_mldsa.h"
const CRYPT_EAL_Func g_defSignDsa[] = {
const CRYPT_EAL_Func g_defEalSignDsa[] = {
#ifdef HITLS_CRYPTO_DSA
{CRYPT_EAL_IMPLPKEYSIGN_SIGN, (CRYPT_EAL_ImplPkeySign)CRYPT_DSA_Sign},
{CRYPT_EAL_IMPLPKEYSIGN_SIGNDATA, (CRYPT_EAL_ImplPkeySignData)CRYPT_DSA_SignData},
@@ -35,7 +35,7 @@ const CRYPT_EAL_Func g_defSignDsa[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defSignEd25519[] = {
const CRYPT_EAL_Func g_defEalSignEd25519[] = {
#ifdef HITLS_CRYPTO_ED25519
{CRYPT_EAL_IMPLPKEYSIGN_SIGN, (CRYPT_EAL_ImplPkeySign)CRYPT_CURVE25519_Sign},
{CRYPT_EAL_IMPLPKEYSIGN_VERIFY, (CRYPT_EAL_ImplPkeyVerify)CRYPT_CURVE25519_Verify},
@@ -43,7 +43,7 @@ const CRYPT_EAL_Func g_defSignEd25519[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defSignRsa[] = {
const CRYPT_EAL_Func g_defEalSignRsa[] = {
#ifdef HITLS_CRYPTO_RSA_SIGN
{CRYPT_EAL_IMPLPKEYSIGN_SIGN, (CRYPT_EAL_ImplPkeySign)CRYPT_RSA_Sign},
{CRYPT_EAL_IMPLPKEYSIGN_SIGNDATA, (CRYPT_EAL_ImplPkeySignData)CRYPT_RSA_SignData},
@@ -64,7 +64,7 @@ const CRYPT_EAL_Func g_defSignRsa[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defSignEcdsa[] = {
const CRYPT_EAL_Func g_defEalSignEcdsa[] = {
#ifdef HITLS_CRYPTO_ECDSA
{CRYPT_EAL_IMPLPKEYSIGN_SIGN, (CRYPT_EAL_ImplPkeySign)CRYPT_ECDSA_Sign},
{CRYPT_EAL_IMPLPKEYSIGN_SIGNDATA, (CRYPT_EAL_ImplPkeySignData)CRYPT_ECDSA_SignData},
@@ -74,7 +74,7 @@ const CRYPT_EAL_Func g_defSignEcdsa[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defSignSm2[] = {
const CRYPT_EAL_Func g_defEalSignSm2[] = {
#ifdef HITLS_CRYPTO_SM2_SIGN
{CRYPT_EAL_IMPLPKEYSIGN_SIGN, (CRYPT_EAL_ImplPkeySign)CRYPT_SM2_Sign},
{CRYPT_EAL_IMPLPKEYSIGN_VERIFY, (CRYPT_EAL_ImplPkeyVerify)CRYPT_SM2_Verify},
@@ -82,7 +82,7 @@ const CRYPT_EAL_Func g_defSignSm2[] = {
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_defSignSlhDsa[] = {
const CRYPT_EAL_Func g_defEalSignSlhDsa[] = {
#ifdef HITLS_CRYPTO_SLH_DSA
{CRYPT_EAL_IMPLPKEYSIGN_SIGN, (CRYPT_EAL_ImplPkeySign)CRYPT_SLH_DSA_Sign},
{CRYPT_EAL_IMPLPKEYSIGN_VERIFY, (CRYPT_EAL_ImplPkeyVerify)CRYPT_SLH_DSA_Verify},
@@ -90,7 +90,7 @@ const CRYPT_EAL_Func g_defSignSlhDsa[] = {
CRYPT_EAL_FUNC_END
};
const CRYPT_EAL_Func g_defSignMlDsa[] = {
const CRYPT_EAL_Func g_defEalSignMlDsa[] = {
#ifdef HITLS_CRYPTO_MLDSA
{CRYPT_EAL_IMPLPKEYSIGN_SIGN, (CRYPT_EAL_ImplPkeySign)CRYPT_ML_DSA_Sign},
{CRYPT_EAL_IMPLPKEYSIGN_VERIFY, (CRYPT_EAL_ImplPkeyVerify)CRYPT_ML_DSA_Verify},
crypto/provider/src/mgr/crypt_provider_common.c
+1 -3
View File
@@ -279,9 +279,7 @@ int32_t CRYPT_EAL_LoadPreDefinedProvider(CRYPT_EAL_LibCtx *libCtx, const char* p
}
}
if (ret != BSL_SUCCESS) {
BSL_SAL_Free(name);
BSL_SAL_ReferencesFree(&mgrCtx->ref);
BSL_SAL_Free(mgrCtx);
CRYPT_EAL_ProviderMgrCtxFree(mgrCtx);
}
return ret;
}
crypto/rsa/src/rsa_local.h
+1 -1
View File
@@ -31,7 +31,7 @@ extern "C" {
#define HASH_MAX_MDSIZE (64)
#define PARAMISNULL(a) (a == NULL || a->value == NULL)
#define PARAMISNULL(a) ((a) == NULL || (a)->value == NULL)
typedef struct RSA_BlindSt {
BN_BigNum *r;
crypto/rsa/src/rsa_padding.c
+4 -4
View File
@@ -186,7 +186,7 @@ int32_t CRYPT_RSA_SetPss(const EAL_MdMethod *hashMethod, const EAL_MdMethod *mgf
const uint32_t maskedDBLen = emLen - hLen - 1;
uint8_t *h = em + maskedDBLen;
ret = CalcHash(hashMethod, hashData, sizeof(hashData) / sizeof(hashData[0]), h, &hLen);
ret = CRYPT_CalcHash(hashMethod, hashData, sizeof(hashData) / sizeof(hashData[0]), h, &hLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
@@ -274,7 +274,7 @@ static int32_t VerifyH(const EAL_MdMethod *hashMethod, const CRYPT_Data *mHash,
};
uint32_t hLen = hBuff->len;
int32_t ret = CalcHash(hashMethod, hashData, sizeof(hashData) / sizeof(hashData[0]), hBuff->data, &hLen);
int32_t ret = CRYPT_CalcHash(hashMethod, hashData, sizeof(hashData) / sizeof(hashData[0]), hBuff->data, &hLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
@@ -701,7 +701,7 @@ int32_t CRYPT_RSA_SetPkcs1Oaep(CRYPT_RSA_Ctx *ctx, const uint8_t *in, uint32_t i
// Calculate hash
const CRYPT_ConstData data = {ctx->label.data, ctx->label.len};
ret = CalcHash(hashMethod, &data, 1, db, &hashLen);
ret = CRYPT_CalcHash(hashMethod, &data, 1, db, &hashLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
@@ -795,7 +795,7 @@ static int32_t OaepVerifyHashMaskDB(const EAL_MdMethod *hashMethod, CRYPT_Data *
int32_t ret;
uint8_t hashVal[HASH_MAX_MDSIZE];
CRYPT_ConstData data = {paramData->data, paramData->len};
ret = CalcHash(hashMethod, &data, 1, hashVal, &hashLen);
ret = CRYPT_CalcHash(hashMethod, &data, 1, hashVal, &hashLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
crypto/slh_dsa/src/slh_dsa.c
+31 -30
View File
@@ -192,33 +192,33 @@ static uint32_t CAdrsGetAdrsLen(void)
}
static AdrsOps g_adrsOps[2] = {{
.setLayerAddr = UCAdrsSetLayerAddr,
.setTreeAddr = UCAdrsSetTreeAddr,
.setType = UCAdrsSetType,
.setKeyPairAddr = UCAdrsSetKeyPairAddr,
.setChainAddr = UCAdrsSetChainAddr,
.setTreeHeight = UCAdrsSetTreeHeight,
.setHashAddr = UCAdrsSetHashAddr,
.setTreeIndex = UCAdrsSetTreeIndex,
.getTreeHeight = UCAdrsGetTreeHeight,
.getTreeIndex = UCAdrsGetTreeIndex,
.copyKeyPairAddr = UCAdrsCopyKeyPairAddr,
.getAdrsLen = UCAdrsGetAdrsLen,
},
{
.setLayerAddr = CAdrsSetLayerAddr,
.setTreeAddr = CAdrsSetTreeAddr,
.setType = CAdrsSetType,
.setKeyPairAddr = CAdrsSetKeyPairAddr,
.setChainAddr = CAdrsSetChainAddr,
.setTreeHeight = CAdrsSetTreeHeight,
.setHashAddr = CAdrsSetHashAddr,
.setTreeIndex = CAdrsSetTreeIndex,
.getTreeHeight = CAdrsGetTreeHeight,
.getTreeIndex = CAdrsGetTreeIndex,
.copyKeyPairAddr = CAdrsCopyKeyPairAddr,
.getAdrsLen = CAdrsGetAdrsLen,
}};
.setLayerAddr = UCAdrsSetLayerAddr,
.setTreeAddr = UCAdrsSetTreeAddr,
.setType = UCAdrsSetType,
.setKeyPairAddr = UCAdrsSetKeyPairAddr,
.setChainAddr = UCAdrsSetChainAddr,
.setTreeHeight = UCAdrsSetTreeHeight,
.setHashAddr = UCAdrsSetHashAddr,
.setTreeIndex = UCAdrsSetTreeIndex,
.getTreeHeight = UCAdrsGetTreeHeight,
.getTreeIndex = UCAdrsGetTreeIndex,
.copyKeyPairAddr = UCAdrsCopyKeyPairAddr,
.getAdrsLen = UCAdrsGetAdrsLen,
},
{
.setLayerAddr = CAdrsSetLayerAddr,
.setTreeAddr = CAdrsSetTreeAddr,
.setType = CAdrsSetType,
.setKeyPairAddr = CAdrsSetKeyPairAddr,
.setChainAddr = CAdrsSetChainAddr,
.setTreeHeight = CAdrsSetTreeHeight,
.setHashAddr = CAdrsSetHashAddr,
.setTreeIndex = CAdrsSetTreeIndex,
.getTreeHeight = CAdrsGetTreeHeight,
.getTreeIndex = CAdrsGetTreeIndex,
.copyKeyPairAddr = CAdrsCopyKeyPairAddr,
.getAdrsLen = CAdrsGetAdrsLen,
}};
void BaseB(const uint8_t *x, uint32_t xLen, uint32_t b, uint32_t *out, uint32_t outLen)
{
@@ -493,7 +493,8 @@ static uint32_t GetMdSize(const EAL_MdMethod *hashMethod, int32_t hashId)
return hashMethod->mdSize;
}
static int32_t MsgEncode(const CryptSlhDsaCtx *ctx, int32_t algId, const uint8_t *data, uint32_t dataLen, uint8_t **mpOut, uint32_t *mpLenOut)
static int32_t MsgEncode(const CryptSlhDsaCtx *ctx, int32_t algId, const uint8_t *data, uint32_t dataLen,
uint8_t **mpOut, uint32_t *mpLenOut)
{
int32_t ret;
BslOidString *oid = NULL;
@@ -503,7 +504,7 @@ static int32_t MsgEncode(const CryptSlhDsaCtx *ctx, int32_t algId, const uint8_t
uint32_t mpLen = SLH_DSA_PREFIX_LEN + ctx->contextLen;
if (ctx->isPrehash) {
oid = BSL_OBJ_GetOidFromCID((BslCid)algId);
oid = BSL_OBJ_GetOID((BslCid)algId);
if (oid == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_SLHDSA_ERR_PREHASH_ID_NOT_SUPPORTED);
return CRYPT_SLHDSA_ERR_PREHASH_ID_NOT_SUPPORTED;
@@ -511,7 +512,7 @@ static int32_t MsgEncode(const CryptSlhDsaCtx *ctx, int32_t algId, const uint8_t
mpLen += 2 + oid->octetLen; // asn1 header length is 2
prehashLen = GetMdSize(EAL_MdFindMethod(algId), algId);
const CRYPT_ConstData constData = {data, dataLen};
ret = CalcHash(EAL_MdFindMethod(algId), &constData, 1, prehash, &prehashLen);
ret = CRYPT_CalcHash(EAL_MdFindMethod(algId), &constData, 1, prehash, &prehashLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
crypto/slh_dsa/src/slh_dsa_hash.c
+1 -1
View File
@@ -35,7 +35,7 @@ static int32_t CalcMultiMsgHash(CRYPT_MD_AlgId mdId, const CRYPT_ConstData *hash
{
uint8_t tmp[MAX_MDSIZE] = {0};
uint32_t tmpLen = sizeof(tmp);
int32_t ret = CalcHash(EAL_MdFindMethod(mdId), hashData, hashDataLen, tmp, &tmpLen);
int32_t ret = CRYPT_CalcHash(EAL_MdFindMethod(mdId), hashData, hashDataLen, tmp, &tmpLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
crypto/slh_dsa/src/slh_dsa_hypertree.c
+13 -9
View File
@@ -34,6 +34,8 @@ int32_t HypertreeSign(const uint8_t *msg, uint32_t msgLen, uint64_t treeIdx, uin
uint32_t d = ctx->para.d;
uint32_t len = 2 * n + 3;
uint32_t retLen = (len + hp) * n * d;
uint32_t leafIdxTmp = leafIdx;
uint64_t treeIdxTmp = treeIdx;
if (*sigLen < retLen) {
return CRYPT_SLHDSA_ERR_SIG_LEN_NOT_ENOUGH;
@@ -49,17 +51,17 @@ int32_t HypertreeSign(const uint8_t *msg, uint32_t msgLen, uint64_t treeIdx, uin
for (uint32_t j = 0; j < d; j++) {
if (j != 0) {
leafIdx = treeIdx & ((1UL << hp) - 1);
treeIdx = treeIdx >> hp;
leafIdxTmp = treeIdxTmp & ((1UL << hp) - 1);
treeIdxTmp = treeIdxTmp >> hp;
ctx->adrsOps.setLayerAddr(&adrs, j);
}
ctx->adrsOps.setTreeAddr(&adrs, treeIdx);
ctx->adrsOps.setTreeAddr(&adrs, treeIdxTmp);
tmpLen = retLen - offset;
ret = XmssSign(root, n, leafIdx, &adrs, ctx, sig + offset, &tmpLen);
ret = XmssSign(root, n, leafIdxTmp, &adrs, ctx, sig + offset, &tmpLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
ret = XmssPkFromSig(leafIdx, sig + offset, tmpLen, root, n, &adrs, ctx, root);
ret = XmssPkFromSig(leafIdxTmp, sig + offset, tmpLen, root, n, &adrs, ctx, root);
if (ret != CRYPT_SUCCESS) {
return ret;
}
@@ -78,6 +80,8 @@ int32_t HypertreeVerify(const uint8_t *msg, uint32_t msgLen, const uint8_t *sig,
uint32_t d = ctx->para.d;
uint32_t len = 2 * n + 3;
uint32_t retLen = (len + hp) * n * d;
uint32_t leafIdxTmp = leafIdx;
uint64_t treeIdxTmp = treeIdx;
if (sigLen < retLen) {
return CRYPT_SLHDSA_ERR_SIG_LEN_NOT_ENOUGH;
@@ -91,12 +95,12 @@ int32_t HypertreeVerify(const uint8_t *msg, uint32_t msgLen, const uint8_t *sig,
(void)memcpy_s(node, sizeof(node), msg, msgLen);
for (uint32_t j = 0; j < d; j++) {
if (j != 0) {
leafIdx = treeIdx & ((1UL << hp) - 1);
treeIdx = treeIdx >> hp;
leafIdxTmp = treeIdxTmp & ((1UL << hp) - 1);
treeIdxTmp = treeIdxTmp >> hp;
ctx->adrsOps.setLayerAddr(&adrs, j);
}
ctx->adrsOps.setTreeAddr(&adrs, treeIdx);
ret = XmssPkFromSig(leafIdx, sig + offset, sigLen - offset, node, n, &adrs, ctx, node);
ctx->adrsOps.setTreeAddr(&adrs, treeIdxTmp);
ret = XmssPkFromSig(leafIdxTmp, sig + offset, sigLen - offset, node, n, &adrs, ctx, node);
if (ret != CRYPT_SUCCESS) {
return ret;
}
crypto/slh_dsa/src/slh_dsa_wots.c
+1 -1
View File
@@ -150,7 +150,7 @@ ERR:
return ret;
}
int WotsPubKeyFromSig(const uint8_t *msg, uint32_t msgLen, const uint8_t *sig, uint32_t sigLen, SlhDsaAdrs *adrs,
int32_t WotsPubKeyFromSig(const uint8_t *msg, uint32_t msgLen, const uint8_t *sig, uint32_t sigLen, SlhDsaAdrs *adrs,
const CryptSlhDsaCtx *ctx, uint8_t *pub)
{
int32_t ret;
crypto/slh_dsa/src/slh_dsa_wots.h
+1 -1
View File
@@ -57,7 +57,7 @@ int32_t WotsSign(uint8_t *sig, uint32_t *sigLen, const uint8_t *msg, uint32_t ms
* @param pub Output reconstructed WOTS+ public key, the length is n
* @return int 0 on success, error code otherwise
*/
int WotsPubKeyFromSig(const uint8_t *msg, uint32_t msgLen, const uint8_t *sig, uint32_t sigLen, SlhDsaAdrs *adrs,
int32_t WotsPubKeyFromSig(const uint8_t *msg, uint32_t msgLen, const uint8_t *sig, uint32_t sigLen, SlhDsaAdrs *adrs,
const CryptSlhDsaCtx *ctx, uint8_t *pub);
/**
crypto/util/crypt_util_mgf.c
+3 -3
View File
@@ -29,8 +29,8 @@
#define HASH_MAX_MDSIZE (64)
// outlen should be hash len
int32_t CalcHash(const EAL_MdMethod *hashMethod, const CRYPT_ConstData *hashData, uint32_t size, uint8_t *out,
uint32_t *outlen)
int32_t CRYPT_CalcHash(const EAL_MdMethod *hashMethod, const CRYPT_ConstData *hashData, uint32_t size, uint8_t *out,
uint32_t *outlen)
{
void *mdCtx = hashMethod->newCtx();
if (mdCtx == NULL) {
@@ -77,7 +77,7 @@ int32_t CRYPT_Mgf1(const EAL_MdMethod *hashMethod, const uint8_t *seed, const ui
uint32_t i, outLen, partLen;
for (i = 0, outLen = 0; outLen < maskLen; i++, outLen += partLen) {
PUT_UINT32_BE(i, counter, 0);
ret = CalcHash(hashMethod, hashData, sizeof(hashData) / sizeof(hashData[0]), md, &hashLen);
ret = CRYPT_CalcHash(hashMethod, hashData, sizeof(hashData) / sizeof(hashData[0]), md, &hashLen);
if (ret != CRYPT_SUCCESS) {
goto EXIT;
}
include/bsl/bsl_obj.h
+5 -4
View File
@@ -570,12 +570,13 @@ typedef struct {
/**
* @ingroup bsl_obj
* @brief Create an object identifier mapping
* @param[in] oid The object identifier string
* @param[in] octs The octs buff for octets
* @param[in] octetLen The length of the octs buff
* @param[in] oidName The name of the object identifier
* @param[in] cid The algorithm ID to map to
* @return HITLS_OK on success, error code on failure
*/
int32_t BSL_OBJ_Create(const BslOidString *oid, const char *oidName, int32_t cid);
int32_t BSL_OBJ_Create(char *octs, uint32_t octetLen, const char *oidName, int32_t cid);
/**
@@ -594,7 +595,7 @@ int32_t BSL_OBJ_CreateSignId(int32_t signId, int32_t asymId, int32_t hashId);
* @param[in] inputCid The algorithm ID
* @return The object identifier string
*/
BslOidString *BSL_OBJ_GetOidFromCID(BslCid inputCid);
BslOidString *BSL_OBJ_GetOID(BslCid ulCID);
/**
* @ingroup bsl_obj
@@ -602,7 +603,7 @@ BslOidString *BSL_OBJ_GetOidFromCID(BslCid inputCid);
* @param[in] oid The object identifier string
* @return The algorithm ID
*/
BslCid BSL_OBJ_GetCIDFromOid(BslOidString *oid);
BslCid BSL_OBJ_GetCID(const BslOidString *oidStr);
#ifdef __cplusplus
}
include/crypto/crypt_eal_codecs.h
+1 -1
View File
@@ -90,7 +90,7 @@ int32_t CRYPT_DECODE_Decode(CRYPT_DECODER_Ctx *ctx, const BSL_Param *inParam, BS
*/
void CRYPT_DECODE_FreeOutData(CRYPT_DECODER_Ctx *ctx, BSL_Param *outData);
typedef struct _CRYPT_DECODER_PoolCtx CRYPT_DECODER_PoolCtx;
typedef struct CRYPT_DECODER_PoolCtx CRYPT_DECODER_PoolCtx;
/**
* @brief Command codes for CRYPT_DECODE_PoolCtrl function
include/crypto/crypt_params_key.h
-1
View File
@@ -17,7 +17,6 @@
#define CRYPT_PARAMS_KEY_H
#include <stdint.h>
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
include/crypto/crypt_types.h
-7
View File
@@ -664,13 +664,6 @@ typedef enum {
} CRYPT_PkeyCtrl;
#define CRYPT_KEYMGMT_SELECT_PRIVATE_KEY 0x01
#define CRYPT_KEYMGMT_SELECT_PUBLIC_KEY 0x02
#define CRYPT_KEYMGMT_SELECT_PARAMETER 0x04
#define CRYPT_KEYMGMT_SELECT_UNKNOWN 0x08
#define CRYPT_KEYMGMT_SELECT_KEY_PAIR (CRYPT_KEYMGMT_SELECT_PRIVATE_KEY | CRYPT_KEYMGMT_SELECT_PUBLIC_KEY)
#define CRYPT_KEYMGMT_SELECT_ALL (CRYPT_KEYMGMT_SELECT_PRIVATE_KEY | CRYPT_KEYMGMT_SELECT_PUBLIC_KEY | \
CRYPT_KEYMGMT_SELECT_PARAMETER)
typedef enum {
CRYPT_CTRL_SET_GM_LEVEL, /**< Set the authentication level of gm drbg */
CRYPT_CTRL_SET_RESEED_INTERVAL,
pki/cms/src/hitls_cms_common.c
+2 -2
View File
@@ -106,7 +106,7 @@ int32_t HITLS_CMS_ParseDigestInfo(BSL_Buffer *encode, BslCid *cid, BSL_Buffer *d
return ret;
}
BslOidString oidStr = {asn1[HITLS_P7_DIGESTINFO_OID_IDX].len, (char *)asn1[HITLS_P7_DIGESTINFO_OID_IDX].buff, 0};
BslCid parseCid = BSL_OBJ_GetCIDFromOid(&oidStr);
BslCid parseCid = BSL_OBJ_GetCID(&oidStr);
if (parseCid == BSL_CID_UNKNOWN) {
BSL_ERR_PUSH_ERROR(HITLS_CMS_ERR_PARSE_TYPE);
return HITLS_CMS_ERR_PARSE_TYPE;
@@ -135,7 +135,7 @@ int32_t HITLS_CMS_EncodeDigestInfoBuff(BslCid cid, BSL_Buffer *in, BSL_Buffer *e
return HITLS_CMS_ERR_NULL_POINTER;
}
BslOidString *oidstr = BSL_OBJ_GetOidFromCID(cid);
BslOidString *oidstr = BSL_OBJ_GetOID(cid);
if (oidstr == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_CMS_ERR_INVALID_ALGO);
return HITLS_CMS_ERR_INVALID_ALGO;
pki/pkcs12/src/hitls_pkcs12_common.c
+10 -10
View File
@@ -160,7 +160,7 @@ static int32_t ParseCommonSafeBag(BSL_Buffer *buffer, HITLS_PKCS12_CommonSafeBag
}
BslOidString oidStr = {asnArr[HITLS_PKCS12_COMMON_SAFEBAG_OID_IDX].len,
(char *)asnArr[HITLS_PKCS12_COMMON_SAFEBAG_OID_IDX].buff, 0};
BslCid cid = BSL_OBJ_GetCIDFromOid(&oidStr);
BslCid cid = BSL_OBJ_GetCID(&oidStr);
if (cid == BSL_CID_UNKNOWN) {
BSL_ERR_PUSH_ERROR(HITLS_PKCS12_ERR_PARSE_TYPE);
return HITLS_PKCS12_ERR_PARSE_TYPE;
@@ -283,7 +283,7 @@ static int32_t ParseSafeBag(BSL_Buffer *buffer, HITLS_PKCS12_SafeBag *safeBag)
}
BslOidString oid = {asnArr[HITLS_PKCS12_SAFEBAG_OID_IDX].len, (char *)asnArr[HITLS_PKCS12_SAFEBAG_OID_IDX].buff, 0};
BslCid cid = BSL_OBJ_GetCIDFromOid(&oid);
BslCid cid = BSL_OBJ_GetCID(&oid);
if (cid == BSL_CID_UNKNOWN) {
BSL_ERR_PUSH_ERROR(HITLS_PKCS12_ERR_INVALID_SAFEBAG_TYPE);
return HITLS_PKCS12_ERR_INVALID_SAFEBAG_TYPE;
@@ -419,7 +419,7 @@ int32_t HITLS_PKCS12_ParseContentInfo(HITLS_PKI_LibCtx *libCtx, const char *attr
return ret;
}
BslOidString oid = {asnArr[HITLS_PKCS12_CONTENT_OID_IDX].len, (char *)asnArr[HITLS_PKCS12_CONTENT_OID_IDX].buff, 0};
BslCid cid = BSL_OBJ_GetCIDFromOid(&oid);
BslCid cid = BSL_OBJ_GetCID(&oid);
if (cid == BSL_CID_UNKNOWN) {
BSL_ERR_PUSH_ERROR(HITLS_PKCS12_ERR_INVALID_SAFEBAG_TYPE);
return HITLS_PKCS12_ERR_INVALID_SAFEBAG_TYPE;
@@ -905,7 +905,7 @@ static int32_t X509_EncodeP12AttrItem(void *attrNode, HITLS_X509_AttrEntry *attr
return HITLS_X509_ERR_INVALID_PARAM;
}
HITLS_PKCS12_SafeBagAttr *p12Attr = attrNode;
BslOidString *oidStr = BSL_OBJ_GetOidFromCID(p12Attr->attrId);
BslOidString *oidStr = BSL_OBJ_GetOID(p12Attr->attrId);
if (oidStr == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_PKCS12_ERR_INVALID_SAFEBAG_ATTRIBUTES);
return HITLS_PKCS12_ERR_INVALID_SAFEBAG_ATTRIBUTES;
@@ -935,7 +935,7 @@ int32_t HITLS_PKCS12_EncodeAttrList(HITLS_X509_Attrs *attrs, BSL_ASN1_Buffer *at
static int32_t EncodeCertBag(HITLS_X509_Cert *cert, uint32_t certType, uint8_t **encode, uint32_t *encodeLen)
{
int32_t ret;
BslOidString *oidStr = BSL_OBJ_GetOidFromCID(certType);
BslOidString *oidStr = BSL_OBJ_GetOID(certType);
if (oidStr == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_PKCS12_ERR_INVALID_ALGO);
return HITLS_PKCS12_ERR_INVALID_ALGO;
@@ -970,7 +970,7 @@ static int32_t EncodeSafeBag(HITLS_PKCS12_Bag *bag, uint32_t encodeType, const C
uint8_t **output, uint32_t *outputLen)
{
int32_t ret;
BslOidString *oidStr = BSL_OBJ_GetOidFromCID(encodeType);
BslOidString *oidStr = BSL_OBJ_GetOID(encodeType);
if (oidStr == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_PKCS12_ERR_INVALID_ALGO);
return HITLS_PKCS12_ERR_INVALID_ALGO;
@@ -1040,7 +1040,7 @@ int32_t HITLS_PKCS12_EncodeContentInfo(HITLS_PKI_LibCtx *libCtx, const char *att
uint32_t encodeType, const CRYPT_EncodeParam *encryptParam, BSL_Buffer *encode)
{
int32_t ret;
BslOidString *oidStr = BSL_OBJ_GetOidFromCID(encodeType);
BslOidString *oidStr = BSL_OBJ_GetOID(encodeType);
if (oidStr == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_PKCS12_ERR_INVALID_ALGO);
return HITLS_PKCS12_ERR_INVALID_ALGO;
@@ -1227,10 +1227,9 @@ static int32_t EncodeCertListAddList(HITLS_PKCS12 *p12, const CRYPT_EncodeParam
bool isNeedMac)
{
int32_t ret;
HITLS_PKCS12_Bag *bag = NULL;
BSL_Buffer certEncode = {0};
if (p12->entityCert != NULL && p12->entityCert->value.cert != NULL) {
bag = BSL_SAL_Malloc(sizeof(HITLS_PKCS12_Bag));
HITLS_PKCS12_Bag *bag = BSL_SAL_Malloc(sizeof(HITLS_PKCS12_Bag));
if (bag == NULL) {
BSL_ERR_PUSH_ERROR(BSL_MALLOC_FAIL);
return BSL_MALLOC_FAIL;
@@ -1307,7 +1306,8 @@ static int32_t EncodeKeyAddList(HITLS_PKCS12 *p12, const CRYPT_EncodeParam *encP
return ret;
}
ret = HITLS_PKCS12_EncodeContentInfo(p12->libCtx, p12->attrName, &keyEncode, BSL_CID_PKCS7_SIMPLEDATA, NULL, &contentInfoEncode);
ret = HITLS_PKCS12_EncodeContentInfo(p12->libCtx, p12->attrName, &keyEncode, BSL_CID_PKCS7_SIMPLEDATA,
NULL, &contentInfoEncode);
BSL_SAL_FREE(keyEncode.data);
if (ret != HITLS_PKI_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
pki/x509_cert/src/hitls_x509_cert.c
+1 -1
View File
@@ -146,7 +146,7 @@ int32_t HITLS_X509_CertTagGetOrCheck(int32_t type, uint32_t idx, void *data, voi
if (idx == X509_ASN1_TBS_SIGNALG_ANY || idx == X509_ASN1_SIGNALG_ANY) {
BSL_ASN1_Buffer *param = (BSL_ASN1_Buffer *) data;
BslOidString oidStr = {param->len, (char *)param->buff, 0};
BslCid cid = BSL_OBJ_GetCIDFromOid(&oidStr);
BslCid cid = BSL_OBJ_GetCID(&oidStr);
if (cid == BSL_CID_UNKNOWN) {
return HITLS_X509_ERR_GET_ANY_TAG;
}
pki/x509_common/src/hitls_x509_attrs.c
+2 -2
View File
@@ -95,7 +95,7 @@ void HITLS_X509_AttrsFree(HITLS_X509_Attrs *attrs, HITLS_X509_FreeAttrItemCb fre
#if defined(HITLS_PKI_X509_CSR_GEN) || defined(HITLS_PKI_PKCS12_GEN)
int32_t HITLS_X509_EncodeObjIdentity(BslCid cid, BSL_ASN1_Buffer *asnBuff)
{
BslOidString *oidStr = BSL_OBJ_GetOidFromCID(cid);
BslOidString *oidStr = BSL_OBJ_GetOID(cid);
if (oidStr == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
return CRYPT_ERR_ALGID;
@@ -165,7 +165,7 @@ int32_t HITLS_X509_ParseAttr(BSL_ASN1_Buffer *attrItem, HITLS_X509_AttrEntry *at
}
/* parse attribute id */
BslOidString oid = {asnArr[HITLS_X509_ATTR_OID_IDX].len, (char *)asnArr[HITLS_X509_ATTR_OID_IDX].buff, 0};
attrEntry->cid = BSL_OBJ_GetCIDFromOid(&oid);
attrEntry->cid = BSL_OBJ_GetCID(&oid);
if (attrEntry->cid == BSL_CID_UNKNOWN) {
BSL_ERR_PUSH_ERROR(HITLS_X509_ERR_PARSE_OBJ_ID);
return HITLS_X509_ERR_PARSE_OBJ_ID;
pki/x509_common/src/hitls_x509_common.c
+22 -18
View File
@@ -80,7 +80,7 @@ int32_t HITLS_X509_ParseSignAlgInfo(BSL_ASN1_Buffer *algId, BSL_ASN1_Buffer *par
{
int32_t ret = HITLS_PKI_SUCCESS;
BslOidString oidStr = {algId->len, (char *)algId->buff, 0};
BslCid cid = BSL_OBJ_GetCIDFromOid(&oidStr);
BslCid cid = BSL_OBJ_GetCID(&oidStr);
if (cid == BSL_CID_UNKNOWN) {
BSL_ERR_PUSH_ERROR(HITLS_X509_ERR_ALG_OID);
return HITLS_X509_ERR_ALG_OID;
@@ -224,7 +224,7 @@ static bool X509_CheckIsRsa(uint32_t algId)
int32_t HITLS_X509_EncodeSignAlgInfo(HITLS_X509_Asn1AlgId *x509Alg, BSL_ASN1_Buffer *asn)
{
int32_t ret;
BslOidString *oidStr = BSL_OBJ_GetOidFromCID(x509Alg->algId);
BslOidString *oidStr = BSL_OBJ_GetOID(x509Alg->algId);
if (oidStr == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_X509_ERR_ALG_OID);
return HITLS_X509_ERR_ALG_OID;
@@ -606,7 +606,7 @@ static int32_t X509_CheckPssParam(CRYPT_EAL_PkeyCtx *key, int32_t algId, const C
int32_t HITLS_X509_CheckAlg(CRYPT_EAL_PkeyCtx *pubkey, const HITLS_X509_Asn1AlgId *subAlg)
{
uint32_t pubKeyId = CRYPT_EAL_PkeyGetId(pubkey);
if (pubKeyId == BSL_CID_UNKNOWN) {
if (pubKeyId == CRYPT_PKEY_MAX) {
BSL_ERR_PUSH_ERROR(HITLS_X509_ERR_VFY_GET_SIGNID);
return HITLS_X509_ERR_VFY_GET_SIGNID;
}
@@ -626,7 +626,7 @@ int32_t HITLS_X509_CheckAlg(CRYPT_EAL_PkeyCtx *pubkey, const HITLS_X509_Asn1AlgI
return HITLS_X509_ERR_ALG_UNSUPPORT;
#endif
}
BslCid subSignAlg = BSL_OBJ_GetAsymIdFromSignId(subAlg->algId);
BslCid subSignAlg = BSL_OBJ_GetAsymAlgIdFromSignId(subAlg->algId);
if (subSignAlg == BSL_CID_UNKNOWN) {
BSL_ERR_PUSH_ERROR(HITLS_X509_ERR_VFY_GET_SIGNID);
return HITLS_X509_ERR_VFY_GET_SIGNID;
@@ -759,6 +759,22 @@ int32_t HITLS_X509_CheckSignature(const CRYPT_EAL_PkeyCtx *pubKey, uint8_t *rawD
}
#ifdef HITLS_PKI_X509_VFY
static int32_t X509_CheckAuthCertIssuer(BslList *authCertIssue, BSL_ASN1_List *issueName)
{
HITLS_X509_GeneralName *name = NULL;
for (HITLS_X509_GeneralName *tmp = BSL_LIST_GET_FIRST(authCertIssue); tmp != NULL;
tmp = BSL_LIST_GET_NEXT(authCertIssue)) {
if (tmp->type == HITLS_X509_GN_DNNAME) {
name = tmp;
break;
}
}
if (name == NULL) {
return HITLS_X509_ERR_VFY_AKI_SKI_NOT_MATCH;
}
return HITLS_X509_CmpNameNode((BslList *)name->value.data, issueName);
}
int32_t HITLS_X509_CheckAki(HITLS_X509_Ext *issueExt, HITLS_X509_Ext *subjectExt, BSL_ASN1_List *issueName,
BSL_ASN1_Buffer *serialNum)
{
@@ -786,21 +802,9 @@ int32_t HITLS_X509_CheckAki(HITLS_X509_Ext *issueExt, HITLS_X509_Ext *subjectExt
return HITLS_X509_ERR_VFY_AKI_SKI_NOT_MATCH;
}
if (aki.issuerName != NULL) {
HITLS_X509_GeneralName *name = NULL;
for (HITLS_X509_GeneralName *tmp = BSL_LIST_GET_FIRST(aki.issuerName); tmp != NULL;
tmp = BSL_LIST_GET_NEXT(aki.issuerName)) {
if (tmp->type == HITLS_X509_GN_DNNAME) {
name = tmp;
break;
}
}
if (name == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_X509_ERR_VFY_AKI_SKI_NOT_MATCH);
return HITLS_X509_ERR_VFY_AKI_SKI_NOT_MATCH;
}
ret = HITLS_X509_CmpNameNode((BslList *)name->value.data, issueName);
ret = X509_CheckAuthCertIssuer(aki.issuerName, issueName);
HITLS_X509_ClearAuthorityKeyId(&aki);
if (ret != 0) {
if (ret != HITLS_PKI_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_X509_ERR_VFY_AKI_SKI_NOT_MATCH);
return HITLS_X509_ERR_VFY_AKI_SKI_NOT_MATCH;
}
pki/x509_common/src/hitls_x509_ctrl.c
+1 -1
View File
@@ -307,7 +307,7 @@ int32_t HITLS_X509_SetNameList(BslList **dest, void *val, uint32_t valLen)
static int32_t FillNameNodes(HITLS_X509_NameNode *layer2, BslCid cid, uint8_t *data, uint32_t dataLen)
{
BslOidString *oid = BSL_OBJ_GetOidFromCID(cid);
BslOidString *oid = BSL_OBJ_GetOID(cid);
if (oid == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_X509_ERR_SET_DNNAME_UNKNOWN);
return HITLS_X509_ERR_SET_DNNAME_UNKNOWN;
pki/x509_common/src/hitls_x509_ext.c
+3 -3
View File
@@ -630,7 +630,7 @@ int32_t HITLS_X509_ParseExtItem(BSL_ASN1_Buffer *extItem, HITLS_X509_ExtEntry *e
// extnid
extEntry->extnId = asnArr[HITLS_X509_EXT_OID_IDX];
BslOidString oid = {extEntry->extnId.len, (char *)extEntry->extnId.buff, 0};
extEntry->cid = BSL_OBJ_GetCIDFromOid(&oid);
extEntry->cid = BSL_OBJ_GetCID(&oid);
// critical
if (asnArr[HITLS_X509_EXT_CRITICAL_IDX].tag == 0) {
extEntry->critical = false;
@@ -657,7 +657,7 @@ static void FreeExtEntryCont(HITLS_X509_ExtEntry *entry)
static int32_t GetExtEntryByCid(BslList *extList, BslCid cid, HITLS_X509_ExtEntry **entry, bool *isNew)
{
BslOidString *oid = BSL_OBJ_GetOidFromCID(cid);
BslOidString *oid = BSL_OBJ_GetOID(cid);
if (oid == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_X509_ERR_EXT_OID);
return HITLS_X509_ERR_EXT_OID;
@@ -720,7 +720,7 @@ static int32_t ParseExtAsnItem(BSL_ASN1_Buffer *asn, void *param, BSL_ASN1_List
}
BslOidString oid = {extEntry.extnId.len, (char *)extEntry.extnId.buff, 0};
switch (BSL_OBJ_GetCIDFromOid(&oid)) {
switch (BSL_OBJ_GetCID(&oid)) {
case BSL_CID_CE_KEYUSAGE:
return ParseExtKeyUsage(&extEntry, (HITLS_X509_CertExt *)ext->extData);
case BSL_CID_CE_BASICCONSTRAINTS:
pki/x509_crl/src/hitls_x509_crl.c
+1 -1
View File
@@ -92,7 +92,7 @@ int32_t HITLS_X509_CrlTagGetOrCheck(int32_t type, uint32_t idx, void *data, void
case BSL_ASN1_TYPE_GET_ANY_TAG: {
BSL_ASN1_Buffer *param = (BSL_ASN1_Buffer *) data;
BslOidString oidStr = {param->len, (char *)param->buff, 0};
BslCid cid = BSL_OBJ_GetCIDFromOid(&oidStr);
BslCid cid = BSL_OBJ_GetCID(&oidStr);
if (cid == BSL_CID_UNKNOWN) {
return HITLS_X509_ERR_GET_ANY_TAG;
}
pki/x509_csr/src/hitls_x509_csr.c
+1 -1
View File
@@ -164,7 +164,7 @@ int32_t HITLS_X509_CsrTagGetOrCheck(int32_t type, uint32_t idx, void *data, void
if (type == BSL_ASN1_TYPE_GET_ANY_TAG) {
BSL_ASN1_Buffer *param = (BSL_ASN1_Buffer *)data;
BslOidString oidStr = {param->len, (char *)param->buff, 0};
BslCid cid = BSL_OBJ_GetCIDFromOid(&oidStr);
BslCid cid = BSL_OBJ_GetCID(&oidStr);
if (cid == BSL_CID_UNKNOWN) {
return HITLS_X509_ERR_GET_ANY_TAG;
}
pki/x509_verify/src/hitls_x509_verify.c
+1 -4
View File
@@ -648,13 +648,10 @@ int32_t HITLS_X509_CheckCertCrl(HITLS_X509_StoreCtx *storeCtx, HITLS_X509_Cert *
crl->tbs.tbsRawDataLen, &(crl->signAlgId), &(crl->signature));
#endif
if (ret != HITLS_PKI_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = HITLS_X509_TrvList(crl->tbs.revokedCerts,
(HITLS_X509_TrvListCallBack)HITLS_X509_CheckCertRevoked, cert);
ret = HITLS_X509_TrvList(crl->tbs.revokedCerts, (HITLS_X509_TrvListCallBack)HITLS_X509_CheckCertRevoked, cert);
if (ret != HITLS_PKI_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
crl = BSL_LIST_GET_NEXT(storeCtx->crl);
testcode/sdv/testcase/bsl/asn1/test_suite_sdv_asn1.c
+2 -2
View File
@@ -1109,9 +1109,9 @@ void SDV_BSL_ASN1_ENCODE_LIST_TC001(int listSize, Hex *encode)
{BSL_ASN1_TAG_ANY, 0, 2}
};
BSL_ASN1_Template templ = {x509Name, sizeof(x509Name) / sizeof(x509Name[0])};
BslOidString *o = BSL_OBJ_GetOidFromCID(BSL_CID_AT_ORGANIZATIONNAME);
BslOidString *o = BSL_OBJ_GetOID(BSL_CID_AT_ORGANIZATIONNAME);
char *oName = "Energy TEST";
BslOidString *cn = BSL_OBJ_GetOidFromCID(BSL_CID_AT_COMMONNAME);
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},
testcode/sdv/testcase/bsl/list/test_suite_sdv_list.c
+11
View File
@@ -316,6 +316,17 @@ void SDV_BSL_LIST_DETACH_FUNC_TC001(void)
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);
}
testcode/sdv/testcase/bsl/obj/test_suite_sdv_obj.c
+15 -16
View File
@@ -76,7 +76,7 @@ void SDV_BSL_OBJ_CREATE_SIGN_ID_TC001(void)
TestMemInit();
ASSERT_EQ(BSL_OBJ_CreateSignId(signId, asymId, hashId), BSL_SUCCESS);
BslCid retrievedAsymId = BSL_OBJ_GetAsymIdFromSignId(signId);
BslCid retrievedAsymId = BSL_OBJ_GetAsymAlgIdFromSignId(signId);
ASSERT_EQ(asymId, retrievedAsymId);
BslCid retrievedHashId = BSL_OBJ_GetHashIdFromSignId(signId);
@@ -121,17 +121,16 @@ void SDV_BSL_OBJ_CREATE_TC001()
const char *aesOidName = "AES128-CBC";
BslCid aesCid = BSL_CID_AES128_CBC;
char aesOidData[] = "\140\206\110\1\145\3\4\1\2";
BslOidString aesOid = {9, aesOidData, BSL_OID_GLOBAL};
TestMemInit();
ASSERT_EQ(BSL_OBJ_Create(&aesOid, aesOidName, aesCid), BSL_SUCCESS);
ASSERT_EQ(BSL_OBJ_Create(aesOidData, 9, aesOidName, aesCid), BSL_SUCCESS);
ASSERT_EQ(BSL_OBJ_Create(&testOid, testOidName, testCid), BSL_SUCCESS);
ASSERT_EQ(BSL_OBJ_Create(testOidData, 9, testOidName, testCid), BSL_SUCCESS);
BslCid retrievedCid = BSL_OBJ_GetCIDFromOid(&testOid);
BslCid retrievedCid = BSL_OBJ_GetCID(&testOid);
ASSERT_EQ(testCid, retrievedCid);
BslOidString *retrievedOid = BSL_OBJ_GetOidFromCID(testCid);
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);
@@ -140,13 +139,13 @@ void SDV_BSL_OBJ_CREATE_TC001()
ASSERT_TRUE(retrievedName != NULL);
ASSERT_EQ(strcmp(testOidName, retrievedName), 0);
ASSERT_EQ(BSL_OBJ_Create(&testOid, testOidName, testCid), BSL_SUCCESS);
ASSERT_EQ(BSL_OBJ_Create(testOidData, 9, testOidName, testCid), BSL_SUCCESS);
ASSERT_EQ(BSL_OBJ_Create(NULL, testOidName, testCid), BSL_INVALID_ARG);
ASSERT_EQ(BSL_OBJ_Create(NULL, 9, testOidName, testCid), BSL_INVALID_ARG);
ASSERT_EQ(BSL_OBJ_Create(&testOid, NULL, testCid), BSL_INVALID_ARG);
ASSERT_EQ(BSL_OBJ_Create(testOidData, 9, NULL, testCid), BSL_INVALID_ARG);
ASSERT_EQ(BSL_OBJ_Create(&testOid, testOidName, BSL_CID_UNKNOWN), BSL_INVALID_ARG);
ASSERT_EQ(BSL_OBJ_Create(testOidData, 9, testOidName, BSL_CID_UNKNOWN), BSL_INVALID_ARG);
BSL_OBJ_FreeHashTable();
EXIT:
@@ -185,24 +184,24 @@ void SDV_BSL_OBJ_HASH_TABLE_LOOKUP_TC001()
testOid2.flags = BSL_OID_GLOBAL;
TestMemInit();
ret = BSL_OBJ_Create(&testOid1, testOidName1, testCid1);
ret = BSL_OBJ_Create(testOidData1, sizeof(testOidData1), testOidName1, testCid1);
ASSERT_EQ(BSL_SUCCESS, ret);
ret = BSL_OBJ_Create(&testOid2, testOidName2, testCid2);
ret = BSL_OBJ_Create(testOidData2, sizeof(testOidData2), testOidName2, testCid2);
ASSERT_EQ(BSL_SUCCESS, ret);
BslCid retrievedCid1 = BSL_OBJ_GetCIDFromOid(&testOid1);
BslCid retrievedCid1 = BSL_OBJ_GetCID(&testOid1);
ASSERT_EQ(testCid1, retrievedCid1);
BslCid retrievedCid2 = BSL_OBJ_GetCIDFromOid(&testOid2);
BslCid retrievedCid2 = BSL_OBJ_GetCID(&testOid2);
ASSERT_EQ(testCid2, retrievedCid2);
BslOidString *retrievedOid1 = BSL_OBJ_GetOidFromCID(testCid1);
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_GetOidFromCID(testCid2);
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);
testcode/sdv/testcase/crypto/drbg/test_suite_sdv_drbg.c
+1 -1
View File
@@ -1318,7 +1318,7 @@ void SDV_CRYPT_DRBG_GETENTROPY_FUNC_TC001(int agId)
ASSERT_NE(CRYPT_EAL_RandInit(agId, &seedMeth, (void *)&seedCtx, NULL, 0), CRYPT_SUCCESS);
drbg = CRYPT_EAL_DrbgNew(agId, &seedMeth, (void *)&seedCtx);
ASSERT_TRUE(drbg != NULL);
ASSERT_NE(CRYPT_EAL_DrbgInstantiate(drbg, NULL, 0), CRYPT_SUCCESS);
ASSERT_EQ(CRYPT_EAL_DrbgInstantiate(drbg, NULL, 0), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_DrbgDeinit(drbg);
CRYPT_EAL_RandDeinit();
testcode/sdv/testcase/crypto/encode/test_suite_sdv_asn1_certkey.c
+2 -2
View File
@@ -103,7 +103,7 @@ int32_t BSL_ASN1_CertTagGetOrCheck(int32_t type, uint32_t idx, void *data, void
case BSL_ASN1_TYPE_GET_ANY_TAG: {
BSL_ASN1_Buffer *param = (BSL_ASN1_Buffer *)data;
BslOidString oidStr = {param->len, (char *)param->buff, 0};
BslCid cid = BSL_OBJ_GetCIDFromOid(&oidStr);
BslCid cid = BSL_OBJ_GetCID(&oidStr);
if (idx == BSL_ASN1_ID_ANY_1 || idx == BSL_ASN1_ID_ANY_3) {
if (cid == BSL_CID_RSASSAPSS) {
// note: any It can be encoded empty or it can be null
@@ -147,7 +147,7 @@ int32_t BSL_ASN1_SubKeyInfoTagGetOrCheck(int32_t type, int32_t idx, void *data,
case BSL_ASN1_TYPE_GET_ANY_TAG: {
BSL_ASN1_Buffer *param = (BSL_ASN1_Buffer *)data;
BslOidString oidStr = {param->len, (char *)param->buff, 0};
BslCid cid = BSL_OBJ_GetCIDFromOid(&oidStr);
BslCid cid = BSL_OBJ_GetCID(&oidStr);
if (cid == BSL_CID_EC_PUBLICKEY) {
// note: any It can be encoded empty or it can be null
*(uint8_t *)expVal = BSL_ASN1_TAG_OBJECT_ID;
testcode/sdv/testcase/crypto/provider/test_suite_sdv_eal_provider_load.c
+21
View File
@@ -1123,3 +1123,24 @@ EXIT:
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_CRYPTO_PROVIDER_GET_CAP_TEST_TC003(void)
{
#ifndef HITLS_CRYPTO_PROVIDER
SKIP_TEST();
#else
CRYPT_EAL_LibCtx *libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, 0, "default", NULL, NULL), CRYPT_SUCCESS);
CRYPT_EAL_ProviderUnload(libCtx, 0, "default");
ASSERT_EQ(CRYPT_EAL_ProviderLoad(libCtx, 0, "default", NULL, NULL), CRYPT_SUCCESS);
EXIT:
CRYPT_EAL_ProviderUnload(libCtx, 0, "default");
CRYPT_EAL_LibCtxFree(libCtx);
#endif
}
/* END_CASE */
testcode/sdv/testcase/crypto/provider/test_suite_sdv_eal_provider_load.data
+3
View File
@@ -49,3 +49,6 @@ SDV_CRYPTO_PROVIDER_GET_CAP_TEST_TC001:"../testdata/provider/path1":"provider_ge
SDV_CRYPTO_PROVIDER_GET_CAP_TEST_TC002
SDV_CRYPTO_PROVIDER_GET_CAP_TEST_TC002:"../testdata/provider/path1":"provider_get_cap_test1":2
SDV_CRYPTO_PROVIDER_GET_CAP_TEST_TC003
SDV_CRYPTO_PROVIDER_GET_CAP_TEST_TC003:
testcode/sdv/testcase/pki/common/test_suite_sdv_common.c
+1 -1
View File
@@ -552,7 +552,7 @@ void SDV_X509_EXT_SetExtendKeyUsage_TC001(void)
BSL_LIST_DeleteAll(oidList, FreeListData);
// success: normal oid
BslOidString *oid = BSL_OBJ_GetOidFromCID(BSL_CID_KP_SERVERAUTH);
BslOidString *oid = BSL_OBJ_GetOID(BSL_CID_KP_SERVERAUTH);
ASSERT_NE(oid, NULL);
BSL_Buffer oidBuff = {(uint8_t *)oid->octs, oid->octetLen};
ASSERT_EQ(BSL_LIST_AddElement(oidList, &oidBuff, BSL_LIST_POS_END), 0);
testcode/sdv/testcase/pki/common/test_suite_sdv_x509.c
+1 -1
View File
@@ -332,7 +332,7 @@ static int32_t SetCertExt(HITLS_X509_Cert *cert)
BslList *oidList = BSL_LIST_New(sizeof(BSL_Buffer));
ASSERT_TRUE(oidList != NULL);
oid = BSL_OBJ_GetOidFromCID(BSL_CID_KP_SERVERAUTH);
oid = BSL_OBJ_GetOID(BSL_CID_KP_SERVERAUTH);
ASSERT_NE(oid, NULL);
oidBuff.data = (uint8_t *)oid->octs;
oidBuff.dataLen = oid->octetLen;
testcode/sdv/testcase/pki/csr/test_suite_sdv_x509_csr.c
+1 -1
View File
@@ -242,7 +242,7 @@ void SDV_X509_CSR_PARSE_FUNC_TC003(int format, char *path, int attrNum, int attr
HITLS_X509_AttrEntry *entry = BSL_LIST_GET_FIRST(rawAttrs->list);
ASSERT_EQ(attrCid, entry->cid);
BslOidString *oid = BSL_OBJ_GetOidFromCID(entry->cid);
BslOidString *oid = BSL_OBJ_GetOID(entry->cid);
ASSERT_NE(oid, NULL);
ASSERT_COMPARE("csr attr oid", entry->attrId.buff, entry->attrId.len, (uint8_t *)oid->octs, oid->octetLen);
ASSERT_COMPARE("csr attr value", entry->attrValue.buff, entry->attrValue.len, attrValue->x, attrValue->len);
testcode/sdv/testcase/tls/interface_tlcp/test_suite_sdv_frame_cm_interface.c
+2
View File
@@ -1918,12 +1918,14 @@ void UT_TLS_CM_HITLS_GetSharedGroup_FUNC_TC004(int version)
uint16_t signAlgs_c[] = {signWrtVersion, CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384};
HITLS_CFG_SetGroups(config_c, groups_c, sizeof(groups_c) / sizeof(uint16_t));
HITLS_CFG_SetSignature(config_c, signAlgs_c, sizeof(signAlgs_c) / sizeof(uint16_t));
HITLS_CFG_SetDhAutoSupport(config_c, true);
uint16_t groups_s[] = {HITLS_EC_GROUP_SECP256R1, HITLS_EC_GROUP_SECP521R1};
uint16_t signAlgs_s[] = {
signWrtVersion, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512};
HITLS_CFG_SetGroups(config_s, groups_s, sizeof(groups_s) / sizeof(uint16_t));
HITLS_CFG_SetSignature(config_s, signAlgs_s, sizeof(signAlgs_s) / sizeof(uint16_t));
HITLS_CFG_SetDhAutoSupport(config_s, true);
FRAME_CertInfo certInfo = {
"rsa_pss_sha256/rsa_pss_root.crt",
testcode/testdata/provider/provider_new_alg_test.c
Vendored
+2 -2
View File
@@ -448,7 +448,7 @@ typedef enum {
static int32_t GetParaId(uint8_t *octs, uint32_t octsLen)
{
BslOidString oidStr = {octsLen, (char *)octs, 0};
BslCid cid = BSL_OBJ_GetCIDFromOid(&oidStr);
BslCid cid = BSL_OBJ_GetCID(&oidStr);
if (cid == BSL_CID_UNKNOWN) {
return CRYPT_PKEY_PARAID_MAX;
}
@@ -589,7 +589,7 @@ static int32_t NewAlgKeySubKeyInfoCb(int32_t type, uint32_t idx, void *data, voi
switch (type) {
case BSL_ASN1_TYPE_GET_ANY_TAG: {
BslOidString oidStr = {param->len, (char *)param->buff, 0};
BslCid cid = BSL_OBJ_GetCIDFromOid(&oidStr);
BslCid cid = BSL_OBJ_GetCID(&oidStr);
if (cid == NEW_PKEY_ALGID) {
// note: any It can be encoded empty or it can be null
*(uint8_t *)expVal = BSL_ASN1_TAG_OBJECT_ID;
testcode/testdata/provider/provider_self_decoder_test.c
Vendored
+3 -2
View File
@@ -30,7 +30,8 @@
#define RSA_MAX_MODULUS_BITS 16384
#define RSA_MAX_MODULUS_LEN (RSA_MAX_MODULUS_BITS / 8)
#define PARAMISNULL(a) (a == NULL || a->value == NULL)
#define PARAMISNULL(a) ((a) == NULL || (a)->value == NULL)
#define PARAMISNULLLENIS0(a) ((a) == NULL || (a)->value == NULL || (a)->valueLen == 0)
/* JSON to PEM decoder context */
typedef struct {
@@ -241,7 +242,7 @@ static int32_t TestRsaSetPrvKey(void *ctx, const BSL_Param *param)
const BSL_Param *dp = TestFindConstParam(param, CRYPT_PARAM_RSA_DP);
const BSL_Param *dq = TestFindConstParam(param, CRYPT_PARAM_RSA_DQ);
const BSL_Param *qInv = TestFindConstParam(param, CRYPT_PARAM_RSA_QINV);
if (PARAMISNULL(n) || PARAMISNULL(d) || n->valueType != BSL_PARAM_TYPE_OCTETS ||
if (PARAMISNULLLENIS0(n) || PARAMISNULLLENIS0(d) || n->valueType != BSL_PARAM_TYPE_OCTETS ||
d->valueType != BSL_PARAM_TYPE_OCTETS) {
return CRYPT_NULL_INPUT;
}
tls/alert/src/alert.c
+3
View File
@@ -115,6 +115,9 @@ int32_t ALERT_Flush(TLS_Ctx *ctx)
/** obtain the alert level */
data[0] = alertCtx->level;
data[1] = alertCtx->description;
if (ctx->negotiatedInfo.version == HITLS_VERSION_SSL30 && alertCtx->description == ALERT_PROTOCOL_VERSION) {
data[1] = ALERT_HANDSHAKE_FAILURE;
}
/** write the record */
ret = REC_Write(ctx, REC_TYPE_ALERT, data, ALERT_DATA_LEN);
if (ret != HITLS_SUCCESS) {
tls/config/src/config_default.c
+1 -1
View File
@@ -191,7 +191,7 @@ static void InitConfig(HITLS_Config *config)
config->needCheckKeyUsage = true;
#endif
#ifdef HITLS_TLS_CONFIG_MANUAL_DH
config->isSupportDhAuto = (config->maxVersion == HITLS_VERSION_TLCP_DTLCP11) ? false : true;
config->isSupportDhAuto = false;
#endif
if (config->maxVersion == HITLS_VERSION_TLCP_DTLCP11) {
config->isSupportExtendMasterSecret = false;
tls/config/src/config_sign.c
+8 -4
View File
@@ -420,25 +420,29 @@ static int32_t ProcessOids(TLS_SigSchemeInfo *scheme, BslOidInfo *keyTypeOidInfo
{
int32_t ret = HITLS_SUCCESS;
if (keyTypeOidInfo != NULL && keyTypeOidInfo->oidStr.octs != NULL) {
ret = BSL_OBJ_Create(&keyTypeOidInfo->oidStr, keyTypeOidInfo->oidName, scheme->keyType);
ret = BSL_OBJ_Create(keyTypeOidInfo->oidStr.octs, keyTypeOidInfo->oidStr.octetLen,
keyTypeOidInfo->oidName, scheme->keyType);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
if (paraOidInfo != NULL && paraOidInfo->oidStr.octs != NULL) {
ret = BSL_OBJ_Create(&paraOidInfo->oidStr, paraOidInfo->oidName, scheme->paraId);
ret = BSL_OBJ_Create(paraOidInfo->oidStr.octs, paraOidInfo->oidStr.octetLen,
paraOidInfo->oidName, scheme->paraId);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
if (hashOidInfo != NULL && hashOidInfo->oidStr.octs != NULL) {
ret = BSL_OBJ_Create(&hashOidInfo->oidStr, hashOidInfo->oidName, scheme->hashAlgId);
ret = BSL_OBJ_Create(hashOidInfo->oidStr.octs, hashOidInfo->oidStr.octetLen,
hashOidInfo->oidName, scheme->hashAlgId);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
if (signHashAlgOidInfo != NULL && signHashAlgOidInfo->oidStr.octs != NULL) {
ret = BSL_OBJ_Create(&signHashAlgOidInfo->oidStr, signHashAlgOidInfo->oidName, scheme->signHashAlgId);
ret = BSL_OBJ_Create(signHashAlgOidInfo->oidStr.octs, signHashAlgOidInfo->oidStr.octetLen,
signHashAlgOidInfo->oidName, scheme->signHashAlgId);
if (ret != HITLS_SUCCESS) {
return ret;
}
tls/handshake/common/src/hs_common.c
+1 -1
View File
@@ -131,7 +131,7 @@ static const char *g_stateMachineStr[] = {
const char *HS_GetStateStr(uint32_t state)
{
/** The handshake status is abnormal. */
if (state > TRY_RECV_HELLO_REQUEST) {
if ((state >= (sizeof(g_stateMachineStr) / sizeof(char *))) || (g_stateMachineStr[state] == NULL)) {
return "unknown";
}
tls/handshake/include/hs.h
+3
View File
@@ -132,6 +132,9 @@ int32_t HS_CheckAndProcess2MslTimeout(TLS_Ctx *ctx);
int32_t HS_CheckPostHandshakeAuth(TLS_Ctx *ctx);
#define TLS_IS_FIRST_HANDSHAKE(ctx) ((ctx)->negotiatedInfo.clientVerifyDataSize == 0 \
|| (ctx)->negotiatedInfo.serverVerifyDataSize == 0)
#ifdef __cplusplus
}
#endif
tls/handshake/recv/src/recv_client_hello.c
+6
View File
@@ -443,6 +443,9 @@ static int32_t ServerSelectNegoVersion(TLS_Ctx *ctx, const ClientHelloMsg *clien
!IS_SUPPORT_TLCP(ctx->config.tlsConfig.originVersionMask)) {
if (legacyVersion > ctx->config.tlsConfig.minVersion) {
/** The DTLS version supported by the client is too early and the negotiation cannot be continued */
if (TLS_IS_FIRST_HANDSHAKE(ctx)) {
ctx->negotiatedInfo.version = legacyVersion;
}
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_UNSUPPORT_VERSION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15223, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"client want a unsupported protocol version 0x%02x.", legacyVersion, 0, 0, 0);
@@ -460,6 +463,9 @@ static int32_t ServerSelectNegoVersion(TLS_Ctx *ctx, const ClientHelloMsg *clien
}
} else {
if (legacyVersion < ctx->config.tlsConfig.minVersion) {
if (TLS_IS_FIRST_HANDSHAKE(ctx)) {
ctx->negotiatedInfo.version = legacyVersion;
}
/* The TLS version supported by the client is too early and cannot be negotiated */
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_UNSUPPORT_VERSION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15225, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,