code stringlengths 1 1.05M | repo_name stringlengths 6 83 | path stringlengths 3 242 | language stringclasses 222 values | license stringclasses 20 values | size int64 1 1.05M |
|---|---|---|---|---|---|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_CFB)
#include "bsl_err_internal.h"
#include "crypt_sm4.h"
#include "crypt_errno.h"
#include "crypt_modes_cfb.h"
#include "modes_local.h"
#include "securec.h"
int32_t MODE_SM4_CFB_Encrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (ctx->feedbackBits == 128) { // feedbackBits value of 128 has assembly optimizations
return CRYPT_SM4_CFB_Encrypt(ctx->modeCtx.ciphCtx, in, out, len, ctx->modeCtx.iv, &ctx->modeCtx.offset);
} else { // no assembly optimization
return MODES_CFB_Encrypt(ctx, in, out, len);
}
}
int32_t MODE_SM4_CFB_Decrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (ctx->feedbackBits == 128) { // feedbackBits value of 128 has assembly optimizations
return CRYPT_SM4_CFB_Decrypt(ctx->modeCtx.ciphCtx, in, out, len, ctx->modeCtx.iv, &ctx->modeCtx.offset);
} else { // no assembly optimization
return MODES_CFB_Decrypt(ctx, in, out, len);
}
}
int32_t SM4_CFB_InitCtx(MODES_CFB_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
int32_t ret;
if (ivLen != modeCtx->cfbCtx.modeCtx.blockSize) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_IVLEN_ERROR);
return CRYPT_MODES_IVLEN_ERROR;
}
ret = CRYPT_SM4_SetEncryptKey(modeCtx->cfbCtx.modeCtx.ciphCtx, key, keyLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
(void)memcpy_s(modeCtx->cfbCtx.modeCtx.iv, MODES_MAX_IV_LENGTH, iv, ivLen);
modeCtx->enc = enc;
return ret;
}
int32_t SM4_CFB_Update(MODES_CFB_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(modeCtx->enc ? MODE_SM4_CFB_Encrypt : MODE_SM4_CFB_Decrypt, &modeCtx->cfbCtx,
in, inLen, out, outLen);
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/asm_sm4_cfb.c | C | unknown | 2,720 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_CTR)
#include "bsl_err_internal.h"
#include "crypt_sm4.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "crypt_modes_ctr.h"
#include "modes_local.h"
int32_t MODE_SM4_CTR_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
// ctx, in, and out pointers have been determined at the EAL layer and will not be determined again
if (len == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
uint32_t offset = MODES_CTR_LastHandle(ctx, in, out, len);
uint32_t left = len - offset;
const uint8_t *tmpIn = in + offset;
uint8_t *tmpOut = out + offset;
uint32_t blockSize = ctx->blockSize; // ctr supports only 16-byte block size
uint32_t blocks, beCtr32;
while (left >= blockSize) {
blocks = left >> 4; // Shift rightwards by 4 bytes to obtain the number of blocks.
beCtr32 = GET_UINT32_BE(ctx->iv, 12); // offset of 12 bytes to obtain the IV in lower 32 bits
beCtr32 += blocks;
if (beCtr32 < blocks) {
blocks -= beCtr32;
beCtr32 = 0;
}
// Shift leftwards by 4 bytes to obtain the length of the data involved in the calculation.
uint32_t calLen = blocks << 4;
(void)CRYPT_SM4_CTR_Encrypt(ctx->ciphCtx, tmpIn, tmpOut, calLen / ctx->blockSize, ctx->iv);
left -= calLen;
tmpIn += calLen;
tmpOut += calLen;
if (beCtr32 == 0) {
// 16 - 4, The lower 32 bits are carried, and the upper 12 bytes are increased by 1.
MODE_IncCounter(ctx->iv, blockSize - 4);
}
}
MODES_CTR_RemHandle(ctx, tmpIn, tmpOut, left);
return CRYPT_SUCCESS;
}
int32_t SM4_CTR_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_CipherInitCtx(modeCtx, MODES_SM4_SetEncryptKey, &modeCtx->commonCtx, key, keyLen, iv, ivLen, enc);
}
int32_t SM4_CTR_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(MODE_SM4_CTR_Encrypt, &modeCtx->commonCtx, in, inLen, out, outLen);
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/asm_sm4_ctr.c | C | unknown | 2,951 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_ECB)
#include "bsl_err_internal.h"
#include "crypt_sm4.h"
#include "crypt_errno.h"
#include "crypt_modes_ecb.h"
#include "modes_local.h"
int32_t MODE_SM4_ECB_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return CRYPT_SM4_ECB_Encrypt(ctx->ciphCtx, in, out, len);
}
int32_t MODE_SM4_ECB_Decrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return CRYPT_SM4_ECB_Decrypt(ctx->ciphCtx, in, out, len);
}
int32_t SM4_ECB_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
(void) iv;
(void) ivLen;
int32_t ret = enc ? MODES_SM4_SetEncryptKey(&modeCtx->commonCtx, key, keyLen) :
MODES_SM4_SetDecryptKey(&modeCtx->commonCtx, key, keyLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
modeCtx->enc = enc;
return ret;
}
int32_t SM4_ECB_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherUpdate(modeCtx, modeCtx->enc ? MODE_SM4_ECB_Encrypt : MODE_SM4_ECB_Decrypt,
in, inLen, out, outLen);
}
int32_t SM4_ECB_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherFinal(modeCtx, modeCtx->enc ? MODE_SM4_ECB_Encrypt : MODE_SM4_ECB_Decrypt, out, outLen);
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/asm_sm4_ecb.c | C | unknown | 2,290 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_GCM)
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "crypt_sm4.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "modes_local.h"
#include "crypt_modes_gcm.h"
int32_t MODES_SM4_GCM_SetKey(MODES_CipherGCMCtx *ctx, const uint8_t *key, uint32_t len)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
uint8_t gcmKey[GCM_BLOCKSIZE] = { 0 };
int32_t ret = CRYPT_SM4_SetEncryptKey(ctx->ciphCtx, key, len);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, gcmKey, gcmKey, GCM_BLOCKSIZE);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
GcmTableGen4bit(gcmKey, ctx->hTable);
ctx->tagLen = 16; // The default tag length is 128 bits, that is, 16 bytes.
BSL_SAL_CleanseData(gcmKey, sizeof(gcmKey));
return CRYPT_SUCCESS;
}
static void GcmRemHandle(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc)
{
(void)ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->iv, ctx->last, GCM_BLOCKSIZE);
uint32_t i;
if (enc) {
for (i = 0; i < len; i++) {
out[i] = in[i] ^ ctx->last[i];
ctx->remCt[i] = out[i];
}
} else {
for (i = 0; i < len; i++) {
ctx->remCt[i] = in[i];
out[i] = in[i] ^ ctx->last[i];
}
}
uint32_t ctr = GET_UINT32_BE(ctx->iv, 12); // offset 12 bytes and obtain the last four bytes
ctr++;
PUT_UINT32_BE(ctr, ctx->iv, 12); // offset 12 bytes and obtain the last four bytes
ctx->lastLen = GCM_BLOCKSIZE - len;
}
int32_t MODES_SM4_GCM_EncryptBlock(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
ctx->plaintextLen += len;
uint32_t lastLen = MODES_GCM_LastHandle(ctx, in, out, len, true);
// Data processing is complete. Exit.
if (lastLen == len) {
return CRYPT_SUCCESS;
}
const uint8_t *tmpIn = in + lastLen;
uint8_t *tmpOut = out + lastLen;
uint32_t clen = len - lastLen;
if (clen >= GCM_BLOCKSIZE) {
uint32_t calLen = clen & 0xfffffff0;
(void)CRYPT_SM4_CTR_Encrypt(ctx->ciphCtx, tmpIn, tmpOut, calLen / GCM_BLOCKSIZE, ctx->iv);
GcmHashMultiBlock(ctx->ghash, ctx->hTable, tmpOut, calLen);
clen -= calLen;
tmpIn += calLen;
tmpOut += calLen;
}
if (clen > 0) { // tail processing
GcmRemHandle(ctx, tmpIn, tmpOut, clen, true);
}
return CRYPT_SUCCESS;
}
int32_t MODES_SM4_GCM_DecryptBlock(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
ctx->plaintextLen += len;
uint32_t lastLen = MODES_GCM_LastHandle(ctx, in, out, len, false);
// Data processing is complete. Exit.
if (lastLen == len) {
return CRYPT_SUCCESS;
}
const uint8_t *tmpIn = in + lastLen;
uint8_t *tmpOut = out + lastLen;
uint32_t clen = len - lastLen;
if (clen >= GCM_BLOCKSIZE) {
uint32_t calLen = clen & 0xfffffff0; // Obtains the length that is an integer multiple of 16 bytes.
GcmHashMultiBlock(ctx->ghash, ctx->hTable, tmpIn, calLen);
(void)CRYPT_SM4_CTR_Encrypt(ctx->ciphCtx, tmpIn, tmpOut, calLen / GCM_BLOCKSIZE, ctx->iv);
tmpIn += calLen;
tmpOut += calLen;
clen -= calLen;
}
if (clen > 0) { // tail processing
GcmRemHandle(ctx, tmpIn, tmpOut, clen, false);
}
return CRYPT_SUCCESS;
}
int32_t SM4_GCM_InitCtx(MODES_GCM_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
int32_t ret = MODES_SM4_GCM_SetKey(&modeCtx->gcmCtx, key, keyLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = MODES_GCM_SetIv(&modeCtx->gcmCtx, iv, ivLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
(void)MODES_GCM_DeInitCtx(modeCtx);
return ret;
}
modeCtx->enc = enc;
return ret;
}
int32_t SM4_GCM_Update(MODES_GCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(modeCtx->enc ? MODES_SM4_GCM_EncryptBlock : MODES_SM4_GCM_DecryptBlock,
&modeCtx->gcmCtx, in, inLen, out, outLen);
}
#endif
| 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/asm_sm4_gcm.c | C | unknown | 4,963 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_OFB)
#include "crypt_modes_ofb.h"
int32_t SM4_OFB_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_OFB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
int32_t SM4_OFB_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_OFB_Update(modeCtx, in, inLen, out, outLen);
}
#endif
| 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/asm_sm4_ofb_armv8.c | C | unknown | 1,058 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_OFB)
#include "bsl_err_internal.h"
#include "crypt_sm4.h"
#include "crypt_errno.h"
#include "crypt_modes_ofb.h"
#include "modes_local.h"
int32_t MODE_SM4_OFB_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return CRYPT_SM4_OFB_Encrypt(ctx->ciphCtx, in, out, len, ctx->iv, &ctx->offset);
}
int32_t MODE_SM4_OFB_Decrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return CRYPT_SM4_OFB_Decrypt(ctx->ciphCtx, in, out, len, ctx->iv, &ctx->offset);
}
int32_t SM4_OFB_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
void *setKey = MODES_SM4_SetEncryptKey;
return MODES_CipherInitCtx(modeCtx, setKey, &modeCtx->commonCtx, key, keyLen, iv, ivLen, enc);
}
int32_t SM4_OFB_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(modeCtx->enc ? MODE_SM4_OFB_Encrypt : MODE_SM4_OFB_Decrypt, &modeCtx->commonCtx,
in, inLen, out, outLen);
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/asm_sm4_ofb_x86_64.c | C | unknown | 1,985 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_SM4
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "crypt_sm4.h"
#include "modes_local.h"
int32_t MODES_SM4_SetEncryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint32_t len)
{
return CRYPT_SM4_SetEncryptKey(ctx->ciphCtx, key, len);
}
int32_t MODES_SM4_SetDecryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint32_t len)
{
return CRYPT_SM4_SetDecryptKey(ctx->ciphCtx, key, len);
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/asm_sm4_setkey.c | C | unknown | 1,046 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_XTS)
#include "bsl_err_internal.h"
#include "crypt_sm4.h"
#include "crypt_errno.h"
#include "modes_local.h"
#include "crypt_modes_xts.h"
int32_t MODES_SM4_XTS_Encrypt(MODES_CipherXTSCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
return CRYPT_SM4_XTS_Encrypt(ctx->ciphCtx, in, out, len, ctx->tweak);
}
int32_t MODES_SM4_XTS_Decrypt(MODES_CipherXTSCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return CRYPT_SM4_XTS_Decrypt(ctx->ciphCtx, in, out, len, ctx->tweak);
}
int32_t SM4_XTS_Update(MODES_XTS_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(modeCtx->enc ? MODES_SM4_XTS_Encrypt : MODES_SM4_XTS_Decrypt, &modeCtx->xtsCtx,
in, inLen, out, outLen);
}
int32_t SM4_XTS_InitCtx(MODES_XTS_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
int32_t ret;
if (key == NULL || iv == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (enc) {
ret = CRYPT_SM4_XTS_SetEncryptKey(modeCtx->xtsCtx.ciphCtx, key, keyLen);
} else {
ret = CRYPT_SM4_XTS_SetDecryptKey(modeCtx->xtsCtx.ciphCtx, key, keyLen);
}
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = MODES_XTS_SetIv(&modeCtx->xtsCtx, iv, ivLen);
if (ret != CRYPT_SUCCESS) {
(void)MODES_XTS_DeInitCtx(modeCtx);
return ret;
}
modeCtx->enc = enc;
return ret;
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/asm_sm4_xts.c | C | unknown | 2,373 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CCM_CORE_H
#define CCM_CORE_H
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CCM
#include "crypt_modes_ccm.h"
#include "modes_local.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
typedef int32_t (*CcmCore)(MODES_CipherCCMCtx *, const uint8_t *, uint8_t *, uint32_t, bool);
int32_t CcmCrypt(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc, const CcmCore func);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/ccm_core.h | C | unknown | 1,018 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef GHASH_CORE_H
#define GHASH_CORE_H
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_GCM
#include "crypt_modes_gcm.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
void GcmTableGen4bitAsm(const MODES_GCM_GF128 *H, MODES_GCM_GF128 hTable[16]);
void GcmMultH4bitAsm(uint8_t t[GCM_BLOCKSIZE], const MODES_GCM_GF128 hTable[16]);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/ghash_core.h | C | unknown | 940 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_MODES
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "crypt_errno.h"
#include "modes_local.h"
#ifdef HITLS_CRYPTO_CTR
#include "crypt_modes_ctr.h"
#endif
#ifdef HITLS_CRYPTO_CBC
#include "crypt_modes_cbc.h"
#endif
#ifdef HITLS_CRYPTO_ECB
#include "crypt_modes_ecb.h"
#endif
#ifdef HITLS_CRYPTO_GCM
#include "crypt_modes_gcm.h"
#endif
#ifdef HITLS_CRYPTO_CCM
#include "crypt_modes_ccm.h"
#endif
#ifdef HITLS_CRYPTO_XTS
#include "crypt_modes_xts.h"
#endif
#if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
#include "crypt_modes_chacha20poly1305.h"
#endif
#ifdef HITLS_CRYPTO_CFB
#include "crypt_modes_cfb.h"
#endif
#ifdef HITLS_CRYPTO_OFB
#include "crypt_modes_ofb.h"
#endif
#ifdef HITLS_CRYPTO_WRAP
#include "crypt_modes_aes_wrap.h"
#endif
int32_t MODE_NewCtxInternal(MODES_CipherCtx *ctx, const EAL_SymMethod *method)
{
ctx->commonCtx.ciphCtx = BSL_SAL_Calloc(1, method->ctxSize);
if (ctx->commonCtx.ciphCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
// block mode blockSize equal symm blockSize
ctx->commonCtx.blockSize = method->blockSize;
ctx->commonCtx.ciphMeth = method;
ctx->commonCtx.offset = 0;
return CRYPT_SUCCESS;
}
MODES_CipherCtx *MODES_CipherNewCtx(int32_t algId)
{
const EAL_SymMethod *method = EAL_GetSymMethod(algId);
if (method == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return NULL;
}
MODES_CipherCtx *ctx = BSL_SAL_Calloc(1, sizeof(MODES_CipherCtx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return ctx;
}
ctx->algId = algId;
int32_t ret = MODE_NewCtxInternal(ctx, method);
if (ret != CRYPT_SUCCESS) {
BSL_SAL_Free(ctx);
return NULL;
}
return ctx;
}
int32_t MODES_CipherInitCommonCtx(MODES_CipherCommonCtx *modeCtx, void *setSymKey, void *keyCtx,
const uint8_t *key, uint32_t keyLen, const uint8_t *iv, uint32_t ivLen)
{
int32_t ret;
if (modeCtx->ciphMeth == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (iv == NULL && ivLen > 0) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
ret = ((SetKey)setSymKey)(keyCtx, key, keyLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = MODES_SetIv(modeCtx, iv, ivLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
return CRYPT_SUCCESS;
}
int32_t MODES_CipherInitCtx(MODES_CipherCtx *ctx, void *setSymKey, void *keyCtx, const uint8_t *key, uint32_t keyLen,
const uint8_t *iv, uint32_t ivLen, bool enc)
{
ctx->enc = enc;
return MODES_CipherInitCommonCtx(&ctx->commonCtx, setSymKey, keyCtx, key, keyLen, iv, ivLen);
}
int32_t MODE_CheckUpdateParam(uint8_t blockSize, uint32_t cacheLen, uint32_t inLen, uint32_t *outLen)
{
if (inLen + cacheLen < inLen) { // Integer flipping
BSL_ERR_PUSH_ERROR(CRYPT_EAL_BUFF_LEN_TOO_LONG);
return CRYPT_EAL_BUFF_LEN_TOO_LONG;
}
if ((*outLen) < ((inLen + cacheLen) / blockSize * blockSize)) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_BUFF_LEN_NOT_ENOUGH);
return CRYPT_EAL_BUFF_LEN_NOT_ENOUGH;
}
return CRYPT_SUCCESS;
}
static bool IfXts(CRYPT_CIPHER_AlgId id)
{
return id == CRYPT_CIPHER_AES128_XTS || id == CRYPT_CIPHER_AES256_XTS || id == CRYPT_CIPHER_SM4_XTS;
}
static int32_t UnPaddingISO7816(const uint8_t *pad, uint32_t padLen, uint32_t *finLen)
{
const uint8_t *p = pad;
uint32_t len = padLen - 1;
while (*(p + len) == 0 && len > 0) {
len--;
}
len = (*(p + len) == 0x80) ? len : padLen;
if (len == padLen) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_CIPHER_DATA_ERROR);
return CRYPT_EAL_CIPHER_DATA_ERROR;
}
(*finLen) = len;
return CRYPT_SUCCESS;
}
static int32_t UnPaddingX923(const uint8_t *pad, uint32_t padLen, uint32_t *finLen)
{
uint32_t len, pos, i;
uint32_t check = 0;
len = pad[padLen - 1];
check |= (uint32_t)(len > padLen);
pos = padLen - len;
for (i = 0; i < padLen - 1; i++) {
check |= (pad[i] * (uint32_t)(i >= pos));
}
if (check != 0) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_CIPHER_DATA_ERROR);
return CRYPT_EAL_CIPHER_DATA_ERROR;
}
(*finLen) = padLen - len;
return CRYPT_SUCCESS;
}
static int32_t UnPaddingPkcs(const uint8_t *pad, uint32_t padLen, uint32_t *finLen)
{
uint32_t len, pos, i;
uint32_t check = 0;
len = pad[padLen - 1];
check |= (uint32_t)((len == 0) || (len > padLen));
pos = padLen - len;
for (i = 0; i < padLen; i++) {
check |= ((pad[i] ^ len) * (uint32_t)(i >= pos));
}
if (check != 0) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_CIPHER_DATA_ERROR);
return CRYPT_EAL_CIPHER_DATA_ERROR;
}
(*finLen) = padLen - len;
return CRYPT_SUCCESS;
}
int32_t MODES_BlockUnPadding(int32_t padding, const uint8_t *pad, uint32_t padLen, uint32_t *dataLen)
{
int32_t ret = 0;
uint32_t len = *dataLen;
switch (padding) {
case CRYPT_PADDING_ISO7816:
ret = UnPaddingISO7816(pad, padLen, &len);
break;
case CRYPT_PADDING_X923:
ret = UnPaddingX923(pad, padLen, &len);
break;
case CRYPT_PADDING_PKCS5:
case CRYPT_PADDING_PKCS7:
ret = UnPaddingPkcs(pad, padLen, &len);
break;
default:
break;
}
*dataLen = len;
return ret;
}
int32_t MODES_BlockPadding(int32_t algId, int32_t padding, uint8_t blockSize, uint8_t *data, uint8_t *dataLen)
{
uint8_t tempLen = *dataLen;
uint8_t *pad = data + tempLen;
uint8_t padLen = blockSize - tempLen;
uint8_t i;
*dataLen += padLen;
switch (padding) {
case CRYPT_PADDING_NONE:
*dataLen = tempLen;
if (tempLen % blockSize != 0) {
return IfXts(algId) ? CRYPT_SUCCESS : CRYPT_MODE_ERR_INPUT_LEN;
}
break;
case CRYPT_PADDING_ZEROS:
for (i = 0; i < padLen; i++) {
pad[i] = 0x00L;
}
break;
case CRYPT_PADDING_ISO7816:
pad[0] = 0x80;
for (i = 1; i < padLen; i++) {
pad[i] = 0x00L;
}
break;
case CRYPT_PADDING_X923:
for (i = 0; i < padLen - 1; i++) {
pad[i] = 0x00L;
}
pad[padLen - 1] = padLen;
break;
case CRYPT_PADDING_PKCS5:
case CRYPT_PADDING_PKCS7:
for (i = 0; i < padLen; i++) {
pad[i] = padLen;
}
break;
default:
*dataLen = tempLen;
return CRYPT_INVALID_ARG;
}
return CRYPT_SUCCESS;
}
int32_t MODES_CipherUpdateCache(MODES_CipherCtx *ctx, void *blockUpdate, const uint8_t **in, uint32_t *inLen,
uint8_t **out, uint32_t *outLen)
{
int32_t ret;
uint8_t blockSize = ctx->commonCtx.blockSize;
// Process the cache. If there is cached data, the cache data is padded into a block first.
if (ctx->dataLen > 0) {
uint8_t padding = blockSize - ctx->dataLen;
padding = (*inLen) > (padding) ? padding : (uint8_t)(*inLen);
if (padding != 0) {
(void)memcpy_s(ctx->data + ctx->dataLen, (EAL_MAX_BLOCK_LENGTH - ctx->dataLen), (*in), padding);
(*inLen) -= padding;
(*in) += padding;
ctx->dataLen += padding;
}
}
// No block is formed, return.
if (ctx->dataLen != blockSize) {
return CRYPT_SUCCESS;
}
// If the block is padded, perform operations on this block first.
if (ctx->enc) {
ret = ((EncryptBlock)blockUpdate)(&ctx->commonCtx, ctx->data, *out, blockSize);
} else {
// If it's decryption and the cached data + input data is equal to blockSize,
// may be it's the last piece of data with padding, the data is cached in the ctx and left for final processing.
if ((*inLen) == 0 && (ctx->pad != CRYPT_PADDING_NONE)) {
(*outLen) = 0;
return CRYPT_SUCCESS;
}
ret = ((DecryptBlock)blockUpdate)(&ctx->commonCtx, ctx->data, *out, blockSize);
}
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ctx->dataLen = 0;
(*outLen) = blockSize;
(*out) += blockSize;
return CRYPT_SUCCESS;
}
int32_t MODES_CipherFinal(MODES_CipherCtx *modeCtx, void *blockUpdate, uint8_t *out, uint32_t *outLen)
{
int32_t ret;
uint32_t outLenTemp;
if (out == NULL || outLen == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (modeCtx->pad != CRYPT_PADDING_NONE && (*outLen) < modeCtx->commonCtx.blockSize) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_BUFF_LEN_NOT_ENOUGH);
return CRYPT_EAL_BUFF_LEN_NOT_ENOUGH;
}
if (modeCtx->enc) {
ret = MODES_BlockPadding(modeCtx->algId, modeCtx->pad,
modeCtx->commonCtx.blockSize, modeCtx->data, &modeCtx->dataLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
if (modeCtx->dataLen == 0) {
*outLen = modeCtx->dataLen;
return CRYPT_SUCCESS;
}
ret = ((EncryptBlock)blockUpdate)(&modeCtx->commonCtx, modeCtx->data, out, modeCtx->dataLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
*outLen = modeCtx->dataLen;
} else {
if (modeCtx->dataLen == 0) {
*outLen = modeCtx->dataLen;
return CRYPT_SUCCESS;
}
ret = ((DecryptBlock)blockUpdate)(&modeCtx->commonCtx, modeCtx->data, out, modeCtx->dataLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
outLenTemp = modeCtx->dataLen;
ret = MODES_BlockUnPadding(modeCtx->pad, out, modeCtx->commonCtx.blockSize, &outLenTemp);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
*outLen = outLenTemp;
}
modeCtx->dataLen = 0;
return ret;
}
int32_t MODES_CipherUpdate(MODES_CipherCtx *modeCtx, void *blockUpdate, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
int32_t ret;
uint32_t tmpLen = inLen;
const uint8_t *tmpIn = in;
uint8_t *tmpOut = (uint8_t *)out;
ret = MODE_CheckUpdateParam(modeCtx->commonCtx.blockSize, modeCtx->dataLen, inLen, outLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
*outLen = 0;
ret = MODES_CipherUpdateCache(modeCtx, blockUpdate, &tmpIn, &tmpLen, &tmpOut, outLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
if (tmpLen == 0) {
return CRYPT_SUCCESS;
}
uint8_t left = tmpLen % modeCtx->commonCtx.blockSize;
uint32_t len = tmpLen - left;
if (len > 0) {
if (modeCtx->enc) {
ret = ((EncryptBlock)blockUpdate)(&modeCtx->commonCtx, tmpIn, tmpOut, len);
} else {
// If it's decryption and the cached data + input data is equal to blockSize,
// may be it's the last piece of data with padding, the data is cached in the ctx and left for final processing.
if ((modeCtx->pad != CRYPT_PADDING_NONE) && left == 0) {
left = modeCtx->commonCtx.blockSize;
len -= modeCtx->commonCtx.blockSize;
}
if (len > 0) {
ret = ((DecryptBlock)blockUpdate)(&modeCtx->commonCtx, tmpIn, tmpOut, len);
}
}
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
}
// Process the new cache.
if (left > 0) {
(void)memcpy_s(modeCtx->data, modeCtx->commonCtx.blockSize, tmpIn + len, left);
modeCtx->dataLen = left;
}
// The encryption/decryption is successful. OutLen is updated.
(*outLen) += len;
return CRYPT_SUCCESS;
}
void MODES_Clean(MODES_CipherCommonCtx *ctx)
{
if (ctx == NULL) {
return;
}
BSL_SAL_CleanseData((void *)(ctx->buf), MODES_MAX_BUF_LENGTH);
BSL_SAL_CleanseData((void *)(ctx->iv), MODES_MAX_IV_LENGTH);
ctx->ciphMeth->cipherDeInitCtx(ctx->ciphCtx);
ctx->offset = 0;
ctx->ivIndex = 0;
}
int32_t MODES_CipherDeInitCtx(MODES_CipherCtx *modeCtx)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
(void)memset_s(modeCtx->data, EAL_MAX_BLOCK_LENGTH, 0, EAL_MAX_BLOCK_LENGTH);
modeCtx->dataLen = 0;
modeCtx->pad = CRYPT_PADDING_NONE;
MODES_Clean(&modeCtx->commonCtx);
return CRYPT_SUCCESS;
}
void MODES_CipherFreeCtx(MODES_CipherCtx *modeCtx)
{
if (modeCtx == NULL) {
return;
}
(void)MODES_CipherDeInitCtx(modeCtx);
BSL_SAL_FREE(modeCtx->commonCtx.ciphCtx);
BSL_SAL_Free(modeCtx);
}
int32_t MODES_SetIv(MODES_CipherCommonCtx *ctx, const uint8_t *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len != ctx->blockSize) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_IVLEN_ERROR);
return CRYPT_MODES_IVLEN_ERROR;
}
if (memcpy_s(ctx->iv, MODES_MAX_IV_LENGTH, val, len) != EOK) {
BSL_ERR_PUSH_ERROR(CRYPT_SECUREC_FAIL);
return CRYPT_SECUREC_FAIL;
}
ctx->offset = 0; // If the IV value is changed, the original offset is useless.
ctx->ivIndex = 0;
return CRYPT_SUCCESS;
}
int32_t MODES_GetIv(MODES_CipherCommonCtx *ctx, uint8_t *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
uint32_t ivLen = ctx->blockSize;
if (len != ivLen) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
(void)memcpy_s(val, len, ctx->iv, ivLen);
return CRYPT_SUCCESS;
}
int32_t MODES_CipherCtrl(MODES_CipherCtx *ctx, int32_t opt, void *val, uint32_t len)
{
switch (opt) {
case CRYPT_CTRL_REINIT_STATUS:
(void)memset_s(ctx->data, EAL_MAX_BLOCK_LENGTH, 0, EAL_MAX_BLOCK_LENGTH);
ctx->dataLen = 0;
ctx->pad = CRYPT_PADDING_NONE;
return MODES_SetIv(&ctx->commonCtx, val, len);
case CRYPT_CTRL_GET_IV:
return MODES_GetIv(&ctx->commonCtx, (uint8_t *)val, len);
default:
if (ctx->commonCtx.ciphMeth == NULL ||
ctx->commonCtx.ciphMeth->cipherCtrl == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_TYPE_ERROR);
return CRYPT_MODES_CTRL_TYPE_ERROR;
}
return ctx->commonCtx.ciphMeth->cipherCtrl(ctx->commonCtx.ciphCtx, opt, val, len);
}
}
int32_t MODES_CipherStreamProcess(void *processFuncs, void *ctx, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
int32_t ret;
if (inLen == 0) {
*outLen = 0;
return CRYPT_SUCCESS;
}
if (inLen > *outLen) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_BUFF_LEN_NOT_ENOUGH);
return CRYPT_MODE_BUFF_LEN_NOT_ENOUGH;
}
ret = ((CipherStreamProcess)(processFuncs))(ctx, in, out, inLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
*outLen = inLen;
return CRYPT_SUCCESS;
}
// Note that CRYPT_PADDING_ZEROS cannot restore the plaintext length.
// If uses it, need to maintain the length themselves
int32_t MODES_SetPaddingCheck(int32_t pad)
{
if (pad >= CRYPT_PADDING_MAX_COUNT || pad < CRYPT_PADDING_NONE) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_PADDING_NOT_SUPPORT);
return CRYPT_MODES_PADDING_NOT_SUPPORT;
}
return CRYPT_SUCCESS;
}
int32_t MODES_SetEncryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint32_t len)
{
// The ctx and key have been checked at the EAL layer and will not be checked again here.
// The keyMethod will support registration in the future. Therefore, this check is added.
if (ctx == NULL || ctx->ciphMeth == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return ctx->ciphMeth->setEncryptKey(ctx->ciphCtx, key, len);
}
int32_t MODES_SetDecryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint32_t len)
{
// The ctx and key have been checked at the EAL layer and will not be checked again here.
// The keyMethod will support registration in the future. Therefore, this check is added.
if (ctx == NULL || ctx->ciphMeth == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return ctx->ciphMeth->setDecryptKey(ctx->ciphCtx, key, len);
}
#endif // HITLS_CRYPTO_MODES
| 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/modes.c | C | unknown | 17,606 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CBC
#include "securec.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "crypt_modes_cbc.h"
#include "modes_local.h"
#define CBC_UPDATE_VALUES(l, i, o, len) \
do { \
(l) -= (len); \
(i) += (len); \
(o) += (len); \
} while (false)
int32_t MODES_CBC_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
uint32_t blockSize = ctx->blockSize;
int32_t ret;
uint8_t *iv = ctx->iv;
uint8_t *tmp = ctx->buf;
uint32_t left = len;
const uint8_t *input = in;
uint8_t *output = out;
// The ctx, in, and out pointers have been determined at the EAL layer and are not determined again.
if ((left % blockSize) != 0) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
while (left >= blockSize) {
/* Plaintext XOR IV. BlockSize must be an integer multiple of 4 bytes. */
DATA32_XOR(input, iv, tmp, blockSize);
ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, tmp, output, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
/* The current encryption result is used as the next IV value. */
iv = output;
/* Offset length is the size of integer multiple blocks */
CBC_UPDATE_VALUES(left, input, output, blockSize);
}
if (memcpy_s(ctx->iv, MODES_MAX_IV_LENGTH, iv, blockSize) != EOK) {
BSL_ERR_PUSH_ERROR(CRYPT_SECUREC_FAIL);
return CRYPT_SECUREC_FAIL;
}
return CRYPT_SUCCESS;
}
int32_t MODES_CBC_Decrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
const uint8_t *iv = ctx->iv;
uint8_t *tmp = ctx->buf;
uint32_t blockSize = ctx->blockSize;
uint32_t left = len;
uint8_t *output = out;
uint8_t tmpChar;
const uint8_t *input = in;
// The ctx, in, and out pointers have been determined at the EAL layer and are not determined again.
if ((left % blockSize) != 0) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
// In the case where the input and output are at the same address,
// the judgment should be placed outside the while loop. Otherwise, the performance will be affected.
if (in != out) {
while (left >= blockSize) {
int32_t ret = ctx->ciphMeth->decryptBlock(ctx->ciphCtx, input, tmp, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
/* The ciphertext is used as the next IV value. BlockSize must be an integer multiple of 4 bytes. */
DATA32_XOR(iv, tmp, output, blockSize);
iv = input;
CBC_UPDATE_VALUES(left, input, output, blockSize);
}
if (iv != ctx->iv) {
(void)memcpy_s(ctx->iv, MODES_MAX_IV_LENGTH, iv, blockSize);
}
} else {
while (left >= blockSize) {
int32_t ret = ctx->ciphMeth->decryptBlock(ctx->ciphCtx, input, tmp, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
for (uint32_t i = 0; i < blockSize; i++) {
tmpChar = input[i];
output[i] = tmp[i] ^ ctx->iv[i];
ctx->iv[i] = tmpChar;
}
CBC_UPDATE_VALUES(left, input, output, blockSize);
}
}
return CRYPT_SUCCESS;
}
MODES_CipherCtx *MODES_CBC_NewCtx(int32_t algId)
{
return MODES_CipherNewCtx(algId);
}
int32_t MODES_CBC_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
void *setKeyFuncs = enc ? modeCtx->commonCtx.ciphMeth->setEncryptKey : modeCtx->commonCtx.ciphMeth->setDecryptKey;
return MODES_CipherInitCtx(modeCtx, setKeyFuncs, modeCtx->commonCtx.ciphCtx, key, keyLen, iv, ivLen, enc);
}
int32_t MODES_CBC_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherUpdate(modeCtx, modeCtx->enc ? MODES_CBC_Encrypt : MODES_CBC_Decrypt,
in, inLen, out, outLen);
}
int32_t MODES_CBC_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherFinal(modeCtx, modeCtx->enc ? MODES_CBC_Encrypt : MODES_CBC_Decrypt, out, outLen);
}
int32_t MODES_CBC_DeInitCtx(MODES_CipherCtx *modeCtx)
{
return MODES_CipherDeInitCtx(modeCtx);
}
int32_t MODES_CBC_Ctrl(MODES_CipherCtx *modeCtx, int32_t cmd, void *val, uint32_t valLen)
{
int32_t ret;
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (cmd) {
case CRYPT_CTRL_SET_PADDING:
if (val == NULL || valLen != sizeof(int32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
ret = MODES_SetPaddingCheck(*(int32_t *)val);
if (ret != CRYPT_SUCCESS) {
return ret;
}
modeCtx->pad = *(int32_t *)val;
return CRYPT_SUCCESS;
case CRYPT_CTRL_GET_PADDING:
if (val == NULL || valLen != sizeof(int32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
*(int32_t *)val = modeCtx->pad;
return CRYPT_SUCCESS;
case CRYPT_CTRL_GET_BLOCKSIZE:
if (val == NULL || valLen != sizeof(uint32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
*(int32_t *)val = modeCtx->commonCtx.ciphMeth->blockSize;
return CRYPT_SUCCESS;
default:
return MODES_CipherCtrl(modeCtx, cmd, val, valLen);
}
}
void MODES_CBC_FreeCtx(MODES_CipherCtx *modeCtx)
{
MODES_CipherFreeCtx(modeCtx);
}
int32_t MODES_CBC_UpdateEx(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_AES128_CBC:
case CRYPT_CIPHER_AES192_CBC:
case CRYPT_CIPHER_AES256_CBC:
#ifdef HITLS_CRYPTO_AES
return AES_CBC_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
case CRYPT_CIPHER_SM4_CBC:
#ifdef HITLS_CRYPTO_SM4
return SM4_CBC_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_CBC_Update(modeCtx, in, inLen, out, outLen);
}
}
int32_t MODES_CBC_InitCtxEx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, void *param, bool enc)
{
(void)param;
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_SM4_CBC:
#ifdef HITLS_CRYPTO_SM4
return SM4_CBC_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_CBC_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
}
int32_t MODES_CBC_FinalEx(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_AES128_CBC:
case CRYPT_CIPHER_AES192_CBC:
case CRYPT_CIPHER_AES256_CBC:
#ifdef HITLS_CRYPTO_AES
return AES_CBC_Final(modeCtx, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
case CRYPT_CIPHER_SM4_CBC:
#ifdef HITLS_CRYPTO_SM4
return SM4_CBC_Final(modeCtx, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_CBC_Final(modeCtx, out, outLen);
}
}
#endif // HITLS_CRYPTO_CBC
| 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/modes_cbc.c | C | unknown | 8,810 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CCM
#include <stdint.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "modes_local.h"
#include "ccm_core.h"
#include "crypt_modes_ccm.h"
#include "crypt_modes.h"
void XorInEncrypt(XorCryptData *data, uint32_t len)
{
uint32_t i;
for (i = 0; i < len; i++) {
data->tag[i] ^= data->in[i];
data->out[i] = data->in[i] ^ data->ctr[i];
}
}
void XorInEncryptBlock(XorCryptData *data)
{
DATA64_XOR(data->in, data->tag, data->tag, CCM_BLOCKSIZE);
DATA64_XOR(data->in, data->ctr, data->out, CCM_BLOCKSIZE);
}
void XorInDecrypt(XorCryptData *data, uint32_t len)
{
uint32_t i;
// Decryption
for (i = 0; i < len; i++) {
data->out[i] = data->in[i] ^ data->ctr[i];
data->tag[i] ^= data->out[i];
}
}
void XorInDecryptBlock(XorCryptData *data)
{
DATA64_XOR(data->in, data->ctr, data->out, CCM_BLOCKSIZE);
DATA64_XOR(data->out, data->tag, data->tag, CCM_BLOCKSIZE);
}
// Process the remaining data in the last update.
static uint32_t CcmLastHandle(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc)
{
uint32_t lastLen = (ctx->lastLen < len) ? ctx->lastLen : len;
if (ctx->lastLen > 0) {
XorCryptData data;
data.in = in;
data.out = out;
data.ctr = &(ctx->last[CCM_BLOCKSIZE - ctx->lastLen]);
data.tag = &(ctx->tag[CCM_BLOCKSIZE - ctx->lastLen]);
if (enc) {
XorInEncrypt(&data, lastLen);
} else {
XorInDecrypt(&data, lastLen);
}
// Refresh the remaining length.
// The judgment of the function entry ensures that lastLen does not exceed ctx->lastLen,
// and this forcible transition does not occur truncation.
ctx->lastLen -= (uint8_t)lastLen;
}
return lastLen;
}
static void RefreshNonce(MODES_CipherCCMCtx *ctx)
{
if ((ctx->nonce[0] & (~0x07)) != 0) {
/**
* RFC_3610-2.3
* Bit Number Contents
* ---------- ----------------------
* 7 Reserved (always zero)
* 6 Reserved (always zero)
* 5 ... 3 Zero
* 2 ... 0 L'
*/
ctx->nonce[0] &= 0x07;
/**
* RFC_3610-2.3
* Octet Number Contents
* ------------ ---------
* 0 Flags
* 1 ... 15-L Nonce N
* 16-L ... 15 Counter i
*/
uint8_t i;
uint8_t l = ctx->nonce[0] + 1;
for (i = 1; i < l; i++) {
ctx->nonce[CCM_BLOCKSIZE - 1 - i] = 0;
}
/**
* RFC_3610-2.3
* The message is encrypted by XORing the octets of message m with the
* first l(m) octets of the concatenation of S_1, S_2, S_3, ... . Note
* that S_0 is not used to encrypt the message.
*/
ctx->nonce[CCM_BLOCKSIZE - 1] = 1;
}
}
static int32_t TagInit(MODES_CipherCCMCtx *ctx)
{
if (ctx->tagInit == 0) {
int32_t ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->nonce, ctx->tag, CCM_BLOCKSIZE);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ctx->tagInit = 1;
}
return CRYPT_SUCCESS;
}
static int32_t CcmBlocks(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc)
{
XorCryptData data;
data.in = in;
data.out = out;
data.ctr = ctx->last;
data.tag = ctx->tag;
uint8_t countLen = (ctx->nonce[0] & 0x07) + 1;
uint32_t dataLen = len;
void (*xorBlock)(XorCryptData *data) = enc ? XorInEncryptBlock : XorInDecryptBlock;
void (*xor)(XorCryptData *data, uint32_t len) = enc ? XorInEncrypt : XorInDecrypt;
while (dataLen >= CCM_BLOCKSIZE) { // process the integer multiple of 16bytes data
(void)ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->nonce, ctx->last, CCM_BLOCKSIZE);
xorBlock(&data);
(void)ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->tag, ctx->tag, CCM_BLOCKSIZE);
MODE_IncCounter(ctx->nonce + CCM_BLOCKSIZE - countLen, countLen); // counter +1
dataLen -= CCM_BLOCKSIZE;
data.in += CCM_BLOCKSIZE;
data.out += CCM_BLOCKSIZE;
}
if (dataLen > 0) { // process the integer multiple of 16bytes data
(void)ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->nonce, ctx->last, CCM_BLOCKSIZE);
xor(&data, dataLen);
MODE_IncCounter(ctx->nonce + CCM_BLOCKSIZE - countLen, countLen); // counter +1
}
return CRYPT_SUCCESS;
}
// Enc: true for encryption and false for decryption.
int32_t CcmCrypt(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc, const CcmCore func)
{
if (ctx == NULL || ctx->ciphCtx == NULL || in == NULL || out == NULL || len == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len > ctx->msgLen) {
// The message length is exceeded.
BSL_ERR_PUSH_ERROR(CRYPT_MODES_MSGLEN_OVERFLOW);
return CRYPT_MODES_MSGLEN_OVERFLOW;
}
int32_t ret = TagInit(ctx);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
// Determine whether to start encryption and update the nonce information.
RefreshNonce(ctx);
uint32_t lastLen = CcmLastHandle(ctx, in, out, len, enc);
if (lastLen != 0 && ctx->lastLen == 0) {
ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->tag, ctx->tag, CCM_BLOCKSIZE);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
}
// Data processing is complete and exits in advance.
if (lastLen == len) {
ctx->msgLen -= len; // Refresh the remaining length.
return CRYPT_SUCCESS;
}
uint32_t tmpLen = len - lastLen;
ret = func(ctx, in + lastLen, out + lastLen, tmpLen, enc);
if (ret != CRYPT_SUCCESS) {
// Returned by the internal function. No redundant push err is required.
return ret;
}
ctx->lastLen = (CCM_BLOCKSIZE - (tmpLen % CCM_BLOCKSIZE)) % CCM_BLOCKSIZE;
ctx->msgLen -= len; // Refresh the remaining length.
return CRYPT_SUCCESS;
}
int32_t MODES_CCM_Encrypt(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
return CcmCrypt(ctx, in, out, len, true, CcmBlocks);
}
int32_t MODES_CCM_Decrypt(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
return CcmCrypt(ctx, in, out, len, false, CcmBlocks);
}
// 7 <= ivLen <= 13
static int32_t SetIv(MODES_CipherCCMCtx *ctx, const void *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
/**
* RFC_3610-2
* Valid values of L range between 2 octets and 8 octets
*/
// L = 15 - ivLen that is 7 <= ivLen <= 13
if (len < 7 || len > 13) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_IVLEN_ERROR);
return CRYPT_MODES_IVLEN_ERROR;
}
// The previous judgment limits the size of iv to [7, 13]. Therefore, forcible conversion does not cause truncation.
uint8_t l = CCM_BLOCKSIZE - 1 - (uint8_t)len;
// Clear data.
void *ciphCtx = ctx->ciphCtx; // Handle used by the method
const EAL_SymMethod *ciphMeth = ctx->ciphMeth; // algorithm method
uint8_t tagLen = ctx->tagLen;
(void)memset_s(ctx, sizeof(MODES_CipherCCMCtx), 0, sizeof(MODES_CipherCCMCtx));
ctx->ciphCtx = ciphCtx;
ctx->ciphMeth = ciphMeth;
ctx->tagLen = tagLen;
uint8_t m = (ctx->tagLen - 2) / 2; // M' = (M - 2)/2
ctx->nonce[0] = (uint8_t)((l - 1) & 0x7); // set L
ctx->nonce[0] |= (m << 3); // set M. The default value of TagLen is 16bytes. (bit2 bit3 bit4) indicating the tagLen
(void)memcpy_s(ctx->nonce + 1, CCM_BLOCKSIZE - 1, val, len);
return CRYPT_SUCCESS;
}
// The input data is the uint64_t.
static int32_t SetMsgLen(MODES_CipherCCMCtx *ctx, const void *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len != sizeof(uint64_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_MSGLEN_ERROR);
return CRYPT_MODES_CTRL_MSGLEN_ERROR;
}
if ((ctx->nonce[0] & 0x40) != 0) {
// If aad has been set, msgLen cannot be set.
BSL_ERR_PUSH_ERROR(CRYPT_MODES_AAD_IS_SET_ERROR);
return CRYPT_MODES_AAD_IS_SET_ERROR;
}
const uint64_t msgLen = *(const uint64_t *)val;
uint8_t l = (ctx->nonce[0] & 0x7) + 1;
/**
* RFC_3610-7
* octet aligned message of arbitrary length, up to 2^(8*L) octets,
* and octet aligned arbitrary additional authenticated data, up to
* 2^64 octets
*/
if (l < 8 && msgLen >= ((uint64_t)1 << (8 * l))) { // When l is 8, the condition must be met.
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_MSGLEN_ERROR);
return CRYPT_MODES_CTRL_MSGLEN_ERROR;
}
uint8_t i;
/**
* RFC_3610-2.3
* Octet Number Contents
* ------------ ---------
* 0 Flags
* 1 ... 15-L Nonce N
* 16-L ... 15 Counter i
*/
uint8_t bytes[sizeof(uint64_t)];
Uint64ToBeBytes(msgLen, bytes);
for (i = 0; i < l; i++) {
ctx->nonce[CCM_BLOCKSIZE - 1 - i] = bytes[8 - 1 - i]; // 8 bit msgLen information
}
ctx->msgLen = msgLen;
return CRYPT_SUCCESS;
}
static int32_t SetTagLen(MODES_CipherCCMCtx *ctx, const void *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len != sizeof(uint32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_TAGLEN_ERROR);
return CRYPT_MODES_CTRL_TAGLEN_ERROR;
}
if ((ctx->nonce[0] & 0x40) != 0) {
// If aad has been set, tagLen cannot be set.
BSL_ERR_PUSH_ERROR(CRYPT_MODES_AAD_IS_SET_ERROR);
return CRYPT_MODES_AAD_IS_SET_ERROR;
}
/**
* RFC_3610-2
* Valid values are 4, 6, 8, 10, 12, 14, and 16 octets
*/
uint32_t tagLen = *((const uint32_t *)val);
// 4 <= tagLen <= 16 and tagLen is an even number.
if (tagLen > 16 || tagLen < 4 || ((tagLen & 0x01) != 0)) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_TAGLEN_ERROR);
return CRYPT_MODES_CTRL_TAGLEN_ERROR;
}
ctx->tagLen = (uint8_t)tagLen;
uint8_t m = (ctx->tagLen - 2) / 2; // M' = (M - 2)/2
ctx->nonce[0] &= ~(0x7 << 3); // Clear 3|4|5 three bits
ctx->nonce[0] |= (m << 3); // Set M
return CRYPT_SUCCESS;
}
static uint32_t XorAadLen(MODES_CipherCCMCtx *ctx, uint32_t aadLen)
{
/**
* RFC_3610-2.2
* First two octets Followed by Comment
* ----------------- ---------------- -------------------------------
* 0x0000 Nothing Reserved
* 0x0001 ... 0xFEFF Nothing For 0 < l(a) < (2^16 - 2^8)
* 0xFF00 ... 0xFFFD Nothing Reserved
* 0xFFFE 4 octets of l(a) For (2^16 - 2^8) <= l(a) < 2^32
* 0xFFFF 8 octets of l(a) For 2^32 <= l(a) < 2^64
*/
uint32_t record; /* In order to record aadlen */
// For 0 < l(a) < (2^16 - 2^8)
if (aadLen < (((size_t)1 << 16) - ((size_t)1 << 8))) {
/* 0 < l(a) < (2^16 - 2^8) */
record = 2; /* 2 octets */
ctx->tag[1] ^= (uint8_t)aadLen;
ctx->tag[0] ^= (uint8_t)(aadLen >> 8); // 1byte = 8bit
} else {
/* (2^16 - 2^8) <= l(a) < 2^32 */
record = 6; /* 6 octets */
ctx->tag[5] ^= (uint8_t)aadLen; // base offset = 5
ctx->tag[4] ^= (uint8_t)(aadLen >> 8); // 1byte(off 5 -> 4) == 8bit
ctx->tag[3] ^= (uint8_t)(aadLen >> 16); // 2byte(off 5 -> 3) == 16bit
ctx->tag[2] ^= (uint8_t)(aadLen >> 24); // 3byte(off 5 -> 2) == 24bit
ctx->tag[1] ^= 0xfe;
ctx->tag[0] ^= 0xff;
}
return record;
}
// 0 < aadLen < 2^32
static int32_t SetAad(MODES_CipherCCMCtx *ctx, const void *val, uint32_t len)
{
if ((ctx->nonce[0] & 0x40) != 0 || ctx->tagInit != 0) {
// If aad has been set, the setting cannot be repeated.
BSL_ERR_PUSH_ERROR(CRYPT_MODES_AAD_REPEAT_SET_ERROR);
return CRYPT_MODES_AAD_REPEAT_SET_ERROR;
}
if (len == 0) { // If AAD is 0, returned directly.
return CRYPT_SUCCESS;
}
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
// bit6 Adata
ctx->nonce[0] |= 0x40;
// X_1 := E( K, B_0 )
int32_t ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->nonce, ctx->tag, CCM_BLOCKSIZE);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ctx->tagInit = 1;
uint32_t i;
uint32_t aadLen = len;
uint32_t record = XorAadLen(ctx, aadLen);
const uint8_t *aad = val;
uint32_t use = CCM_BLOCKSIZE - record;
use = (use < aadLen) ? use : aadLen;
for (i = 0; i < use; i++) {
ctx->tag[i + record] ^= aad[i];
}
aad += use;
aadLen -= use;
ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->tag, ctx->tag, CCM_BLOCKSIZE);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
while (aadLen > 0) {
uint32_t blockLen = (aadLen < CCM_BLOCKSIZE) ? aadLen : CCM_BLOCKSIZE;
for (i = 0; i < blockLen; i++) {
ctx->tag[i] ^= aad[i];
}
aad += blockLen;
aadLen -= blockLen;
ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->tag, ctx->tag, CCM_BLOCKSIZE);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
}
return CRYPT_SUCCESS;
}
static int32_t CtrTagCalc(MODES_CipherCCMCtx *ctx)
{
/**
* RFC_3610-2.3
* The authentication value U is computed by encrypting T with the ciphCtx
* stream block S_0 and truncating it to the desired length.
*/
ctx->nonce[0] &= 0x07; // update the nonce
uint8_t l = (ctx->nonce[0] & 0x07) + 1;
(void)memset_s(ctx->nonce + CCM_BLOCKSIZE - l, l, 0, l);
int32_t ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->nonce, ctx->nonce, CCM_BLOCKSIZE);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
}
static int32_t GetTag(MODES_CipherCCMCtx *ctx, void *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len != ctx->tagLen) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_TAGLEN_ERROR);
return CRYPT_MODES_TAGLEN_ERROR;
}
if (ctx->msgLen != 0) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_MSGLEN_LEFT_ERROR);
return CRYPT_MODES_MSGLEN_LEFT_ERROR;
}
int32_t ret = TagInit(ctx);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = CtrTagCalc(ctx);
if (ret != CRYPT_SUCCESS) {
// An error is reported by the internal function, and no redundant pushErr is required.
return ret;
}
if (ctx->lastLen != 0) {
ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->tag, ctx->tag, CCM_BLOCKSIZE);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
}
uint32_t i;
uint8_t *tag = val;
/**
* RFC_3610-2.3
* U := T XOR first-M-bytes( S_0 )
*/
for (i = 0; i < len; i++) {
tag[i] = ctx->tag[i] ^ ctx->nonce[i];
}
return CRYPT_SUCCESS;
}
int32_t MODES_CCM_Ctrl(MODES_CCM_Ctx *modeCtx, int32_t opt, void *val, uint32_t len)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (opt) {
case CRYPT_CTRL_SET_IV:
case CRYPT_CTRL_REINIT_STATUS:
return SetIv(&modeCtx->ccmCtx, val, len);
case CRYPT_CTRL_GET_BLOCKSIZE:
if (val == NULL || len != sizeof(uint32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
*(int32_t *)val = 1;
return CRYPT_SUCCESS;
case CRYPT_CTRL_SET_TAGLEN:
return SetTagLen(&modeCtx->ccmCtx, val, len);
case CRYPT_CTRL_SET_MSGLEN:
return SetMsgLen(&modeCtx->ccmCtx, val, len);
case CRYPT_CTRL_SET_AAD:
return SetAad(&modeCtx->ccmCtx, val, len);
case CRYPT_CTRL_GET_TAG:
return GetTag(&modeCtx->ccmCtx, val, len);
default:
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_TYPE_ERROR);
return CRYPT_MODES_CTRL_TYPE_ERROR;
}
}
MODES_CCM_Ctx *MODES_CCM_NewCtx(int32_t algId)
{
const EAL_SymMethod *method = EAL_GetSymMethod(algId);
if (method == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return NULL;
}
MODES_CCM_Ctx *ctx = BSL_SAL_Calloc(1, sizeof(MODES_CCM_Ctx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return ctx;
}
ctx->algId = algId;
ctx->ccmCtx.ciphCtx = BSL_SAL_Calloc(1, method->ctxSize);
if (ctx->ccmCtx.ciphCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
BSL_SAL_Free(ctx);
return NULL;
}
ctx->ccmCtx.ciphMeth = method;
return ctx;
}
int32_t MODES_CCM_InitCtx(MODES_CCM_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, void *param, bool enc)
{
(void)param;
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = modeCtx->ccmCtx.ciphMeth->setEncryptKey(modeCtx->ccmCtx.ciphCtx, key, keyLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
modeCtx->ccmCtx.tagLen = 16; // 16 default tag len, set iv need
ret = SetIv(&modeCtx->ccmCtx, iv, ivLen);
if (ret != CRYPT_SUCCESS) {
modeCtx->ccmCtx.ciphMeth->cipherDeInitCtx(modeCtx->ccmCtx.ciphCtx);
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
modeCtx->enc = enc;
return ret;
}
int32_t MODES_CCM_Update(MODES_CCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(modeCtx->enc ? MODES_CCM_Encrypt : MODES_CCM_Decrypt, &modeCtx->ccmCtx,
in, inLen, out, outLen);
}
int32_t MODES_CCM_Final(MODES_CCM_Ctx *modeCtx, uint8_t *out, uint32_t *outLen)
{
(void) modeCtx;
(void) out;
(void) outLen;
return CRYPT_EAL_CIPHER_FINAL_WITH_AEAD_ERROR;
}
int32_t MODES_CCM_DeInitCtx(MODES_CCM_Ctx *modeCtx)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
const EAL_SymMethod *ciphMeth = modeCtx->ccmCtx.ciphMeth;
void *ciphCtx = modeCtx->ccmCtx.ciphCtx;
modeCtx->ccmCtx.ciphMeth->cipherDeInitCtx(modeCtx->ccmCtx.ciphCtx);
BSL_SAL_CleanseData(&modeCtx->ccmCtx, sizeof(MODES_CipherCCMCtx));
modeCtx->ccmCtx.ciphMeth = ciphMeth;
modeCtx->ccmCtx.ciphCtx = ciphCtx;
return CRYPT_SUCCESS;
}
void MODES_CCM_FreeCtx(MODES_CCM_Ctx *modeCtx)
{
if (modeCtx == NULL) {
return;
}
modeCtx->ccmCtx.ciphMeth->cipherDeInitCtx(modeCtx->ccmCtx.ciphCtx);
BSL_SAL_FREE(modeCtx->ccmCtx.ciphCtx);
BSL_SAL_CleanseData(&modeCtx->ccmCtx, sizeof(MODES_CipherCCMCtx));
BSL_SAL_FREE(modeCtx);
}
int32_t MODES_CCM_UpdateEx(MODES_CCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_AES128_CCM:
case CRYPT_CIPHER_AES192_CCM:
case CRYPT_CIPHER_AES256_CCM:
#ifdef HITLS_CRYPTO_AES
return AES_CCM_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_CCM_Update(modeCtx, in, inLen, out, outLen);
}
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/modes_ccm.c | C | unknown | 20,629 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CFB
#include <stdbool.h>
#include "securec.h"
#include "bsl_err_internal.h"
#include "bsl_sal.h"
#include "crypt_modes_cfb.h"
#include "modes_local.h"
#include "crypt_errno.h"
#include "crypt_local_types.h"
#include "crypt_modes.h"
/* 8-bit | 64-bit | 128-bit CFB encryption. Here, len indicates the number of bytes to be processed. */
static int32_t MODES_CFB_BytesEncrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
const uint8_t *input = in;
uint8_t *output = out;
uint8_t *tmp = ctx->modeCtx.buf;
uint32_t blockSize = ctx->modeCtx.blockSize;
uint32_t feedbackBytes = ctx->feedbackBits >> 3; // right shifting by 3 to obtain the number of bytes.
uint32_t left = len;
uint32_t i, k;
// If the remaining encryption iv is not used up last time, use that part to perform XOR.
while (left > 0 && ctx->modeCtx.offset > 0) {
ctx->modeCtx.iv[ctx->modeCtx.offset] ^= *(input++);
*(output++) = ctx->modeCtx.iv[ctx->modeCtx.offset];
left--;
ctx->modeCtx.offset = (ctx->modeCtx.offset + 1) % blockSize;
}
while (left > 0) {
// Encrypt the IV.
int32_t ret = ctx->modeCtx.ciphMeth->encryptBlock(ctx->modeCtx.ciphCtx, ctx->modeCtx.iv, tmp, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
i = 0;
// The first (blockSize - feedbackBytes) bytes are filled with the least significant bytes of the previous IV.
if (blockSize - feedbackBytes > 0) {
(void)memmove_s(&ctx->modeCtx.iv[0], blockSize, &ctx->modeCtx.iv[feedbackBytes],
blockSize - feedbackBytes);
i = blockSize - feedbackBytes;
}
// The input data is XORed with the encrypted IV, and the current ciphertext is sent to the next IV.
if (left >= feedbackBytes) {
// Enter the last feedbackBytes in ciphertext.
for (k = 0; i < blockSize; i++, k++) {
output[k] = input[k] ^ tmp[k];
ctx->modeCtx.iv[i] = output[k];
}
UPDATE_VALUES(left, input, output, feedbackBytes);
} else {
// Enter the last feedbackBytes in ciphertext.
// The cache with insufficient feedbackBytes is used to encrypt the IV.
for (k = 0; k < left; k++) {
output[k] = input[k] ^ tmp[k];
ctx->modeCtx.iv[i++] = output[k];
}
while (i < blockSize) {
ctx->modeCtx.iv[i++] = tmp[k++];
}
ctx->modeCtx.offset = (uint8_t)(blockSize - feedbackBytes + left);
left = 0;
}
}
return CRYPT_SUCCESS;
}
static int32_t MODES_CFB128_BytesEncrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
const uint8_t *inp = in;
uint8_t *outp = out;
uint32_t blockSize = ctx->modeCtx.blockSize;
uint8_t *iv = ctx->modeCtx.iv;
uint32_t left = len;
int32_t ret;
while (left > 0 && ctx->modeCtx.offset > 0) {
iv[ctx->modeCtx.offset] ^= *(inp++);
*(outp++) = iv[ctx->modeCtx.offset];
left--;
ctx->modeCtx.offset = (ctx->modeCtx.offset + 1) % blockSize;
}
while (left >= blockSize) {
ret = ctx->modeCtx.ciphMeth->encryptBlock(ctx->modeCtx.ciphCtx, iv, iv, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
#ifdef FORCE_ADDR_ALIGN
for (uint32_t i = 0; i < blockSize; i++) {
iv[i] ^= inp[i];
out[i] = iv[i];
}
#else
for (uint32_t i = 0; i < blockSize; i += sizeof(uint64_t)) {
*((uint64_t *)(iv + i)) ^= *((const uint64_t *)(inp + i));
*((uint64_t *)(outp + i)) = *((uint64_t *)(iv + i));
}
#endif
UPDATE_VALUES(left, inp, outp, blockSize);
}
if (left > 0) {
ret = ctx->modeCtx.ciphMeth->encryptBlock(ctx->modeCtx.ciphCtx, iv, iv, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
uint32_t i = 0;
for (; i < left; i++) {
iv[i] ^= inp[i];
outp[i] = iv[i];
}
ctx->modeCtx.offset = (uint8_t)left;
}
return CRYPT_SUCCESS;
}
/* 8-bit | 64-bit | 128-bit CFB decryption. Here, len indicates the number of bytes to be processed. */
static int32_t MODES_CFB_BytesDecrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
const uint8_t *input = in;
uint8_t *output = out;
uint8_t *tmp = ctx->modeCtx.buf;
uint32_t blockSize = ctx->modeCtx.blockSize;
uint32_t feedbackBytes = ctx->feedbackBits >> 3;
uint32_t left = len;
uint32_t i, k;
// If the remaining encryption iv is not used up last time, use that part to perform XOR.
while (left > 0 && ctx->modeCtx.offset > 0) {
uint8_t tmpInput = *input; // To support the same address in and out
*(output++) = ctx->modeCtx.iv[ctx->modeCtx.offset] ^ *(input++);
ctx->modeCtx.iv[ctx->modeCtx.offset] = tmpInput;
left--;
ctx->modeCtx.offset = (ctx->modeCtx.offset + 1) % blockSize;
}
while (left > 0) {
// Encrypt the IV.
int32_t ret = ctx->modeCtx.ciphMeth->encryptBlock(ctx->modeCtx.ciphCtx, ctx->modeCtx.iv, tmp, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
i = 0;
// The first (blockSize - feedbackBytes) bytes are filled with the least significant bytes of the previous IV.
if (blockSize - feedbackBytes > 0) {
(void)memmove_s(&ctx->modeCtx.iv[0], blockSize, &ctx->modeCtx.iv[feedbackBytes],
blockSize - feedbackBytes);
i = blockSize - feedbackBytes;
}
// The input data is XORed with the encrypted IV, and the current ciphertext is sent to the next IV.
if (left >= feedbackBytes) {
// Enter the last feedbackBytes in ciphertext.
for (k = 0; i < blockSize; i++, k++) {
ctx->modeCtx.iv[i] = input[k];
output[k] = input[k] ^ tmp[k];
}
UPDATE_VALUES(left, input, output, feedbackBytes);
} else {
// Enter the last feedbackBytes in ciphertext.
// The cache with insufficient feedbackBytes is used to encrypt the IV.
for (k = 0; k < left; k++) {
ctx->modeCtx.iv[i++] = input[k];
output[k] = input[k] ^ tmp[k];
}
while (i < blockSize) {
ctx->modeCtx.iv[i++] = tmp[k++];
}
ctx->modeCtx.offset = (uint8_t)(blockSize - feedbackBytes + left);
left = 0;
}
}
return CRYPT_SUCCESS;
}
static int32_t MODES_CFB128_BytesDecrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
const uint8_t *inp = in;
uint8_t *outp = out;
uint8_t *iv = ctx->modeCtx.iv;
uint32_t blockSize = ctx->modeCtx.blockSize;
uint32_t left = len;
int32_t ret;
while (left > 0 && ctx->modeCtx.offset > 0) {
uint8_t tmpInput = *inp; // To support the same address in and out
*(outp++) = iv[ctx->modeCtx.offset] ^ *(inp++);
iv[ctx->modeCtx.offset] = tmpInput;
left--;
ctx->modeCtx.offset = (ctx->modeCtx.offset + 1) % blockSize;
}
while (left >= blockSize) {
ret = ctx->modeCtx.ciphMeth->encryptBlock(ctx->modeCtx.ciphCtx, iv, iv, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
#ifdef FORCE_ADDR_ALIGN
for (uint32_t i = 0; i < blockSize; i++) {
uint8_t c = inp[i];
outp[i] = iv[i] ^ c;
iv[i] = c;
}
#else
for (uint32_t i = 0; i < blockSize; i += sizeof(uint64_t)) {
uint64_t ti = *((const uint64_t *)(inp + i));
*((uint64_t *)(outp + i)) = *((uint64_t *)(iv + i)) ^ ti;
*((uint64_t *)(iv + i)) = ti;
}
#endif
UPDATE_VALUES(left, inp, outp, blockSize);
}
if (left > 0) {
ret = ctx->modeCtx.ciphMeth->encryptBlock(ctx->modeCtx.ciphCtx, iv, iv, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
uint32_t i = 0;
for (; i < left; i++) {
uint8_t b = inp[i];
outp[i] = iv[i] ^ b;
iv[i] = b;
}
ctx->modeCtx.offset = (uint8_t)left;
}
return CRYPT_SUCCESS;
}
static int32_t Cfb1Crypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, bool enc)
{
int32_t ret;
uint8_t *tmp = ctx->modeCtx.buf;
uint32_t blockSize = ctx->modeCtx.blockSize;
uint32_t i;
// Encrypt the IV.
ret = ctx->modeCtx.ciphMeth->encryptBlock(ctx->modeCtx.ciphCtx, ctx->modeCtx.iv, tmp, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
for (i = 0; i < blockSize - 1; i++) {
// All bytes are shifted left by one bit,
// and the least significant bits are obtained by shifting right by 7 bits from the next byte.
ctx->modeCtx.iv[i] = (ctx->modeCtx.iv[i] << 1) | (ctx->modeCtx.iv[i + 1] >> 7);
}
if (enc) {
*out = tmp[0] ^ *in;
// The last byte is shifted to the left by one bit and then filled in the ciphertext.
// Shifted to the right by 7 bits to obtain the first bit of the byte.
ctx->modeCtx.iv[i] = (ctx->modeCtx.iv[i] << 1) | (*out >> 7);
} else {
// The last byte is shifted to the left by one bit and then filled in the ciphertext.
// Shifted to the right by 7 bits to obtain the first bit of the byte.
ctx->modeCtx.iv[i] = (ctx->modeCtx.iv[i] << 1) | (*in >> 7);
*out = tmp[0] ^ *in;
}
return CRYPT_SUCCESS;
}
/* 1-bit CFB. Here, len indicates the number of bits to be processed. */
int32_t MODES_CFB_BitCrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc)
{
int32_t ret;
uint8_t tmp[2];
uint32_t pos;
for (uint32_t i = 0; i < len; i++) {
// 7 - i % 8 is used to obtain the number of bits in the byte stream (high bit -> low bit).
pos = 7 - i % 8;
// Obtain the bits to be encrypted. 0x80 indicates a byte whose most significant bit is 1.
tmp[0] = ((in[i / 8] & (1 << pos)) > 0) ? 0x80 : 0;
ret = Cfb1Crypt(ctx, &tmp[0], &tmp[1], enc);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
// Divide by 8 to obtain the current byte position. Assign the out encryption bit to 0.
out[i / 8] = out[i / 8] & ~(1u << pos);
// Divide by 8 to obtain the current byte position. tmpOut[0] >> 7 to obtain the most significant bit.
out[i / 8] |= (tmp[1] >> 7) << pos; // Assign the out encryption bit to the encrypted/decrypted value.
}
(void)memset_s(tmp, sizeof(tmp), 0, sizeof(tmp));
return CRYPT_SUCCESS;
}
int32_t MODES_CFB_Encrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL || len == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (ctx->feedbackBits) {
case 1:
return MODES_CFB_BitCrypt(ctx, in, out, len * 8, true); // Each byte occupies 8 bits.
case 8:
case 64:
return MODES_CFB_BytesEncrypt(ctx, in, out, len);
case 128:
return MODES_CFB128_BytesEncrypt(ctx, in, out, len);
default:
BSL_ERR_PUSH_ERROR(CRYPT_MODES_ERR_FEEDBACKSIZE);
return CRYPT_MODES_ERR_FEEDBACKSIZE;
}
}
int32_t MODES_CFB_Decrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL || len == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (ctx->feedbackBits) {
case 1: // 1-bit cfb. Convert the length of bytes to the length of bits.
return MODES_CFB_BitCrypt(ctx, in, out, len * 8, false); // Each byte occupies 8 bits.
case 8: // 8-bit cfb
case 64: // 64-bit cfb
return MODES_CFB_BytesDecrypt(ctx, in, out, len);
case 128: // 128-bit cfb
return MODES_CFB128_BytesDecrypt(ctx, in, out, len);
default:
BSL_ERR_PUSH_ERROR(CRYPT_MODES_ERR_FEEDBACKSIZE);
return CRYPT_MODES_ERR_FEEDBACKSIZE;
}
}
static int32_t SetFeedbackSize(MODES_CipherCFBCtx *ctx, const uint32_t *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len != sizeof(uint32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
if (*val != 1 && *val != 8 && *val != 64 && *val != 128) { // set 1|8|64|128 feedbackbits only
BSL_ERR_PUSH_ERROR(CRYPT_MODES_ERR_FEEDBACKSIZE);
return CRYPT_MODES_ERR_FEEDBACKSIZE;
}
if (*val > (uint32_t)(ctx->modeCtx.blockSize * 8)) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_ERR_FEEDBACKSIZE);
return CRYPT_MODES_ERR_FEEDBACKSIZE;
}
ctx->feedbackBits = (uint8_t)*val;
return CRYPT_SUCCESS;
}
static int32_t GetFeedbackSize(MODES_CipherCFBCtx *ctx, uint32_t *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len != sizeof(uint32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
*val = ctx->feedbackBits;
return CRYPT_SUCCESS;
}
int32_t MODES_CFB_Ctrl(MODES_CFB_Ctx *modeCtx, int32_t opt, void *val, uint32_t len)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (opt) {
case CRYPT_CTRL_REINIT_STATUS:
modeCtx->cfbCtx.cacheIndex = 0;
return MODES_SetIv(&modeCtx->cfbCtx.modeCtx, val, len);
case CRYPT_CTRL_GET_IV:
return MODES_GetIv(&modeCtx->cfbCtx.modeCtx, (uint8_t *)val, len);
case CRYPT_CTRL_SET_FEEDBACKSIZE:
return SetFeedbackSize(&modeCtx->cfbCtx, (uint32_t *)val, len);
case CRYPT_CTRL_GET_FEEDBACKSIZE:
return GetFeedbackSize(&modeCtx->cfbCtx, (uint32_t *)val, len);
case CRYPT_CTRL_GET_BLOCKSIZE:
if (val == NULL || len != sizeof(uint32_t)) {
return CRYPT_INVALID_ARG;
}
*(int32_t *)val = 1;
return CRYPT_SUCCESS;
default:
if (modeCtx->cfbCtx.modeCtx.ciphMeth == NULL ||
modeCtx->cfbCtx.modeCtx.ciphMeth->cipherCtrl == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_TYPE_ERROR);
return CRYPT_MODES_CTRL_TYPE_ERROR;
}
return modeCtx->cfbCtx.modeCtx.ciphMeth->cipherCtrl(modeCtx->cfbCtx.modeCtx.ciphCtx, opt, val, len);
}
}
MODES_CFB_Ctx *MODES_CFB_NewCtx(int32_t algId)
{
const EAL_SymMethod *method = EAL_GetSymMethod(algId);
if (method == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return NULL;
}
MODES_CFB_Ctx *ctx = BSL_SAL_Calloc(1, sizeof(MODES_CFB_Ctx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return ctx;
}
ctx->algId = algId;
ctx->cfbCtx.modeCtx.ciphCtx = BSL_SAL_Calloc(1, method->ctxSize);
if (ctx->cfbCtx.modeCtx.ciphCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
BSL_SAL_Free(ctx);
return NULL;
}
ctx->cfbCtx.cacheIndex = 0;
uint8_t blockBits = method->blockSize * 8;
if (blockBits <= 128) {
ctx->cfbCtx.feedbackBits = blockBits;
} else {
ctx->cfbCtx.feedbackBits = 128;
}
ctx->cfbCtx.modeCtx.blockSize = method->blockSize;
ctx->cfbCtx.modeCtx.ciphMeth = method;
ctx->cfbCtx.modeCtx.offset = 0;
return ctx;
}
int32_t MODES_CFB_InitCtx(MODES_CFB_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
modeCtx->cfbCtx.cacheIndex = 0;
modeCtx->enc = enc;
return MODES_CipherInitCommonCtx(&modeCtx->cfbCtx.modeCtx, modeCtx->cfbCtx.modeCtx.ciphMeth->setEncryptKey,
modeCtx->cfbCtx.modeCtx.ciphCtx, key, keyLen, iv, ivLen);
}
int32_t MODES_CFB_Update(MODES_CFB_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(modeCtx->enc ? MODES_CFB_Encrypt : MODES_CFB_Decrypt, &modeCtx->cfbCtx,
in, inLen, out, outLen);
}
int32_t MODES_CFB_Final(MODES_CFB_Ctx *modeCtx, uint8_t *out, uint32_t *outLen)
{
(void) modeCtx;
(void) out;
*outLen = 0;
return CRYPT_SUCCESS;
}
int32_t MODES_CFB_DeInitCtx(MODES_CFB_Ctx *modeCtx)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
MODES_Clean(&modeCtx->cfbCtx.modeCtx);
BSL_SAL_CleanseData((void *)(modeCtx->cfbCtx.cipherCache[0]), DES_BLOCK_BYTE_NUM * 3); // 3 ciphertext caches
return CRYPT_SUCCESS;
}
void MODES_CFB_FreeCtx(MODES_CFB_Ctx *modeCtx)
{
if (modeCtx == NULL) {
return ;
}
(void)MODES_CFB_DeInitCtx(modeCtx);
BSL_SAL_Free(modeCtx->cfbCtx.modeCtx.ciphCtx);
BSL_SAL_Free(modeCtx);
}
int32_t MODES_CFB_InitCtxEx(MODES_CFB_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, void *param, bool enc)
{
(void) param;
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (ivLen != modeCtx->cfbCtx.modeCtx.blockSize) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_IVLEN_ERROR);
return CRYPT_MODES_IVLEN_ERROR;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_SM4_CFB:
#ifdef HITLS_CRYPTO_SM4
return SM4_CFB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_CFB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
}
int32_t MODES_CFB_UpdateEx(MODES_CFB_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_AES128_CFB:
case CRYPT_CIPHER_AES192_CFB:
case CRYPT_CIPHER_AES256_CFB:
#ifdef HITLS_CRYPTO_AES
return AES_CFB_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
case CRYPT_CIPHER_SM4_CFB:
#ifdef HITLS_CRYPTO_SM4
return SM4_CFB_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_CFB_Update(modeCtx, in, inLen, out, outLen);
}
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/modes_cfb.c | C | unknown | 19,758 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
#include <stdint.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "modes_local.h"
#include "poly1305_core.h"
#include "crypt_modes.h"
void Poly1305SetKey(Poly1305Ctx *ctx, const uint8_t key[POLY1305_KEYSIZE])
{
// RFC_7539-2.5
ctx->r[0] = GET_UINT32_LE(key, 0);
ctx->r[1] = GET_UINT32_LE(key, 4);
ctx->r[2] = GET_UINT32_LE(key, 8);
ctx->r[3] = GET_UINT32_LE(key, 12);
ctx->s[0] = GET_UINT32_LE(key, 16);
ctx->s[1] = GET_UINT32_LE(key, 20);
ctx->s[2] = GET_UINT32_LE(key, 24);
ctx->s[3] = GET_UINT32_LE(key, 28);
/**
* r[3], r[7], r[11], and r[15] are required to have their top four
* bits clear (be smaller than 16)
* r[4], r[8], and r[12] are required to have their bottom two bits
* clear (be divisible by 4)
*/
ctx->r[0] &= 0x0FFFFFFF;
ctx->r[1] &= 0x0FFFFFFC;
ctx->r[2] &= 0x0FFFFFFC;
ctx->r[3] &= 0x0FFFFFFC;
ctx->acc[0] = 0;
ctx->acc[1] = 0;
ctx->acc[2] = 0;
ctx->acc[3] = 0;
ctx->acc[4] = 0;
ctx->acc[5] = 0;
(void)memset_s(ctx->last, sizeof(ctx->last), 0, sizeof(ctx->last));
ctx->lastLen = 0;
Poly1305InitForAsm(ctx); // Information such as tables required for initializing the assembly
}
void Poly1305Update(Poly1305Ctx *ctx, const uint8_t *data, uint32_t dataLen)
{
uint32_t i;
uint32_t len = dataLen;
const uint8_t *off = data;
if (ctx->lastLen != 0) {
uint64_t end = (uint64_t)len + ctx->lastLen;
if (end > POLY1305_BLOCKSIZE) {
end = POLY1305_BLOCKSIZE;
}
for (i = ctx->lastLen; i < end; i++) {
ctx->last[i] = *off;
off++;
}
len -= (uint32_t)(end - ctx->lastLen);
if (end == POLY1305_BLOCKSIZE) {
(void)Poly1305Block(ctx, ctx->last, POLY1305_BLOCKSIZE, 1);
} else {
ctx->lastLen = (uint32_t)end;
return;
}
}
/**
* Add one bit beyond the number of octets. For a 16-byte block,
* this is equivalent to adding 2^128 to the number.
*/
if (len >= POLY1305_BLOCKSIZE) {
(void)Poly1305Block(ctx, off, len & 0xfffffff0, 1);
}
ctx->lastLen = len & 0x0f; // mod 16;
off += len - ctx->lastLen;
for (i = 0; i < ctx->lastLen; i++) {
ctx->last[i] = off[i];
}
return;
}
void Poly1305Final(Poly1305Ctx *ctx, uint8_t mac[POLY1305_TAGSIZE])
{
uint32_t len = ctx->lastLen;
if (len > 0) {
/**
* For the shorter block, it can be 2^120, 2^112, or any power of two that is
* evenly divisible by 8, all the way down to 2^8
*/
ctx->last[len++] = 1;
/**
* If the block is not 17 bytes long (the last block), pad it with
* zeros. This is meaningless if you are treating the blocks as
* numbers.
*/
while (len < POLY1305_BLOCKSIZE) {
ctx->last[len++] = 0;
}
Poly1305Block(ctx, ctx->last, POLY1305_BLOCKSIZE, 0);
ctx->lastLen = 0;
}
Poly1305Last(ctx, mac);
}
int32_t MODES_CHACHA20POLY1305_Encrypt(MODES_CipherChaChaPolyCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL || len == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = ctx->method->encryptBlock(ctx->key, in, out, len);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
Poly1305Update(&(ctx->polyCtx), out, len);
ctx->cipherTextLen += (uint64_t)len;
return CRYPT_SUCCESS;
}
int32_t MODES_CHACHA20POLY1305_Decrypt(MODES_CipherChaChaPolyCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL || len == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
Poly1305Update(&(ctx->polyCtx), in, len);
ctx->cipherTextLen += (uint64_t)len;
int32_t ret = ctx->method->decryptBlock(ctx->key, in, out, len);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
}
static void CipherTextPad(MODES_CipherChaChaPolyCtx *ctx)
{
/**
* The ciphertext
* padding2 -- the padding is up to 15 zero bytes, and it brings
* the total length so far to an integral multiple of 16. If the
* length of the ciphertext was already an integral multiple of 16
* bytes, this field is zero-length.
*/
Poly1305Ctx *polyCtx = &(ctx->polyCtx);
uint32_t len = polyCtx->lastLen;
if (len != 0) {
const uint8_t pad2[POLY1305_BLOCKSIZE] = {0};
Poly1305Update(polyCtx, pad2, POLY1305_BLOCKSIZE - len);
}
uint8_t pad[POLY1305_BLOCKSIZE];
/**
* The length of the additional data in octets (as a 64-bit
* little-endian integer).
*/
PUT_UINT64_LE(ctx->aadLen, pad, 0); // The first eight bytes are padded with the length of the AAD.
/**
* The length of the ciphertext in octets (as a 64-bit littleendian
* integer).
*/
PUT_UINT64_LE(ctx->cipherTextLen, pad, 8); // The last 8 bytes are padded the length of the ciphertext.
Poly1305Update(polyCtx, pad, POLY1305_BLOCKSIZE);
}
static int32_t GetTag(MODES_CipherChaChaPolyCtx *ctx, uint8_t *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len != POLY1305_TAGSIZE) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_TAGLEN_ERROR);
return CRYPT_MODES_TAGLEN_ERROR;
}
CipherTextPad(ctx);
Poly1305Final(&(ctx->polyCtx), val);
return CRYPT_SUCCESS;
}
static int32_t SetIv(MODES_CipherChaChaPolyCtx *ctx, const uint8_t *iv, uint32_t ivLen)
{
/**
* RFC_7539-2.6
* ChaCha20 as specified here requires a 96-bit nonce.
* So if the provided nonce is only 64-bit, then the first 32
* bits of the nonce will be set to a constant number. This will
* usually be zero, but for protocols with multiple senders it may be
* different for each sender, but should be the same for all
* invocations of the function with the same key by a particular
* sender.
*/
if (iv == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
// 96 bits or 64 bits, that is, 12 bytes or 8 bytes.
if (ivLen != 12 && ivLen != 8) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_IVLEN_ERROR);
return CRYPT_MODES_IVLEN_ERROR;
}
int32_t ret;
uint8_t block[POLY1305_KEYSIZE] = { 0 };
if (ivLen == 8) { // If the length of the IV is 8, 0 data must be padded before.
uint8_t tmpBuff[12] = { 0 };
(void)memcpy_s(tmpBuff + 4, sizeof(tmpBuff) - 4, iv, ivLen); // // 4 bytes 0 data must be padded before.
ret = ctx->method->cipherCtrl(ctx->key, CRYPT_CTRL_SET_IV, tmpBuff, sizeof(tmpBuff));
// Clear sensitive data.
(void)BSL_SAL_CleanseData(tmpBuff, sizeof(tmpBuff));
} else {
ret = ctx->method->cipherCtrl(ctx->key, CRYPT_CTRL_SET_IV, (void *)(uintptr_t)iv, ivLen);
}
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
/**
* RFC_7539-2.6
* The block counter is set to zero
*/
uint8_t initCount[4] = { 0 };
ret = ctx->method->cipherCtrl(ctx->key, CRYPT_CTRL_SET_COUNT, initCount, sizeof(initCount));
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = ctx->method->encryptBlock(ctx->key, block, block, POLY1305_KEYSIZE);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
Poly1305SetKey(&(ctx->polyCtx), block);
/**
* RFC_7539-2.8
* the ChaCha20 encryption function is called to encrypt the
* plaintext, using the same key and nonce, and with the initial
* counter set to 1
*/
initCount[0] = 0x01;
ret = ctx->method->cipherCtrl(ctx->key, CRYPT_CTRL_SET_COUNT, initCount, sizeof(initCount)); // 4bytes count
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
// Information that needs to be reset.
ctx->aadLen = 0;
ctx->cipherTextLen = 0;
return ret;
}
// Set the AAD information. The AAD information can be set only once.
static int32_t SetAad(MODES_CipherChaChaPolyCtx *ctx, const uint8_t *aad, uint32_t aadLen)
{
/**
* RFC_7539-2.8
* The AAD
* padding1 -- the padding is up to 15 zero bytes, and it brings
* the total length so far to an integral multiple of 16. If the
* length of the AAD was already an integral multiple of 16 bytes,
* this field is zero-length.
*/
if (ctx->aadLen != 0 || ctx->cipherTextLen != 0) { // aad is set
BSL_ERR_PUSH_ERROR(CRYPT_MODES_AAD_REPEAT_SET_ERROR);
return CRYPT_MODES_AAD_REPEAT_SET_ERROR;
}
if (aadLen == 0) {
return CRYPT_SUCCESS;
}
if (aad == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
const uint8_t pad[16] = { 0 };
ctx->aadLen = aadLen;
Poly1305Update(&(ctx->polyCtx), aad, aadLen);
uint32_t padLen = (16 - aadLen % 16) % 16;
Poly1305Update(&(ctx->polyCtx), pad, padLen);
return CRYPT_SUCCESS;
}
int32_t MODES_CHACHA20POLY1305_SetEncryptKey(MODES_CipherChaChaPolyCtx *ctx, const uint8_t *key, uint32_t len)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return ctx->method->setEncryptKey(ctx->key, key, len);
}
int32_t MODES_CHACHA20POLY1305_SetDecryptKey(MODES_CipherChaChaPolyCtx *ctx, const uint8_t *key, uint32_t len)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return ctx->method->setDecryptKey(ctx->key, key, len);
}
int32_t MODES_CHACHA20POLY1305_Ctrl(MODES_CHACHAPOLY_Ctx *modeCtx, int32_t opt, void *val, uint32_t len)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
switch (opt) {
case CRYPT_CTRL_REINIT_STATUS:
return SetIv(&modeCtx->chachaCtx, val, len);
case CRYPT_CTRL_GET_TAG:
return GetTag(&modeCtx->chachaCtx, val, len);
case CRYPT_CTRL_SET_AAD:
return SetAad(&modeCtx->chachaCtx, val, len);
case CRYPT_CTRL_GET_BLOCKSIZE:
if (val == NULL || len != sizeof(uint32_t)) {
return CRYPT_INVALID_ARG;
}
*(int32_t *)val = 1;
return CRYPT_SUCCESS;
default:
if (modeCtx->chachaCtx.method == NULL ||
modeCtx->chachaCtx.method->cipherCtrl == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_TYPE_ERROR);
return CRYPT_MODES_CTRL_TYPE_ERROR;
}
return modeCtx->chachaCtx.method->cipherCtrl(modeCtx->chachaCtx.key, opt, val, len);
}
}
MODES_CHACHAPOLY_Ctx *MODES_CHACHA20POLY1305_NewCtx(int32_t algId)
{
const EAL_SymMethod *method = EAL_GetSymMethod(algId);
if (method == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return NULL;
}
MODES_CHACHAPOLY_Ctx *ctx = BSL_SAL_Calloc(1, sizeof(MODES_CHACHAPOLY_Ctx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return ctx;
}
ctx->algId = algId;
ctx->chachaCtx.key = BSL_SAL_Calloc(1, method->ctxSize);
if (ctx->chachaCtx.key == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
BSL_SAL_Free(ctx);
return NULL;
}
ctx->chachaCtx.method = method;
return ctx;
}
int32_t MODES_CHACHA20POLY1305_InitCtx(MODES_CHACHAPOLY_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen,
const uint8_t *iv, uint32_t ivLen, void *param, bool enc)
{
(void)param;
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = enc ? modeCtx->chachaCtx.method->setEncryptKey(modeCtx->chachaCtx.key, key, keyLen) :
modeCtx->chachaCtx.method->setDecryptKey(modeCtx->chachaCtx.key, key, keyLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = SetIv(&modeCtx->chachaCtx, iv, ivLen);
if (ret != CRYPT_SUCCESS) {
modeCtx->chachaCtx.method->cipherDeInitCtx(modeCtx->chachaCtx.key);
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
modeCtx->enc = enc;
return ret;
}
int32_t MODES_CHACHA20POLY1305_Update(MODES_CHACHAPOLY_Ctx *modeCtx, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return MODES_CipherStreamProcess(modeCtx->enc ? MODES_CHACHA20POLY1305_Encrypt : MODES_CHACHA20POLY1305_Decrypt,
&modeCtx->chachaCtx, in, inLen, out, outLen);
}
int32_t MODES_CHACHA20POLY1305_Final(MODES_CHACHAPOLY_Ctx *modeCtx, uint8_t *out, uint32_t *outLen)
{
(void) modeCtx;
(void) out;
(void) outLen;
return CRYPT_EAL_CIPHER_FINAL_WITH_AEAD_ERROR;
}
int32_t MODES_CHACHA20POLY1305_DeInitCtx(MODES_CHACHAPOLY_Ctx *modeCtx)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
modeCtx->chachaCtx.method->cipherDeInitCtx(modeCtx->chachaCtx.key);
BSL_SAL_CleanseData((void *)(&(modeCtx->chachaCtx.polyCtx)), sizeof(Poly1305Ctx));
modeCtx->chachaCtx.aadLen = 0;
modeCtx->chachaCtx.cipherTextLen = 0;
Poly1305CleanRegister();
return CRYPT_SUCCESS;
}
void MODES_CHACHA20POLY1305_FreeCtx(MODES_CHACHAPOLY_Ctx *modeCtx)
{
if (modeCtx == NULL) {
return;
}
modeCtx->chachaCtx.method->cipherDeInitCtx(modeCtx->chachaCtx.key);
BSL_SAL_FREE(modeCtx->chachaCtx.key);
BSL_SAL_ClearFree(modeCtx, sizeof(MODES_CHACHAPOLY_Ctx));
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/modes_chacha20_poly1305.c | C | unknown | 14,601 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CTR
#include "securec.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "crypt_modes_ctr.h"
#include "modes_local.h"
uint32_t MODES_CTR_LastHandle(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
uint32_t left = len;
uint32_t blockSize = ctx->blockSize;
const uint8_t *tmpIn = in;
uint8_t *tmpOut = out;
// buf[0, ctx->offset, blockSize)
// The data from st to blockSize - 1 is the data obtained after the last encryption and is not used up.
while ((ctx->offset != 0) && (left > 0)) {
*(tmpOut++) = ((*(tmpIn++)) ^ (ctx->buf[ctx->offset++]));
--left;
// & (blockSize - 1) is equivalent to mod blockSize.
ctx->offset &= (uint8_t)(blockSize - 1);
}
// Return the calculated length.
return (len - left);
}
void MODES_CTR_RemHandle(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (len == 0) {
return;
}
uint32_t left = len;
uint32_t blockSize = ctx->blockSize;
const uint8_t *tmpIn = in;
uint8_t *tmpOut = out;
// Ensure that the length of IV is 16 when setting it, which will not cause encryption failures.
// To optimize performance, the function does not determine the length of the IV.
(void)ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->iv, ctx->buf, blockSize);
MODE_IncCounter(ctx->iv, ctx->blockSize);
ctx->offset = 0;
while ((left) > 0) {
tmpOut[ctx->offset] = (tmpIn[ctx->offset]) ^ (ctx->buf[ctx->offset]);
--left;
++ctx->offset;
}
}
int32_t MODES_CTR_Crypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
uint32_t offset = MODES_CTR_LastHandle(ctx, in, out, len);
uint32_t left = len - offset;
const uint8_t *tmpIn = in + offset;
uint8_t *tmpOut = out + offset;
uint32_t blockSize = ctx->blockSize;
while (left >= blockSize) {
// Ensure that the length of IV is 16 when setting it, which will not cause encryption failures.
// To optimize performance, the function does not determine the length of the IV.
(void)ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->iv, ctx->buf, blockSize);
MODE_IncCounter(ctx->iv, ctx->blockSize);
DATA64_XOR(tmpIn, ctx->buf, tmpOut, blockSize);
left -= blockSize;
tmpOut += blockSize;
tmpIn += blockSize;
}
MODES_CTR_RemHandle(ctx, tmpIn, tmpOut, left);
return CRYPT_SUCCESS;
}
MODES_CipherCtx *MODES_CTR_NewCtx(int32_t algId)
{
return MODES_CipherNewCtx(algId);
}
int32_t MODES_CTR_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_CipherInitCtx(modeCtx, modeCtx->commonCtx.ciphMeth->setEncryptKey,
modeCtx->commonCtx.ciphCtx, key, keyLen, iv, ivLen, enc);
}
int32_t MODES_CTR_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(MODES_CTR_Crypt, &modeCtx->commonCtx, in, inLen, out, outLen);
}
int32_t MODES_CTR_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
(void) modeCtx;
(void) out;
*outLen = 0;
return CRYPT_SUCCESS;
}
int32_t MODES_CTR_DeInitCtx(MODES_CipherCtx *modeCtx)
{
return MODES_CipherDeInitCtx(modeCtx);
}
int32_t MODES_CTR_Ctrl(MODES_CipherCtx *modeCtx, int32_t cmd, void *val, uint32_t valLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (cmd) {
case CRYPT_CTRL_GET_BLOCKSIZE:
if (val == NULL || valLen != sizeof(uint32_t)) {
return CRYPT_INVALID_ARG;
}
*(int32_t *)val = 1;
return CRYPT_SUCCESS;
default:
return MODES_CipherCtrl(modeCtx, cmd, val, valLen);;
}
}
void MODES_CTR_FreeCtx(MODES_CipherCtx *modeCtx)
{
MODES_CipherFreeCtx(modeCtx);
}
int32_t MODES_CTR_InitCtxEx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, void *param, bool enc)
{
(void)param;
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_SM4_CTR:
#ifdef HITLS_CRYPTO_SM4
return SM4_CTR_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_CTR_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
}
int32_t MODES_CTR_UpdateEx(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_AES128_CTR:
case CRYPT_CIPHER_AES192_CTR:
case CRYPT_CIPHER_AES256_CTR:
#ifdef HITLS_CRYPTO_AES
return AES_CTR_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
case CRYPT_CIPHER_SM4_CTR:
#ifdef HITLS_CRYPTO_SM4
return SM4_CTR_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_CTR_Update(modeCtx, in, inLen, out, outLen);
}
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/modes_ctr.c | C | unknown | 6,028 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_ECB
#include "bsl_err_internal.h"
#include "bsl_sal.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "crypt_modes_ecb.h"
#include "modes_local.h"
#include "securec.h"
int32_t MODES_ECB_Crypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc)
{
// ctx, in, out, these pointer have been judged at the EAL layer and is not judged again here.
if (ctx->ciphCtx == NULL || len == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret;
uint32_t left = len;
const uint8_t *input = in;
uint8_t *output = out;
uint32_t blockSize = ctx->blockSize;
while (left >= blockSize) {
if (enc) {
ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, input, output, blockSize);
} else {
ret = ctx->ciphMeth->decryptBlock(ctx->ciphCtx, input, output, blockSize);
}
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
input += blockSize;
output += blockSize;
left -= blockSize;
}
if (left > 0) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
return CRYPT_SUCCESS;
}
int32_t MODES_ECB_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
return MODES_ECB_Crypt(ctx, in, out, len, true);
}
int32_t MODES_ECB_Decrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
return MODES_ECB_Crypt(ctx, in, out, len, false);
}
MODES_CipherCtx *MODES_ECB_NewCtx(int32_t algId)
{
return MODES_CipherNewCtx(algId);
}
int32_t MODES_ECB_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
(void)iv;
(void)ivLen;
int32_t ret;
ret = enc ? modeCtx->commonCtx.ciphMeth->setEncryptKey(modeCtx->commonCtx.ciphCtx, key, keyLen) :
modeCtx->commonCtx.ciphMeth->setDecryptKey(modeCtx->commonCtx.ciphCtx, key, keyLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
modeCtx->enc = enc;
return ret;
}
int32_t MODES_ECB_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherUpdate(modeCtx, modeCtx->enc ? MODES_ECB_Encrypt : MODES_ECB_Decrypt,
in, inLen, out, outLen);
}
int32_t MODES_ECB_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherFinal(modeCtx, modeCtx->enc ? MODES_ECB_Encrypt : MODES_ECB_Decrypt, out, outLen);
}
int32_t MODES_ECB_DeinitCtx(MODES_CipherCtx *modeCtx)
{
return MODES_CipherDeInitCtx(modeCtx);
}
int32_t MODES_ECB_Ctrl(MODES_CipherCtx *modeCtx, int32_t cmd, void *val, uint32_t valLen)
{
int ret;
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (cmd) {
case CRYPT_CTRL_REINIT_STATUS:
(void)memset_s(modeCtx->data, EAL_MAX_BLOCK_LENGTH, 0, EAL_MAX_BLOCK_LENGTH);
modeCtx->dataLen = 0;
modeCtx->pad = CRYPT_PADDING_NONE;
return CRYPT_SUCCESS;
case CRYPT_CTRL_SET_PADDING:
if (val == NULL || valLen != sizeof(int32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
if (modeCtx->commonCtx.blockSize == 1) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_PADDING_NOT_SUPPORT);
return CRYPT_EAL_PADDING_NOT_SUPPORT;
}
ret = MODES_SetPaddingCheck(*(int32_t *)val);
if (ret != CRYPT_SUCCESS) {
return ret;
}
modeCtx->pad = *(int32_t *)val;
return CRYPT_SUCCESS;
case CRYPT_CTRL_GET_PADDING:
if (val == NULL || valLen != sizeof(int32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
*(int32_t *)val = modeCtx->pad;
return CRYPT_SUCCESS;
case CRYPT_CTRL_GET_BLOCKSIZE:
if (val == NULL || valLen != sizeof(uint32_t)) {
return CRYPT_INVALID_ARG;
}
*(int32_t *)val = modeCtx->commonCtx.ciphMeth->blockSize;
return CRYPT_SUCCESS;
default:
return MODES_CipherCtrl(modeCtx, cmd, val, valLen);
}
}
void MODES_ECB_FreeCtx(MODES_CipherCtx *modeCtx)
{
MODES_CipherFreeCtx(modeCtx);
}
int32_t MODES_ECB_InitCtxEx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, void *param, bool enc)
{
(void)param;
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_SM4_ECB:
#ifdef HITLS_CRYPTO_SM4
return SM4_ECB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_ECB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
}
int32_t MODES_ECB_UpdateEx(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_AES128_ECB:
case CRYPT_CIPHER_AES192_ECB:
case CRYPT_CIPHER_AES256_ECB:
#ifdef HITLS_CRYPTO_AES
return AES_ECB_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
case CRYPT_CIPHER_SM4_ECB:
#ifdef HITLS_CRYPTO_SM4
return SM4_ECB_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_ECB_Update(modeCtx, in, inLen, out, outLen);
}
}
int32_t MODES_ECB_FinalEx(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_AES128_ECB:
case CRYPT_CIPHER_AES192_ECB:
case CRYPT_CIPHER_AES256_ECB:
#ifdef HITLS_CRYPTO_AES
return AES_ECB_Final(modeCtx, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
case CRYPT_CIPHER_SM4_ECB:
#ifdef HITLS_CRYPTO_SM4
return SM4_ECB_Final(modeCtx, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_ECB_Final(modeCtx, out, outLen);
}
}
#endif // end HITLS_CRYPTO_ECB
| 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/modes_ecb.c | C | unknown | 7,331 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_GCM
#include <stdint.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "crypt_modes_gcm.h"
#include "modes_local.h"
#include "crypt_modes.h"
int32_t MODES_GCM_SetKey(MODES_CipherGCMCtx *ctx, const uint8_t *key, uint32_t len)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = ctx->ciphMeth->setEncryptKey(ctx->ciphCtx, key, len);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
return MODES_GCM_InitHashTable(ctx);
}
int32_t MODES_GCM_InitHashTable(MODES_CipherGCMCtx *ctx)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
uint8_t gcmKey[GCM_BLOCKSIZE] = { 0 };
int32_t ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, gcmKey, gcmKey, GCM_BLOCKSIZE);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
GcmTableGen4bit(gcmKey, ctx->hTable);
ctx->tagLen = GCM_BLOCKSIZE;
BSL_SAL_CleanseData(gcmKey, sizeof(gcmKey));
return CRYPT_SUCCESS;
}
// Update the number of usage times.
static int32_t CheckUseCnt(const MODES_CipherGCMCtx *ctx)
{
// 128, 120, 112, 104, or 96 that is 12 byte - 16 byte
if (ctx->cryptCnt == GCM_MAX_INVOCATIONS_TIMES) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_KEYUSE_TOOMANY_TIME);
return CRYPT_MODES_KEYUSE_TOOMANY_TIME;
}
return CRYPT_SUCCESS;
}
/**
* NIST_800-38D-5.2
* 1 ≤ len(IV) ≤ 2^64 - 1 (bit)
* It is currently restricted to no more than 2^32 - 1 bytes
*/
int32_t MODES_GCM_SetIv(MODES_CipherGCMCtx *ctx, const uint8_t *iv, uint32_t ivLen)
{
if (iv == NULL || ivLen == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = CheckUseCnt(ctx); // Check the number of usage times.
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
uint32_t i;
uint64_t len = (uint64_t)ivLen;
// when ivLen == 0, do reinit, no need to refersh iv
if (len == 12) { // len(IV ) = 96bit = 12byte
const uint8_t ivPad[4] = {0x00, 0x00, 0x00, 0x01};
/* Y0 = IV || 0^31 || 1 if len(IV ) = 96 = 12byte */
(void)memcpy_s(ctx->iv, GCM_BLOCKSIZE, iv, 12);
(void)memcpy_s(ctx->iv + 12, GCM_BLOCKSIZE - 12, ivPad, sizeof(ivPad)); // pad last 4bit(base = 12)
} else {
/* Y0 = GHASH(H, {}, IV ) otherwise */
(void)memset_s(ctx->iv, GCM_BLOCKSIZE, 0, GCM_BLOCKSIZE);
const uint8_t *off = iv;
uint32_t blockLen = ivLen & GCM_BLOCK_MASK;
uint32_t lastLen = ivLen - blockLen;
uint8_t tmp[GCM_BLOCKSIZE] = {0};
if (blockLen > 0) {
GcmHashMultiBlock(ctx->iv, ctx->hTable, off, blockLen);
off += blockLen;
}
if (lastLen > 0) {
for (i = 0; i < lastLen; i++) {
tmp[i] = off[i];
}
GcmHashMultiBlock(ctx->iv, ctx->hTable, tmp, GCM_BLOCKSIZE);
}
len = (uint64_t)ivLen << 3; // bitLen = byteLen << 3
(void)BSL_SAL_CleanseData(tmp, GCM_BLOCKSIZE);
Uint64ToBeBytes(len, tmp + 8); // The last 8 bytes store the length of the IV.
GcmHashMultiBlock(ctx->iv, ctx->hTable, tmp, GCM_BLOCKSIZE);
}
/**
* NIST_800-38D-7.1
* GCTR(J0)
*/
ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->iv, ctx->ek0, GCM_BLOCKSIZE);
/**
* NIST_800-38D-7.1
* INC32
* the 32-bit incrementing function is applied to the pre-counter block
* to produce the initial counter block for an invocation of the GCTR
* function on the plaintext
*/
uint32_t ctr = GET_UINT32_BE(ctx->iv, 12); // Offset of 12 bytes. Use the last four bytes.
ctr++;
PUT_UINT32_BE(ctr, ctx->iv, 12); // Writeback of offset 12 bytes
// Reset information.
(void)memset_s(ctx->ghash, GCM_BLOCKSIZE, 0, GCM_BLOCKSIZE);
ctx->aadLen = 0;
(void)memset_s(ctx->last, GCM_BLOCKSIZE, 0, GCM_BLOCKSIZE);
ctx->lastLen = 0;
ctx->plaintextLen = 0;
(void)memset_s(ctx->remCt, GCM_BLOCKSIZE, 0, GCM_BLOCKSIZE);
// Clear sensitive information.
BSL_SAL_CleanseData(&ctr, sizeof(uint32_t));
return CRYPT_SUCCESS;
}
/**
* NIST_800-38D-5.2
* len(AAD) ≤ 2^64 - 1 (bit)
* Currently, it is restricted to no more than 2^32 - 1 bytes.
*/
static int32_t SetAad(MODES_CipherGCMCtx *ctx, const uint8_t *aad, uint32_t aadLen)
{
if (aad == NULL && aadLen != 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
const uint8_t *off = aad;
uint32_t i;
if (ctx->aadLen != 0 || ctx->plaintextLen != 0) { // aad is set
BSL_ERR_PUSH_ERROR(CRYPT_MODES_AAD_REPEAT_SET_ERROR);
return CRYPT_MODES_AAD_REPEAT_SET_ERROR;
}
uint32_t blockLen = aadLen & GCM_BLOCK_MASK;
uint32_t lastLen = aadLen - blockLen;
if (blockLen > 0) {
GcmHashMultiBlock(ctx->ghash, ctx->hTable, off, blockLen);
off += blockLen;
}
if (lastLen > 0) {
uint8_t temp[GCM_BLOCKSIZE] = {0};
for (i = 0; i < lastLen; i++) {
temp[i] = off[i];
}
GcmHashMultiBlock(ctx->ghash, ctx->hTable, temp, GCM_BLOCKSIZE);
}
ctx->aadLen = aadLen;
return CRYPT_SUCCESS;
}
// Overflow occurs when the encryption length is determined and the encrypted length information is updated.
int32_t CryptLenCheckAndRefresh(MODES_CipherGCMCtx *ctx, uint32_t len)
{
// The length of len is only 32 bits. This calculation does not cause overflow.
uint64_t plaintextLen = ctx->plaintextLen + len;
if (plaintextLen > GCM_MAX_COMBINED_LENGTH) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CRYPTLEN_OVERFLOW);
return CRYPT_MODES_CRYPTLEN_OVERFLOW;
}
ctx->plaintextLen = plaintextLen;
return CRYPT_SUCCESS;
}
static void GcmXorInEncrypt(XorCryptData *data, uint32_t len)
{
uint32_t i;
for (i = 0; i < len; i++) {
data->out[i] = data->in[i] ^ data->ctr[i];
data->tag[i] = data->out[i];
}
}
static void GcmXorInDecrypt(XorCryptData *data, uint32_t len)
{
uint32_t i;
for (i = 0; i < len; i++) {
data->tag[i] = data->in[i];
data->out[i] = data->in[i] ^ data->ctr[i];
}
}
// Process the remaining data in the last update.
uint32_t MODES_GCM_LastHandle(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc)
{
uint32_t lastLen = 0;
if (ctx->lastLen > 0) {
XorCryptData data;
lastLen = (ctx->lastLen < len) ? ctx->lastLen : len;
data.in = in;
data.out = out;
data.ctr = &(ctx->last[GCM_BLOCKSIZE - ctx->lastLen]);
data.tag = &(ctx->remCt[GCM_BLOCKSIZE - ctx->lastLen]);
if (enc) { // ctx->lastLen must be smaller than the GCM_BLOCKSIZE
GcmXorInEncrypt(&data, lastLen);
} else {
GcmXorInDecrypt(&data, lastLen);
}
// Refresh the remaining length.
ctx->lastLen -= lastLen;
if (ctx->lastLen == 0) {
GcmHashMultiBlock(ctx->ghash, ctx->hTable, ctx->remCt, GCM_BLOCKSIZE);
}
}
return lastLen;
}
static void GcmMultiBlockCrypt(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc)
{
uint32_t blockLen = len;
const uint8_t *dataIn = in;
uint8_t *dataOut = out;
// count information, last 32 bits of the IV, with an offset of 12 bytes (16-4 = 12)
uint32_t ctr = GET_UINT32_BE(ctx->iv, 12);
if (enc == false) {
GcmHashMultiBlock(ctx->ghash, ctx->hTable, in, len);
}
while (blockLen > 0) {
ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->iv, ctx->last, GCM_BLOCKSIZE);
DATA64_XOR(dataIn, ctx->last, dataOut, GCM_BLOCKSIZE);
/**
* NIST_800-38D-7.1
* INC32
*/
ctr++;
PUT_UINT32_BE(ctr, ctx->iv, 12); // Offset of 12 bytes. Use the last four bytes.
// Refresh the remaining length.
blockLen -= GCM_BLOCKSIZE;
// offset
dataIn += GCM_BLOCKSIZE;
dataOut += GCM_BLOCKSIZE;
}
if (enc) {
GcmHashMultiBlock(ctx->ghash, ctx->hTable, out, len);
}
// Clear sensitive information.
BSL_SAL_CleanseData(&ctr, sizeof(uint32_t));
}
// enc: true: the encryption operation, false: the decryption operation
static int32_t MODES_GCM_Crypt(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc)
{
if (ctx == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len != 0 && in == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = CryptLenCheckAndRefresh(ctx, len);
if (ret != CRYPT_SUCCESS) {
return ret;
}
uint32_t lastLen = MODES_GCM_LastHandle(ctx, in, out, len, enc);
// Data processing is complete. Exit.
if (lastLen == len) {
return CRYPT_SUCCESS;
}
XorCryptData data;
data.in = in + lastLen;
data.out = out + lastLen;
data.ctr = ctx->last;
data.tag = ctx->remCt;
uint32_t multiBlockLen = (len - lastLen) & GCM_BLOCK_MASK;
if (multiBlockLen > 0) {
GcmMultiBlockCrypt(ctx, data.in, data.out, multiBlockLen, enc);
data.in += multiBlockLen;
data.out += multiBlockLen;
}
uint32_t remLen = len - lastLen - multiBlockLen;
if (remLen > 0) {
// count information, last 32 bits of the IV, with an offset of 12 bytes (16-4 = 12)
uint32_t ctr = GET_UINT32_BE(ctx->iv, 12);
(void)ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->iv, ctx->last, GCM_BLOCKSIZE);
if (enc) {
GcmXorInEncrypt(&data, remLen);
} else {
GcmXorInDecrypt(&data, remLen);
}
/**
* NIST_800-38D-7.1
* INC32
*/
ctr++;
PUT_UINT32_BE(ctr, ctx->iv, 12); // Offset of 12 bytes. Use the last four bytes.
// Clear sensitive information.
BSL_SAL_CleanseData(&ctr, sizeof(uint32_t));
}
ctx->lastLen = (remLen > 0) ? (GCM_BLOCKSIZE - remLen) : 0;
return CRYPT_SUCCESS;
}
static void GcmPad(MODES_CipherGCMCtx *ctx)
{
// S = GHASHH (A || 0v || C || 0u || [len(A)]64 || [len(C)]64).
if (ctx->lastLen != 0) {
uint32_t offset = GCM_BLOCKSIZE - ctx->lastLen;
(void)memset_s(ctx->remCt + offset, GCM_BLOCKSIZE - offset, 0, ctx->lastLen);
GcmHashMultiBlock(ctx->ghash, ctx->hTable, ctx->remCt, GCM_BLOCKSIZE);
}
uint64_t aadLen = (uint64_t)(ctx->aadLen) << 3; // bitLen = byteLen << 3
uint64_t plaintextLen = ctx->plaintextLen << 3; // bitLen = byteLen << 3
uint8_t padBuf[GCM_BLOCKSIZE];
Uint64ToBeBytes(aadLen, padBuf);
Uint64ToBeBytes(plaintextLen, padBuf + 8); // The last 64 bits (8 bytes) is the length of the ciphertext.
GcmHashMultiBlock(ctx->ghash, ctx->hTable, padBuf, GCM_BLOCKSIZE);
}
static int32_t SetTagLen(MODES_CipherGCMCtx *ctx, const uint8_t *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len != sizeof(uint32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_TAGLEN_ERROR);
return CRYPT_MODES_CTRL_TAGLEN_ERROR;
}
/**
* NIST_800-38D-5.2.1.2
* The bit length of the tag, denoted t, is a security parameter, as discussed in Appendix B.
* In general, t may be any one of the following five values: 128, 120, 112, 104, or 96. For certain
* applications, t may be 64 or 32; guidance for the use of these two tag lengths, including
* requirements on the length of the input data and the lifetime of the ciphCtx in these cases,
* is given in Appendix C
*/
uint32_t tagLen = *((const uint32_t *)val);
// 32bit is 4 bytes, 64bit is 8 bytes, 128, 120, 112, 104, or 96 is 12byte - 16byte
if (tagLen == 4 || tagLen == 8 || (tagLen >= 12 && tagLen <= 16)) {
ctx->tagLen = (uint8_t)tagLen;
return CRYPT_SUCCESS;
}
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_TAGLEN_ERROR);
return CRYPT_MODES_CTRL_TAGLEN_ERROR;
}
static int32_t GetTag(MODES_CipherGCMCtx *ctx, uint8_t *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len != ctx->tagLen) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_TAGLEN_ERROR);
return CRYPT_MODES_TAGLEN_ERROR;
}
ctx->cryptCnt++; // The encryption/decryption process ends. Key usage times + 1
GcmPad(ctx);
uint32_t i;
for (i = 0; i < len; i++) {
val[i] = ctx->ghash[i] ^ ctx->ek0[i];
}
return CRYPT_SUCCESS;
}
int32_t MODES_GCM_Encrypt(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
return MODES_GCM_Crypt(ctx, in, out, len, true);
}
int32_t MODES_GCM_Decrypt(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
return MODES_GCM_Crypt(ctx, in, out, len, false);
}
int32_t MODES_GCM_Ctrl(MODES_GCM_Ctx *modeCtx, int32_t opt, void *val, uint32_t len)
{
if (modeCtx == NULL) {
return CRYPT_NULL_INPUT;
}
switch (opt) {
case CRYPT_CTRL_SET_IV:
case CRYPT_CTRL_REINIT_STATUS:
return MODES_GCM_SetIv(&modeCtx->gcmCtx, val, len);
case CRYPT_CTRL_SET_TAGLEN:
return SetTagLen(&modeCtx->gcmCtx, val, len);
case CRYPT_CTRL_SET_AAD:
return SetAad(&modeCtx->gcmCtx, val, len);
case CRYPT_CTRL_GET_TAG:
return GetTag(&modeCtx->gcmCtx, val, len);
case CRYPT_CTRL_GET_BLOCKSIZE:
if (val == NULL || len != sizeof(uint32_t)) {
return CRYPT_INVALID_ARG;
}
*(int32_t *)val = 1;
return CRYPT_SUCCESS;
default:
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_TYPE_ERROR);
return CRYPT_MODES_CTRL_TYPE_ERROR;
}
}
MODES_GCM_Ctx *MODES_GCM_NewCtx(int32_t algId)
{
const EAL_SymMethod *method = EAL_GetSymMethod(algId);
if (method == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return NULL;
}
MODES_GCM_Ctx *ctx = BSL_SAL_Calloc(1, sizeof(MODES_GCM_Ctx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return ctx;
}
ctx->algId = algId;
ctx->gcmCtx.ciphCtx = BSL_SAL_Calloc(1, method->ctxSize);
if (ctx->gcmCtx.ciphCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
BSL_SAL_Free(ctx);
return NULL;
}
ctx->gcmCtx.ciphMeth = method;
return ctx;
}
int32_t MODES_GCM_InitCtx(MODES_GCM_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = MODES_GCM_SetKey(&modeCtx->gcmCtx, key, keyLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
ret = MODES_GCM_SetIv(&modeCtx->gcmCtx, iv, ivLen);
if (ret != CRYPT_SUCCESS) {
(void)MODES_GCM_DeInitCtx(modeCtx);
return ret;
}
modeCtx->enc = enc;
return ret;
}
int32_t MODES_GCM_Update(MODES_GCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(modeCtx->enc ? MODES_GCM_Encrypt : MODES_GCM_Decrypt, &modeCtx->gcmCtx,
in, inLen, out, outLen);
}
int32_t MODES_GCM_Final(MODES_GCM_Ctx *modeCtx, uint8_t *out, uint32_t *outLen)
{
(void) modeCtx;
(void) out;
(void) outLen;
return CRYPT_EAL_CIPHER_FINAL_WITH_AEAD_ERROR;
}
int32_t MODES_GCM_DeInitCtx(MODES_GCM_Ctx *modeCtx)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t algId = modeCtx->algId;
void *ciphCtx = modeCtx->gcmCtx.ciphCtx;
const EAL_SymMethod *ciphMeth = modeCtx->gcmCtx.ciphMeth;
modeCtx->gcmCtx.ciphMeth->cipherDeInitCtx(ciphCtx);
BSL_SAL_CleanseData((void *)(&(modeCtx->gcmCtx)), sizeof(MODES_CipherGCMCtx));
modeCtx->gcmCtx.ciphCtx = ciphCtx;
modeCtx->gcmCtx.ciphMeth = ciphMeth;
modeCtx->algId = algId;
return CRYPT_SUCCESS;
}
void MODES_GCM_FreeCtx(MODES_GCM_Ctx *modeCtx)
{
if (modeCtx == NULL) {
return;
}
(void)BSL_SAL_ClearFree(modeCtx->gcmCtx.ciphCtx, modeCtx->gcmCtx.ciphMeth->ctxSize);
(void)BSL_SAL_CleanseData(modeCtx, sizeof(MODES_GCM_Ctx));
BSL_SAL_Free(modeCtx);
}
int32_t MODES_GCM_InitCtxEx(MODES_GCM_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, void *param, bool enc)
{
(void)param;
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_SM4_GCM:
#ifdef HITLS_CRYPTO_SM4
return SM4_GCM_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_GCM_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
}
int32_t MODES_GCM_UpdateEx(MODES_GCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_AES128_GCM:
case CRYPT_CIPHER_AES192_GCM:
case CRYPT_CIPHER_AES256_GCM:
#ifdef HITLS_CRYPTO_AES
return AES_GCM_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
case CRYPT_CIPHER_SM4_GCM:
#ifdef HITLS_CRYPTO_SM4
return SM4_GCM_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_GCM_Update(modeCtx, in, inLen, out, outLen);
}
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/modes_gcm.c | C | unknown | 18,606 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef MODES_LOCAL_H
#define MODES_LOCAL_H
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_MODES
#include <stdint.h>
#include <stdbool.h>
#include "crypt_local_types.h"
#include "crypt_modes_xts.h"
#include "crypt_modes_cbc.h"
#include "crypt_modes_ccm.h"
#include "crypt_modes_cfb.h"
#include "crypt_modes_chacha20poly1305.h"
#include "crypt_modes_ctr.h"
#include "crypt_modes_ecb.h"
#include "crypt_modes_gcm.h"
#include "crypt_modes_ofb.h"
#include "crypt_modes.h"
#include "eal_cipher_local.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
#define UPDATE_VALUES(l, i, o, len) \
do { \
(l) -= (len); \
(i) += (len); \
(o) += (len); \
} while (false)
MODES_CipherCtx *MODES_CipherNewCtx(int32_t algId);
int32_t MODES_CipherInitCommonCtx(MODES_CipherCommonCtx *modeCtx, void *setSymKey, void *keyCtx,
const uint8_t *key, uint32_t keyLen, const uint8_t *iv, uint32_t ivLen);
int32_t MODES_CipherInitCtx(MODES_CipherCtx *ctx, void *setSymKey, void *keyCtx, const uint8_t *key,
uint32_t keyLen, const uint8_t *iv, uint32_t ivLen, bool enc);
int32_t MODE_CheckUpdateParam(uint8_t blockSize, uint32_t cacheLen, uint32_t inLen, uint32_t *outLen);
/* Block cipher processing */
int32_t MODES_CipherUpdate(MODES_CipherCtx *modeCtx, void *blockUpdate, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen);
int32_t MODES_BlockPadding(int32_t algId, int32_t padding, uint8_t blockSize, uint8_t *data, uint8_t *dataLen);
int32_t MODES_BlockUnPadding(int32_t padding, const uint8_t *pad, uint32_t padLen, uint32_t *dataLen);
/* Block cipher processing */
int32_t MODES_CipherFinal(MODES_CipherCtx *modeCtx, void *blockUpdate, uint8_t *out, uint32_t *outLen);
int32_t MODES_CipherDeInitCtx(MODES_CipherCtx *modeCtx);
void MODES_CipherFreeCtx(MODES_CipherCtx *modeCtx);
int32_t MODES_CipherCtrl(MODES_CipherCtx *ctx, int32_t opt, void *val, uint32_t len);
int32_t MODES_CipherStreamProcess(void *processFuncs, void *ctx, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen);
static inline void MODE_IncCounter(uint8_t *counter, uint32_t counterLen)
{
uint32_t i = counterLen;
uint16_t carry = 1;
while (i > 0) {
i--;
carry += counter[i];
counter[i] = carry & (0xFFu);
carry >>= 8; // Take the upper 8 bits.
}
}
int32_t MODES_SetEncryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint32_t len);
int32_t MODES_SetDecryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint32_t len);
int32_t MODES_SetPaddingCheck(int32_t pad);
#ifdef HITLS_CRYPTO_SM4
int32_t MODES_SM4_SetEncryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint32_t len);
int32_t MODES_SM4_SetDecryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint32_t len);
#endif
// cfb
#ifdef HITLS_CRYPTO_CFB
int32_t MODES_CFB_Encrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_CFB_Decrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
#endif
// ctr
#ifdef HITLS_CRYPTO_CTR
uint32_t MODES_CTR_LastHandle(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
void MODES_CTR_RemHandle(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
#endif
// gcm
#ifdef HITLS_CRYPTO_GCM
void GcmTableGen4bit(uint8_t key[GCM_BLOCKSIZE], MODES_GCM_GF128 hTable[16]);
void GcmHashMultiBlock(uint8_t t[GCM_BLOCKSIZE], const MODES_GCM_GF128 hTable[16], const uint8_t *in, uint32_t inLen);
uint32_t MODES_GCM_LastHandle(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc);
int32_t MODES_GCM_SetIv(MODES_CipherGCMCtx *ctx, const uint8_t *iv, uint32_t ivLen);
int32_t CryptLenCheckAndRefresh(MODES_CipherGCMCtx *ctx, uint32_t len);
#endif
// xts
#ifdef HITLS_CRYPTO_XTS
int32_t MODES_XTS_CheckPara(const uint8_t *key, uint32_t len, const uint8_t *iv);
int32_t MODES_XTS_SetIv(MODES_CipherXTSCtx *ctx, const uint8_t *val, uint32_t len);
int32_t MODES_XTS_SetEncryptKey(MODES_CipherXTSCtx *ctx, const uint8_t *key, uint32_t len);
int32_t MODES_XTS_SetDecryptKey(MODES_CipherXTSCtx *ctx, const uint8_t *key, uint32_t len);
#endif
#ifdef HITLS_CRYPTO_CBC
int32_t AES_CBC_EncryptBlock(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t AES_CBC_DecryptBlock(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_CBC_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_CBC_Decrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODE_SM4_CBC_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODE_SM4_CBC_Decrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
#endif
#ifdef HITLS_CRYPTO_CCM
int32_t MODES_CCM_Encrypt(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_CCM_Decrypt(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_AES_CCM_Encrypt(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_AES_CCM_Decrypt(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
#endif
#ifdef HITLS_CRYPTO_CFB
int32_t MODES_CFB_BitCrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc);
int32_t MODE_AES_CFB_Decrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODE_SM4_CFB_Encrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODE_SM4_CFB_Decrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
#endif
#if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
int32_t MODES_CHACHA20POLY1305_Encrypt(MODES_CipherChaChaPolyCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_CHACHA20POLY1305_Decrypt(MODES_CipherChaChaPolyCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_CHACHA20POLY1305_SetEncryptKey(MODES_CipherChaChaPolyCtx *ctx, const uint8_t *key, uint32_t len);
int32_t MODES_CHACHA20POLY1305_SetDecryptKey(MODES_CipherChaChaPolyCtx *ctx, const uint8_t *key, uint32_t len);
#endif
#ifdef HITLS_CRYPTO_CTR
int32_t MODES_CTR_Crypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t AES_CTR_EncryptBlock(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODE_SM4_CTR_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
#endif
#ifdef HITLS_CRYPTO_ECB
int32_t MODES_ECB_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_ECB_Decrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t AES_ECB_EncryptBlock(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t AES_ECB_DecryptBlock(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODE_SM4_ECB_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODE_SM4_ECB_Decrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
#endif
#ifdef HITLS_CRYPTO_GCM
int32_t MODES_GCM_Encrypt(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_GCM_Decrypt(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t AES_GCM_EncryptBlock(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t AES_GCM_DecryptBlock(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_SM4_GCM_DecryptBlock(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
#endif
#ifdef HITLS_CRYPTO_OFB
int32_t MODES_OFB_Crypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
#endif
#ifdef HITLS_CRYPTO_XTS
int32_t MODES_XTS_Encrypt(MODES_CipherXTSCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_XTS_Decrypt(MODES_CipherXTSCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_AES_XTS_Encrypt(MODES_CipherXTSCtx *xtsCtx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_AES_XTS_Decrypt(MODES_CipherXTSCtx *xtsCtx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_SM4_XTS_Encrypt(MODES_CipherXTSCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_SM4_XTS_Decrypt(MODES_CipherXTSCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
#endif
#ifdef __cplusplus
}
#endif // __cplusplus
#endif
#endif
| 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/modes_local.h | C | unknown | 9,184 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_OFB
#include "securec.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "modes_local.h"
#include "crypt_modes_ofb.h"
int32_t MODES_OFB_Crypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret;
const uint8_t *input = in;
uint32_t blockSize = ctx->blockSize;
uint32_t left = len;
uint8_t *output = out;
uint32_t i;
// If the remaining encrypted iv is not used up last time, use that part to perform XOR.
while (left > 0 && ctx->offset > 0) {
*(output++) = ctx->iv[ctx->offset] ^ *(input++);
left--;
ctx->offset = (ctx->offset + 1) % blockSize;
}
while (left > 0) {
// Encrypt the IV.
ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->iv, ctx->iv, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
if (left >= blockSize) {
DATA32_XOR(input, ctx->iv, output, blockSize);
UPDATE_VALUES(left, input, output, blockSize);
} else {
for (i = 0; i < left; i++) {
output[i] = input[i] ^ ctx->iv[i];
}
ctx->offset = (uint8_t)left;
left = 0;
}
}
return CRYPT_SUCCESS;
}
MODES_CipherCtx *MODES_OFB_NewCtx(int32_t algId)
{
return MODES_CipherNewCtx(algId);
}
int32_t MODES_OFB_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_CipherInitCtx(modeCtx, modeCtx->commonCtx.ciphMeth->setEncryptKey,
modeCtx->commonCtx.ciphCtx, key, keyLen, iv, ivLen, enc);
}
int32_t MODES_OFB_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(MODES_OFB_Crypt, &modeCtx->commonCtx,
in, inLen, out, outLen);
}
int32_t MODES_OFB_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
(void) modeCtx;
(void) out;
*outLen = 0;
return CRYPT_SUCCESS;
}
int32_t MODES_OFB_DeInitCtx(MODES_CipherCtx *modeCtx)
{
return MODES_CipherDeInitCtx(modeCtx);
}
int32_t MODES_OFB_Ctrl(MODES_CipherCtx *modeCtx, int32_t cmd, void *val, uint32_t valLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (cmd) {
case CRYPT_CTRL_GET_BLOCKSIZE:
if (val == NULL || valLen != sizeof(uint32_t)) {
return CRYPT_INVALID_ARG;
}
*(int32_t *)val = 1;
return CRYPT_SUCCESS;
default:
return MODES_CipherCtrl(modeCtx, cmd, val, valLen);;
}
}
void MODES_OFB_FreeCtx(MODES_CipherCtx *modeCtx)
{
MODES_CipherFreeCtx(modeCtx);
}
int32_t MODES_OFB_InitCtxEx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, void *param, bool enc)
{
(void) param;
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_SM4_OFB:
#ifdef HITLS_CRYPTO_SM4
return SM4_OFB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_OFB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
}
int32_t MODES_OFB_UpdateEx(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_SM4_OFB:
#ifdef HITLS_CRYPTO_SM4
return SM4_OFB_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_OFB_Update(modeCtx, in, inLen, out, outLen);
}
}
#endif // HITLS_CRYPTO_OFB | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/modes_ofb.c | C | unknown | 4,731 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_CBC)
#include "crypt_modes_cbc.h"
#include "modes_local.h"
int32_t AES_CBC_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CBC_Update(modeCtx, in, inLen, out, outLen);
}
int32_t AES_CBC_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
return MODES_CBC_Final(modeCtx, out, outLen);
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/noasm_aes_cbc.c | C | unknown | 1,007 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_CCM)
#include "modes_local.h"
#include "crypt_modes_ccm.h"
int32_t AES_CCM_Update(MODES_CCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CCM_Update(modeCtx, in, inLen, out, outLen);
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/noasm_aes_ccm.c | C | unknown | 870 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_CFB)
#include "crypt_modes_cfb.h"
int32_t AES_CFB_Update(MODES_CFB_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CFB_Update(modeCtx, in, inLen, out, outLen);
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/noasm_aes_cfb.c | C | unknown | 845 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_CTR)
#include "crypt_modes_ctr.h"
#include "modes_local.h"
int32_t AES_CTR_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CTR_Update(modeCtx, in, inLen, out, outLen);
}
#endif
| 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/noasm_aes_ctr.c | C | unknown | 873 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_ECB)
#include "crypt_modes_ecb.h"
#include "modes_local.h"
int32_t AES_ECB_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_ECB_Update(modeCtx, in, inLen, out, outLen);
}
int32_t AES_ECB_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
return MODES_ECB_Final(modeCtx, out, outLen);
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/noasm_aes_ecb.c | C | unknown | 1,041 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_GCM)
#include "crypt_modes_gcm.h"
int32_t AES_GCM_Update(MODES_GCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_GCM_Update(modeCtx, in, inLen, out, outLen);
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/noasm_aes_gcm.c | C | unknown | 845 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_XTS)
#include "bsl_err_internal.h"
#include "crypt_errno.h"
#include "crypt_aes.h"
#include "crypt_modes_xts.h"
#include "modes_local.h"
int32_t AES_XTS_Update(MODES_XTS_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_XTS_Update(modeCtx, in, inLen, out, outLen);
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/noasm_aes_xts.c | C | unknown | 950 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_GCM
#include "bsl_sal.h"
#include "crypt_utils.h"
#include "modes_local.h"
/* table[i] = (P^4)*i, P = 0x4000000000000000, i = 0...16 */
static const uint64_t TABLE_P4_BITS[16] = {
0x0000000000000000, 0x1c20000000000000, 0x3840000000000000, 0x2460000000000000,
0x7080000000000000, 0x6ca0000000000000, 0x48c0000000000000, 0x54e0000000000000,
0xe100000000000000, 0xfd20000000000000, 0xd940000000000000, 0xc560000000000000,
0x9180000000000000, 0x8da0000000000000, 0xa9c0000000000000, 0xb5e0000000000000
};
// Calculate n*H, n is in 0 .... 16
void GcmTableGen4bit(uint8_t key[GCM_BLOCKSIZE], MODES_GCM_GF128 hTable[16])
{
uint32_t i;
uint32_t j;
const uint64_t r = 0xE100000000000000;
hTable[0].h = 0;
hTable[0].l = 0;
// The intermediate term of the table (16 / 2 = = 8) is H itself.
hTable[8].h = Uint64FromBeBytes(key);
// The intermediate term of the table (16 / 2 = = 8) is H itself.
hTable[8].l = Uint64FromBeBytes(key + sizeof(uint64_t));
for (i = 4; i > 0; i >>= 1) { // 4-bit table, the value of the 2^n item is calculated first.
// cyclically shift to right by 1bit. The upper 1 bit of h is combined with the lower 63 bits of l.
hTable[i].l = (hTable[ i * 2].h << 63) | (hTable[ i * 2].l >> 1);
hTable[i].h = (hTable[ i * 2].h >> 1) ^ ((hTable[ i * 2].l & 1) * r); // the value of the 2^n item
}
for (i = 1; i < 16; i <<= 1) {
for (j = 1; j < i; j++) {
hTable[i + j].h = hTable[i].h ^ hTable[j].h;
hTable[i + j].l = hTable[i].l ^ hTable[j].l;
}
}
}
// Calculate t = t * H
void GcmHashMultiBlock(uint8_t t[GCM_BLOCKSIZE], const MODES_GCM_GF128 hTable[16], const uint8_t *in, uint32_t inLen)
{
MODES_GCM_GF128 x;
uint8_t r;
uint8_t h, l, tag; // Ciphertext information, digest information, and non-sensitive information.
const uint8_t *tempIn = in;
for (uint32_t i = 0; i < inLen; i += GCM_BLOCKSIZE) {
uint8_t cnt = GCM_BLOCKSIZE - 1;
x.h = 0;
x.l = 0;
while (1) {
tag = t[cnt] ^ tempIn[cnt];
l = tag & 0xf;
h = (tag >> 4) & 0xf;
x.h ^= hTable[l].h;
x.l ^= hTable[l].l;
r = (x.l & 0xf);
// Cyclically shift to right by 4 bits. The upper 4 bits of h is combined with the lower 60 bits of l.
x.l = (x.h << 60) | (x.l >> 4);
x.h = (x.h >> 4); // Cyclically shift to right by 4 bits.
x.h ^= TABLE_P4_BITS[r];
x.h ^= hTable[h].h;
x.l ^= hTable[h].l;
if (cnt == 0) {
break;
}
cnt--;
r = (x.l & 0xf);
// Cyclically shift to right by 4 bits. The upper 4 bits of h is combined with the lower 60 bits of l.
x.l = (x.h << 60) | (x.l >> 4);
x.h = (x.h >> 4); // Cyclically shift to right by 4 bits.
x.h ^= TABLE_P4_BITS[r];
}
tempIn += GCM_BLOCKSIZE;
Uint64ToBeBytes(x.h, t);
Uint64ToBeBytes(x.l, t + 8);
}
// Clear sensitive information.
BSL_SAL_CleanseData(&x, sizeof(MODES_GCM_GF128));
BSL_SAL_CleanseData(&r, sizeof(uint8_t));
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/noasm_ghash.c | C | unknown | 3,822 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
#include "bsl_sal.h"
#include "crypt_utils.h"
#include "poly1305_core.h"
// Information required by initializing the assembly,
// for example, ctx->table. However, the C language does not calculate the table.
void Poly1305InitForAsm(Poly1305Ctx *ctx)
{
(void)ctx;
return;
}
// Operation for blocks. The return value is the length of the remaining unprocessed data.
uint32_t Poly1305Block(Poly1305Ctx *ctx, const uint8_t *data, uint32_t dataLen, uint32_t padbit)
{
uint32_t a[5], r[4];
uint64_t b[8];
// RFC_7539-2.5.1 for loop internal operation
a[0] = ctx->acc[0];
a[1] = ctx->acc[1];
a[2] = ctx->acc[2];
a[3] = ctx->acc[3];
a[4] = ctx->acc[4];
r[0] = ctx->r[0];
r[1] = ctx->r[1];
r[2] = ctx->r[2];
r[3] = ctx->r[3];
const uint8_t *off = data;
uint32_t len = dataLen;
while (len >= POLY1305_BLOCKSIZE) {
// a = acc + inputret
b[0] = (uint64_t)a[0] + GET_UINT32_LE(off, 0);
b[1] = (uint64_t)a[1] + GET_UINT32_LE(off, 4) + (b[0] >> 32);
b[2] = (uint64_t)a[2] + GET_UINT32_LE(off, 8) + (b[1] >> 32);
b[3] = (uint64_t)a[3] + GET_UINT32_LE(off, 12) + (b[2] >> 32);
a[0] = (uint32_t)b[0];
a[1] = (uint32_t)b[1];
a[2] = (uint32_t)b[2];
a[3] = (uint32_t)b[3];
// Upper 32 bits of b[3] carry to a[4]. Because a[4] <= 4, this processing can never overflow
a[4] += (uint32_t)(b[3] >> 32) + padbit;
/* Lower bits of the data product. Because the high bits of each term of r are processed,
there is no carry in the following polynomial multiplication and addition. */
b[0] = (uint64_t)a[0] * r[0];
b[1] = (uint64_t)a[0] * r[1] + (uint64_t)a[1] * r[0];
b[2] = (uint64_t)a[0] * r[2] + (uint64_t)a[1] * r[1] + (uint64_t)a[2] * r[0];
b[3] = (uint64_t)a[0] * r[3] + (uint64_t)a[1] * r[2] + (uint64_t)a[2] * r[1] + (uint64_t)a[3] * r[0];
/**
* Higher bits of the data product. Because the high bits of each term of r are processed,
* there is no carry in the following polynomial multiplication and addition.
*/
// (Ensure that the calculation (b[4] * 5) does not overflow, calculate (a[4] * r[0]) items later.)
b[4] = (uint64_t)a[1] * r[3] + (uint64_t)a[2] * r[2] + (uint64_t)a[3] * r[1];
b[5] = (uint64_t)a[2] * r[3] + (uint64_t)a[3] * r[2] + (uint64_t)a[4] * r[1];
b[6] = (uint64_t)a[3] * r[3] + (uint64_t)a[4] * r[2];
b[7] = (uint64_t)a[4] * r[3];
/**
* The upper bits are multiplied by 5/4, because r1, r[2], r3 is processed,
* so the above values are divisible by 4. Because the high bits of each term of r are processed,
* there is no carry in the following polynomial multiplication and addition: (3 * 5) < 0xF
*/
b[4] = (b[4] >> 2) + b[4];
b[5] = (b[5] >> 2) + b[5];
b[6] = (b[6] >> 2) + b[6];
b[7] = (b[7] >> 2) + b[7];
/* After offset 130 bits, the combination is obtained a0 = b[4] * 5 + b[0]....
Because the high bits of each term of r are processed,
there is no carry in the following polynomial multiplication and addition. */
b[0] += (b[4] & 0xFFFFFFFF);
b[1] += (b[0] >> 32) + (b[4] >> 32) + (b[5] & 0xFFFFFFFF);
b[2] += (b[1] >> 32) + (b[5] >> 32) + (b[6] & 0xFFFFFFFF);
b[3] += (b[2] >> 32) + (b[6] >> 32) + (b[7] & 0xFFFFFFFF);
a[4] = a[4] * r[0] + (uint32_t)(b[3] >> 32) + (uint32_t)(b[7] >> 32);
b[0] = (uint32_t)b[0];
b[1] = (uint32_t)b[1];
b[2] = (uint32_t)b[2];
b[3] = (uint32_t)b[3];
// Shift the upper bits of a4 by 130 bits and then multiply it by 5.
// The amount of a4 data is small and carry cannot be occurred.
b[0] += (a[4] >> 2) + (a[4] & 0xFFFFFFFC);
a[4] &= 0x3;
/* Process carry */
b[1] += (b[0] >> 32);
b[2] += (b[1] >> 32);
b[3] += (b[2] >> 32);
a[4] += (uint32_t)(b[3] >> 32);
a[0] = (uint32_t)b[0];
a[1] = (uint32_t)b[1];
a[2] = (uint32_t)b[2];
a[3] = (uint32_t)b[3];
len -= POLY1305_BLOCKSIZE;
off += POLY1305_BLOCKSIZE;
}
ctx->acc[0] = a[0];
ctx->acc[1] = a[1];
ctx->acc[2] = a[2];
ctx->acc[3] = a[3];
ctx->acc[4] = a[4];
// Clear sensitive information.
BSL_SAL_CleanseData(a, sizeof(a));
BSL_SAL_CleanseData(r, sizeof(r));
BSL_SAL_CleanseData(b, sizeof(b));
return len;
}
void Poly1305Last(Poly1305Ctx *ctx, uint8_t mac[POLY1305_TAGSIZE])
{
uint32_t a[5];
uint64_t b[5];
a[0] = ctx->acc[0];
a[1] = ctx->acc[1];
a[2] = ctx->acc[2];
a[3] = ctx->acc[3];
a[4] = ctx->acc[4];
/* Check whether it is greater than p. */
b[0] = (uint64_t)(a[0]) + 5;
b[1] = a[1] + (b[0] >> 32);
b[2] = a[2] + (b[1] >> 32);
b[3] = a[3] + (b[2] >> 32);
b[4] = a[4] + (b[3] >> 32);
/* Obtain the mask. If there is a carry, the number is greater than p. */
if ((b[4] & 0x4) == 0) { // b[4] & 0x4 is bit131.
b[0] = a[0];
b[1] = a[1];
b[2] = a[2];
b[3] = a[3];
}
// Adding s at the end does not require modulo processing.
b[0] = ctx->s[0] + (b[0] & 0xffffffff);
b[1] = ctx->s[1] + (b[1] & 0xffffffff) + (b[0] >> 32);
b[2] = ctx->s[2] + (b[2] & 0xffffffff) + (b[1] >> 32);
b[3] = ctx->s[3] + (b[3] & 0xffffffff) + (b[2] >> 32);
PUT_UINT32_LE(b[0], mac, 0);
PUT_UINT32_LE(b[1], mac, 4);
PUT_UINT32_LE(b[2], mac, 8);
PUT_UINT32_LE(b[3], mac, 12);
// Clear sensitive information.
BSL_SAL_CleanseData(a, sizeof(a));
BSL_SAL_CleanseData(b, sizeof(b));
}
// Clear the residual sensitive information in the register.
// This function is implemented only when the assembly function is enabled.
void Poly1305CleanRegister(void)
{
return;
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/noasm_poly1305.c | C | unknown | 6,568 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_CBC)
#include "crypt_modes_cbc.h"
#include "modes_local.h"
int32_t SM4_CBC_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CBC_Update(modeCtx, in, inLen, out, outLen);
}
int32_t SM4_CBC_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
return MODES_CBC_Final(modeCtx, out, outLen);
}
int32_t SM4_CBC_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_CBC_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
#endif
| 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/noasm_sm4_cbc.c | C | unknown | 1,219 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_CFB)
#include "crypt_modes_cfb.h"
#include "modes_local.h"
int32_t SM4_CFB_InitCtx(MODES_CFB_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_CFB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
int32_t SM4_CFB_Update(MODES_CFB_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CFB_Update(modeCtx, in, inLen, out, outLen);
}
#endif
| 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/noasm_sm4_cfb.c | C | unknown | 1,078 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_CTR)
#include "crypt_modes_ctr.h"
#include "modes_local.h"
int32_t SM4_CTR_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_CTR_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
int32_t SM4_CTR_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CTR_Update(modeCtx, in, inLen, out, outLen);
}
#endif
| 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/noasm_sm4_ctr.c | C | unknown | 1,082 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_ECB)
#include "crypt_modes_ecb.h"
#include "modes_local.h"
int32_t SM4_ECB_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_ECB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
int32_t SM4_ECB_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_ECB_Update(modeCtx, in, inLen, out, outLen);
}
int32_t SM4_ECB_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
return MODES_ECB_Final(modeCtx, out, outLen);
}
#endif
| 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/noasm_sm4_ecb.c | C | unknown | 1,219 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_GCM)
#include "crypt_modes_gcm.h"
#include "modes_local.h"
int32_t SM4_GCM_InitCtx(MODES_GCM_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_GCM_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
int32_t SM4_GCM_Update(MODES_GCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_GCM_Update(modeCtx, in, inLen, out, outLen);
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/noasm_sm4_gcm.c | C | unknown | 1,078 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_OFB)
#include "crypt_modes_ofb.h"
#include "modes_local.h"
int32_t SM4_OFB_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_OFB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
int32_t SM4_OFB_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_OFB_Update(modeCtx, in, inLen, out, outLen);
}
#endif
| 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/noasm_sm4_ofb.c | C | unknown | 1,083 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_SM4
#include "bsl_err_internal.h"
#include "crypt_sm4.h"
#include "modes_local.h"
/**
* @brief Set the encryption key.
*
* @param ctx [IN] Mode handle
* @param key [IN] Encrypt key
* @param len [IN] Encrypt key length. Only 16 bytes (128 bits) are supported.
* @return Success: CRYPT_SUCCESS
* Other error codes are returned if the operation fails.
*/
int32_t MODES_SM4_SetEncryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint32_t len)
{
return MODES_SetEncryptKey(ctx, key, len);
}
/**
* @brief Set the decryption key.
*
* @param ctx [IN] Mode handle
* @param key [IN] Decrypt key
* @param len [IN] Decrypt key length. Only 16 bytes (128 bits) are supported.
* @return Success: CRYPT_SUCCESS
* Other error codes are returned if the operation fails.
*/
int32_t MODES_SM4_SetDecryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint32_t len)
{
return MODES_SetDecryptKey(ctx, key, len);
}
#endif // HITLS_CRYPTO_SM4
| 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/noasm_sm4_setkey.c | C | unknown | 1,564 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_XTS)
#include "bsl_err_internal.h"
#include "crypt_errno.h"
#include "crypt_sm4.h"
#include "crypt_modes_xts.h"
#include "modes_local.h"
int32_t SM4_XTS_Update(MODES_XTS_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_XTS_Update(modeCtx, in, inLen, out, outLen);
}
int32_t SM4_XTS_InitCtx(MODES_XTS_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_XTS_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/noasm_sm4_xts.c | C | unknown | 1,155 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef POLY1305_CORE_H
#define POLY1305_CORE_H
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
#include "crypt_modes_chacha20poly1305.h"
#include "modes_local.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
#define POLY1305_BLOCKSIZE 16
#define POLY1305_TAGSIZE 16
#define POLY1305_KEYSIZE 32
void Poly1305InitForAsm(Poly1305Ctx *ctx);
uint32_t Poly1305Block(Poly1305Ctx *ctx, const uint8_t *data, uint32_t dataLen, uint32_t padbit);
void Poly1305Last(Poly1305Ctx *ctx, uint8_t mac[POLY1305_TAGSIZE]);
void Poly1305CleanRegister(void);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif // HITLS_CRYPTO_CHACHA20POLY1305
#endif // POLY1305_CORE_H | 2302_82127028/openHiTLS-examples_1508 | crypto/modes/src/poly1305_core.h | C | unknown | 1,266 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CRYPT_PAILLIER_H
#define CRYPT_PAILLIER_H
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_PAILLIER
#include <stdlib.h>
#include <stdint.h>
#include "crypt_bn.h"
#include "crypt_local_types.h"
#include "bsl_params.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cpluscplus */
#define PAILLIER_MAX_MODULUS_BITS 16384
/* Paillier*/
typedef struct PAILLIER_Ctx CRYPT_PAILLIER_Ctx;
typedef struct PAILLIER_Para CRYPT_PAILLIER_Para;
/* Paillier method*/
/**
* @ingroup paillier
* @brief Allocate paillier context memory space.
*
* @retval (CRYPT_PAILLIER_Ctx *) Pointer to the memory space of the allocated context
* @retval NULL Invalid null pointer.
*/
CRYPT_PAILLIER_Ctx *CRYPT_PAILLIER_NewCtx(void);
/**
* @ingroup paillier
* @brief Allocate paillier context memory space.
* @param libCtx [IN] Library context
*
* @retval (CRYPT_PAILLIER_Ctx *) Pointer to the memory space of the allocated context
* @retval NULL Invalid null pointer.
*/
CRYPT_PAILLIER_Ctx *CRYPT_PAILLIER_NewCtxEx(void *libCtx);
/**
* @ingroup paillier
* @brief Copy the Paillier context. After the duplication is complete, call the CRYPT_PAILLIER_FreeCtx to release the memory.
*
* @param ctx [IN] PAILLIER context
*
* @return CRYPT_PAILLIER_Ctx Paillier context pointer
* If the operation fails, a null value is returned.
*/
CRYPT_PAILLIER_Ctx *CRYPT_PAILLIER_DupCtx(CRYPT_PAILLIER_Ctx *keyCtx);
/**
* @ingroup paillier
* @brief Create paillier key parameter structure
*
* @param para [IN] PAILLIER External parameter
*
* @retval (CRYPT_PAILLIER_Para *) Pointer to the allocated memory space of the structure
* @retval NULL Invalid null pointer.
*/
CRYPT_PAILLIER_Para *CRYPT_PAILLIER_NewPara(const CRYPT_PaillierPara *para);
/**
* @ingroup paillier
* @brief release paillier key context structure
*
* @param ctx [IN] Pointer to the context structure to be released. The ctx is set NULL by the invoker.
*/
void CRYPT_PAILLIER_FreeCtx(CRYPT_PAILLIER_Ctx *ctx);
/**
* @ingroup paillier
* @brief Release paillier key parameter structure
*
* @param para [IN] Storage pointer in the parameter structure to be released. The parameter is set NULL by the invoker.
*/
void CRYPT_PAILLIER_FreePara(CRYPT_PAILLIER_Para *para);
/**
* @ingroup paillier
* @brief Set the data of the key parameter structure to the key structure.
*
* @param ctx [OUT] Paillier context structure for which related parameters need to be set
* @param para [IN] Key parameter structure
*
* @retval CRYPT_NULL_INPUT Invalid null pointer input.
* @retval CRYPT_PAILLIER_ERR_KEY_BITS The expected key length does not meet the requirements.
* @retval CRYPT_PAILLIER_ERR_E_VALUE The expected value of e does not meet the requirements.
* @retval CRYPT_MEM_ALLOC_FAIL internal memory allocation error
* @retval CRYPT_SUCCESS set successfully.
*/
int32_t CRYPT_PAILLIER_SetPara(CRYPT_PAILLIER_Ctx *ctx, const CRYPT_PaillierPara *para);
/**
* @ingroup paillier
* @brief Obtain the valid length of the key.
*
* @param ctx [IN] Structure from which the key length is expected to be obtained
*
* @retval 0: The input is incorrect or the corresponding key structure does not have a valid key length.
* @retval uint32_t: Valid key length
*/
uint32_t CRYPT_PAILLIER_GetBits(const CRYPT_PAILLIER_Ctx *ctx);
/**
* @ingroup paillier
* @brief Generate the Paillier key pair.
*
* @param ctx [IN/OUT] paillier context structure
*
* @retval CRYPT_NULL_INPUT Error null pointer input
* @retval CRYPT_PAILLIER_ERR_KEY_BITS The value of e in the context structure does not meet the requirements.
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval BN error An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS The key pair is successfully generated.
*/
int32_t CRYPT_PAILLIER_Gen(CRYPT_PAILLIER_Ctx *ctx);
/**
* @ingroup paillier
* @brief Paillier public key encryption
*
* @param ctx [IN] Paillier context structure
* @param input [IN] Information to be encrypted
* @param inputLen [IN] Length of the information to be encrypted
* @param out [OUT] Pointer to the encrypted information output.
* @param outLen [IN/OUT] Pointer to the length of the encrypted information.
* Before being transferred, the value must be set to the maximum length of the array.
*
* @retval CRYPT_NULL_INPUT Invalid null pointer input
* @retval CRYPT_PAILLIER_NO_KEY_INFO does not contain the key information.
* @retval CRYPT_PAILLIER_ERR_INPUT_VALUE The entered value does not meet the calculation conditions.
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval CRYPT_SECUREC_FAIL A security function error occurs.
* @retval BN error An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS encryption succeeded.
*/
int32_t CRYPT_PAILLIER_PubEnc(const CRYPT_PAILLIER_Ctx *ctx, const uint8_t *input, uint32_t inputLen,
uint8_t *out, uint32_t *outLen);
/**
* @ingroup paillier
* @brief Paillier private key decryption
*
* @param ctx [IN] Paillier context structure
* @param ciphertext [IN] Information to be decrypted
* @param bits [IN] Length of the information to be decrypted
* @param out [OUT] Pointer to the decrypted information output.
* @param outLen [IN/OUT] Pointer to the length of the decrypted information.
* Before being transferred, the value must be set to the maximum length of the array.
*
* @retval CRYPT_NULL_INPUT Invalid null pointer input
* @retval CRYPT_PAILLIER_ERR_DEC_BITS Incorrect length of the encrypted private key.
* @retval CRYPT_PAILLIER_NO_KEY_INFO does not contain the key information.
* @retval CRYPT_PAILLIER_ERR_INPUT_VALUE The entered value does not meet the calculation conditions.
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval CRYPT_SECUREC_FAIL A security function error occurs.
* @retval BN error. An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS Decrypted Successfully
*/
int32_t CRYPT_PAILLIER_PrvDec(const CRYPT_PAILLIER_Ctx *ctx, const BN_BigNum *ciphertext, uint32_t bits,
uint8_t *out, uint32_t *outLen);
/**
* @ingroup paillier
* @brief Paillier Set the private key information.
*
* @param ctx [OUT] paillier context structure
* @param prv [IN] Private key data
*
* @retval CRYPT_NULL_INPUT Error null pointer input
* @retval CRYPT_PAILLIER_ERR_KEY_BITS The key length does not meet the requirements.
* @retval CRYPT_PAILLIER_NO_KEY_INFO does not contain the key information.
* @retval CRYPT_PAILLIER_ERR_INPUT_VALUE The entered value does not meet the calculation conditions.
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval BN error An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS The private key is successfully set.
*/
int32_t CRYPT_PAILLIER_SetPrvKey(CRYPT_PAILLIER_Ctx *ctx, const CRYPT_PaillierPrv *prv);
/**
* @ingroup paillier
* @brief Paillier Set the public key information.
*
* @param ctx [OUT] Paillier context structure
* @param pub [IN] Public key data
*
* @retval CRYPT_NULL_INPUT Error null pointer input
* @retval CRYPT_PAILLIER_ERR_KEY_BITS The key length does not meet the requirements.
* @retval CRYPT_PAILLIER_ERR_INPUT_VALUE The entered value does not meet the calculation conditions.
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval BN error An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS The public key is successfully set.
*/
int32_t CRYPT_PAILLIER_SetPubKey(CRYPT_PAILLIER_Ctx *ctx, const CRYPT_PaillierPub *pub);
/**
* @ingroup paillier
* @brief Paillier Obtain the private key information.
*
* @param ctx [IN] Paillier context structure
* @param prv [OUT] Private key data
*
* @retval CRYPT_NULL_INPUT Invalid null pointer input
* @retval BN error An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS The private key is obtained successfully.
*/
int32_t CRYPT_PAILLIER_GetPrvKey(const CRYPT_PAILLIER_Ctx *ctx, CRYPT_PaillierPrv *prv);
/**
* @ingroup paillier
* @brief Paillier Obtain the public key information.
*
* @param ctx [IN] Paillier context structure
* @param pub [OUT] Public key data
*
* @retval CRYPT_NULL_INPUT Invalid null pointer input
* @retval BN error An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS The public key is obtained successfully.
*/
int32_t CRYPT_PAILLIER_GetPubKey(const CRYPT_PAILLIER_Ctx *ctx, CRYPT_PaillierPub *pub);
#ifdef HITLS_BSL_PARAMS
/**
* @ingroup paillier
* @brief Set the data of the key parameter structure to the key structure.
*
* @param ctx [OUT] Paillier context structure for which related parameters need to be set
* @param para [IN] Key parameter structure
*
* @retval CRYPT_NULL_INPUT Invalid null pointer input.
* @retval CRYPT_PAILLIER_ERR_KEY_BITS The expected key length does not meet the requirements.
* @retval CRYPT_PAILLIER_ERR_E_VALUE The expected value of e does not meet the requirements.
* @retval CRYPT_MEM_ALLOC_FAIL internal memory allocation error
* @retval CRYPT_SUCCESS set successfully.
*/
int32_t CRYPT_PAILLIER_SetParaEx(CRYPT_PAILLIER_Ctx *ctx, const BSL_Param *para);
/**
* @ingroup paillier
* @brief Paillier Set the private key information.
*
* @param ctx [OUT] paillier context structure
* @param prv [IN] Private key data
*
* @retval CRYPT_NULL_INPUT Error null pointer input
* @retval CRYPT_PAILLIER_ERR_KEY_BITS The key length does not meet the requirements.
* @retval CRYPT_PAILLIER_NO_KEY_INFO does not contain the key information.
* @retval CRYPT_PAILLIER_ERR_INPUT_VALUE The entered value does not meet the calculation conditions.
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval BN error An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS The private key is successfully set.
*/
int32_t CRYPT_PAILLIER_SetPrvKeyEx(CRYPT_PAILLIER_Ctx *ctx, const BSL_Param *para);
/**
* @ingroup paillier
* @brief Paillier Set the public key information.
*
* @param ctx [OUT] Paillier context structure
* @param pub [IN] Public key data
*
* @retval CRYPT_NULL_INPUT Error null pointer input
* @retval CRYPT_PAILLIER_ERR_KEY_BITS The key length does not meet the requirements.
* @retval CRYPT_PAILLIER_ERR_INPUT_VALUE The entered value does not meet the calculation conditions.
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval BN error An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS The public key is successfully set.
*/
int32_t CRYPT_PAILLIER_SetPubKeyEx(CRYPT_PAILLIER_Ctx *ctx, const BSL_Param *para);
/**
* @ingroup paillier
* @brief Paillier Obtain the private key information.
*
* @param ctx [IN] Paillier context structure
* @param prv [OUT] Private key data
*
* @retval CRYPT_NULL_INPUT Invalid null pointer input
* @retval BN error An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS The private key is obtained successfully.
*/
int32_t CRYPT_PAILLIER_GetPrvKeyEx(const CRYPT_PAILLIER_Ctx *ctx, BSL_Param *para);
/**
* @ingroup paillier
* @brief Paillier Obtain the public key information.
*
* @param ctx [IN] Paillier context structure
* @param pub [OUT] Public key data
*
* @retval CRYPT_NULL_INPUT Invalid null pointer input
* @retval BN error An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS The public key is obtained successfully.
*/
int32_t CRYPT_PAILLIER_GetPubKeyEx(const CRYPT_PAILLIER_Ctx *ctx, BSL_Param *para);
#endif
/**
* @ingroup paillier
* @brief PAILLIER public key encryption
*
* @param ctx [IN] PAILLIER context structure
* @param data [IN] Information to be encrypted
* @param dataLen [IN] Length of the information to be encrypted
* @param out [OUT] Pointer to the encrypted information output.
* @param outLen [OUT] Pointer to the length of the encrypted information
*
* @retval CRYPT_NULL_INPUT Invalid null pointer input
* @retval CRYPT_PAILLIER_NO_KEY_INFO does not contain the key information.
* @retval CRYPT_PAILLIER_ERR_INPUT_VALUE The entered value does not meet the calculation conditions.
* @retval CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH Outbuf Insufficient
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval CRYPT_SECUREC_FAIL A safe function error occurs.
* @retval BN error. An error occurs in the internal BigNum operation.
* @retval CRYPT_EAL_ALG_NOT_SUPPORT does not register the encryption method.
* @retval CRYPT_SUCCESS encryption succeeded.
*/
int32_t CRYPT_PAILLIER_Encrypt(CRYPT_PAILLIER_Ctx *ctx, const uint8_t *data, uint32_t dataLen,
uint8_t *out, uint32_t *outLen);
/**
* @ingroup paillier
* @brief PAILLIER private key decryption
*
* @param ctx [IN] PAILLIER context structure
* @param data [IN] Information to be decrypted
* @param dataLen [IN] Length of the information to be decrypted
* @param out [OUT] Pointer to the output information after decryption.
* @param outLen [OUT] Pointer to the length of the decrypted information
*
* @retval CRYPT_NULL_INPUT Error null pointer input
* @retval CRYPT_PAILLIER_NO_KEY_INFO does not contain the key information.
* @retval CRYPT_PAILLIER_ERR_INPUT_VALUE The entered value does not meet the calculation conditions.
* @retval CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH Outbuf Insufficient
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval CRYPT_SECUREC_FAIL A security function error occurs.
* @retval CRYPT_EAL_ALG_NOT_SUPPORT does not register the decryption method.
* @retval BN error. An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS Decryption succeeded.
*/
int32_t CRYPT_PAILLIER_Decrypt(CRYPT_PAILLIER_Ctx *ctx, const uint8_t *data, uint32_t dataLen,
uint8_t *out, uint32_t *outLen);
/**
* @ingroup paillier
* @brief PAILLIER get security bits
*
* @param ctx [IN] PAILLIER Context structure
*
* @retval security bits
*/
int32_t CRYPT_PAILLIER_GetSecBits(const CRYPT_PAILLIER_Ctx *ctx);
/**
* @ingroup paillier
* @brief PAILLIER control function for various operations
*
* @param ctx [IN/OUT] PAILLIER context structure
* @param opt [IN] Control operation type
* @param val [IN/OUT] Parameter value for the operation
* @param len [IN] Length of the parameter value
*
* @retval CRYPT_NULL_INPUT Invalid null pointer input
* @retval CRYPT_PAILLIER_ERR_INPUT_VALUE The entered value does not meet the calculation conditions
* @retval CRYPT_PAILLIER_NO_KEY_INFO Does not contain the key information
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval CRYPT_EAL_ALG_NOT_SUPPORT Operation not supported
* @retval CRYPT_SUCCESS Operation succeeded
*/
int32_t CRYPT_PAILLIER_Ctrl(CRYPT_PAILLIER_Ctx *ctx, int32_t opt, void *val, uint32_t len);
/**
* @ingroup paillier
* @brief PAILLIER homomorphic addition operation (c_res = c1 * c2 mod n^2)
*
* @param ctx [IN] Paillier context structure
* @param input [IN] Addition operands, must include two ciphertext parameters
* @param out [OUT] The result of the addition operation
* @param outLen [IN/OUT] Pointer to the length of the output buffer
*
* @retval CRYPT_NULL_INPUT Any input pointer is NULL
* @retval CRYPT_PAILLIER_NO_KEY_INFO Context does not contain valid public key information
* @retval CRYPT_PAILLIER_ERR_INPUT_VALUE Input ciphertext value is incorrect
* @retval CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH Output buffer length is insufficient
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval CRYPT_SUCCESS Operation succeeded, result is written to out
*/
int32_t CRYPT_PAILLIER_Add(const void *ctx, const BSL_Param *input, uint8_t *out, uint32_t *outLen);
#ifdef __cplusplus
}
#endif
#endif // HITLS_CRYPTO_PAILLIER
#endif // CRYPT_PAILLIER_H | 2302_82127028/openHiTLS-examples_1508 | crypto/paillier/include/crypt_paillier.h | C | unknown | 17,517 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_PAILLIER
#include "crypt_utils.h"
#include "crypt_paillier.h"
#include "paillier_local.h"
#include "crypt_errno.h"
#include "bsl_sal.h"
#include "securec.h"
#include "bsl_err_internal.h"
int32_t CRYPT_PAILLIER_PubEnc(const CRYPT_PAILLIER_Ctx *ctx, const uint8_t *input, uint32_t inputLen,
uint8_t *out, uint32_t *outLen)
{
int32_t ret;
CRYPT_PAILLIER_PubKey *pubKey = ctx->pubKey;
if (pubKey == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
uint32_t bits = CRYPT_PAILLIER_GetBits(ctx);
BN_Optimizer *optimizer = BN_OptimizerCreate();
if (optimizer == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
BN_BigNum *m = BN_Create(bits);
BN_BigNum *r = BN_Create(bits);
BN_BigNum *gm = BN_Create(bits);
BN_BigNum *rn = BN_Create(bits);
BN_BigNum *result = BN_Create(bits);
BN_BigNum *gcd_result = BN_Create(bits);
bool createFailed = (m == NULL || r == NULL || gm == NULL || rn == NULL || result == NULL || gcd_result == NULL);
if (createFailed) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
ret = CRYPT_MEM_ALLOC_FAIL;
goto EXIT;
}
ret = BN_Bin2Bn(m, input, inputLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
// Check whether m is less than n and non-negative
if (BN_Cmp(m, pubKey->n) >= 0 || BN_IsNegative(m)) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_INPUT_VALUE);
ret = CRYPT_PAILLIER_ERR_INPUT_VALUE;
goto EXIT;
}
ret = BN_RandRangeEx(ctx->libCtx, r, pubKey->n);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
while (true) {
// Check whether r is relatively prime to n, if not, regenerate r
ret = BN_Gcd(gcd_result, r, pubKey->n, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
if (BN_IsOne(gcd_result)) {
break;
}
ret = BN_RandRangeEx(ctx->libCtx, r, pubKey->n);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
}
ret = BN_ModExp(gm, pubKey->g, m, pubKey->n2, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_ModExp(rn, r, pubKey->n, pubKey->n2, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_ModMul(result, gm, rn, pubKey->n2, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_Bn2Bin(result, out, outLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
EXIT:
BN_Destroy(m);
BN_Destroy(r);
BN_Destroy(gm);
BN_Destroy(rn);
BN_Destroy(result);
BN_Destroy(gcd_result);
BN_OptimizerDestroy(optimizer);
return ret;
}
int32_t CRYPT_PAILLIER_PrvDec(const CRYPT_PAILLIER_Ctx *ctx, const BN_BigNum *ciphertext, uint32_t bits,
uint8_t *out, uint32_t *outLen)
{
int32_t ret;
CRYPT_PAILLIER_PrvKey *prvKey = ctx->prvKey;
if (prvKey == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
BN_Optimizer *optimizer = BN_OptimizerCreate();
if (optimizer == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
BN_BigNum *m = BN_Create(bits);
BN_BigNum *result = BN_Create(bits);
bool createFailed = (m == NULL || result == NULL);
if (createFailed) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
ret = CRYPT_MEM_ALLOC_FAIL;
goto EXIT;
}
ret = BN_ModExp(m, ciphertext, prvKey->lambda, prvKey->n2, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_SubLimb(result, m, 1);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_Div(result, NULL, result, prvKey->n, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_ModMul(result, result, prvKey->mu, prvKey->n, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_Bn2Bin(result, out, outLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
EXIT:
BN_Destroy(m);
BN_Destroy(result);
BN_OptimizerDestroy(optimizer);
return ret;
}
static int32_t EncryptInputCheck(const CRYPT_PAILLIER_Ctx *ctx, const uint8_t *input, uint32_t inputLen,
const uint8_t *out, const uint32_t *outLen)
{
if (ctx == NULL || (input == NULL && inputLen != 0) || out == NULL || outLen == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (ctx->pubKey == NULL) {
// Check whether the public key information exists.
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_NO_KEY_INFO);
return CRYPT_PAILLIER_NO_KEY_INFO;
}
// Check whether the length of the out is sufficient to place the encryption information.
uint32_t bits = CRYPT_PAILLIER_GetBits(ctx);
if ((*outLen) < BN_BITS_TO_BYTES(bits)) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH);
return CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH;
}
if (inputLen > BN_BITS_TO_BYTES(bits)) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_ENC_BITS);
return CRYPT_PAILLIER_ERR_ENC_BITS;
}
return CRYPT_SUCCESS;
}
int32_t CRYPT_PAILLIER_Encrypt(CRYPT_PAILLIER_Ctx *ctx, const uint8_t *data, uint32_t dataLen,
uint8_t *out, uint32_t *outLen)
{
int32_t ret = EncryptInputCheck(ctx, data, dataLen, out, outLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
ret = CRYPT_PAILLIER_PubEnc(ctx, data, dataLen, out, outLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
}
static int32_t DecryptInputCheck(const CRYPT_PAILLIER_Ctx *ctx, const uint8_t *data, uint32_t dataLen,
const uint8_t *out, const uint32_t *outLen)
{
if (ctx == NULL || data == NULL || out == NULL || outLen == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (ctx->prvKey == NULL) {
// Check whether the private key information exists.
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_NO_KEY_INFO);
return CRYPT_PAILLIER_NO_KEY_INFO;
}
// Check whether the length of the out is sufficient to place the decryption information.
uint32_t bits = CRYPT_PAILLIER_GetBits(ctx);
if ((*outLen) < BN_BITS_TO_BYTES(bits)) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH);
return CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH;
}
if (dataLen != BN_BITS_TO_BYTES(bits) * 2) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_DEC_BITS);
return CRYPT_PAILLIER_ERR_DEC_BITS;
}
return CRYPT_SUCCESS;
}
static int32_t CRYPT_PAILLIER_CheckCiphertext(const BN_BigNum* ciphertext, const CRYPT_PAILLIER_PrvKey* prvKey)
{
if (BN_Cmp(ciphertext, prvKey->n2) >= 0 || BN_IsNegative(ciphertext)) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_INPUT_VALUE);
return CRYPT_PAILLIER_ERR_INPUT_VALUE;
}
int32_t ret = CRYPT_SUCCESS;
BN_BigNum *gcd_result = BN_Create(BN_Bits(ciphertext));
BN_Optimizer *optimizer = BN_OptimizerCreate();
if (gcd_result == NULL || optimizer == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
ret = CRYPT_MEM_ALLOC_FAIL;
goto EXIT;
}
ret = BN_Gcd(gcd_result, ciphertext, prvKey->n2, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
if (BN_IsOne(gcd_result) == false) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_INPUT_VALUE);
ret = CRYPT_PAILLIER_ERR_INPUT_VALUE;
}
EXIT:
BN_Destroy(gcd_result);
BN_OptimizerDestroy(optimizer);
return ret;
}
int32_t CRYPT_PAILLIER_Decrypt(CRYPT_PAILLIER_Ctx *ctx, const uint8_t *data, uint32_t dataLen,
uint8_t *out, uint32_t *outLen)
{
int32_t ret = DecryptInputCheck(ctx, data, dataLen, out, outLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
uint32_t bits = CRYPT_PAILLIER_GetBits(ctx);
BN_BigNum *c = BN_Create(bits);
if (c == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
ret = BN_Bin2Bn(c, data, dataLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
// check whether c is in Zn2*
ret = CRYPT_PAILLIER_CheckCiphertext(c, ctx->prvKey);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = CRYPT_PAILLIER_PrvDec(ctx, c, bits, out, outLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
EXIT:
BN_Destroy(c);
return ret;
}
static int32_t CRYPT_PAILLIER_GetLen(const CRYPT_PAILLIER_Ctx *ctx, GetLenFunc func, void *val, uint32_t len)
{
if (val == NULL || len != sizeof(int32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
*(int32_t *)val = func(ctx);
return CRYPT_SUCCESS;
}
int32_t CRYPT_PAILLIER_Ctrl(CRYPT_PAILLIER_Ctx *ctx, int32_t opt, void *val, uint32_t len)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (opt) {
case CRYPT_CTRL_GET_BITS:
return CRYPT_PAILLIER_GetLen(ctx, (GetLenFunc)CRYPT_PAILLIER_GetBits, val, len);
case CRYPT_CTRL_GET_SECBITS:
return CRYPT_PAILLIER_GetLen(ctx, (GetLenFunc)CRYPT_PAILLIER_GetSecBits, val, len);
default:
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_CTRL_NOT_SUPPORT_ERROR);
return CRYPT_PAILLIER_CTRL_NOT_SUPPORT_ERROR;
}
}
static int32_t CRYPT_PAILLIER_CheckHECiphertext(const BN_BigNum* ciphertext, const CRYPT_PAILLIER_PubKey* pubKey,
BN_Optimizer *optimizer)
{
if (BN_Cmp(ciphertext, pubKey->n2) >= 0 || BN_IsNegative(ciphertext)) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_INPUT_VALUE);
return CRYPT_PAILLIER_ERR_INPUT_VALUE;
}
int32_t ret = CRYPT_SUCCESS;
BN_BigNum *gcd_result = BN_Create(BN_Bits(ciphertext));
if (gcd_result == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
ret = CRYPT_MEM_ALLOC_FAIL;
goto EXIT;
}
ret = BN_Gcd(gcd_result, ciphertext, pubKey->n2, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
if (BN_IsOne(gcd_result) == false) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_INPUT_VALUE);
ret = CRYPT_PAILLIER_ERR_INPUT_VALUE;
}
EXIT:
BN_Destroy(gcd_result);
return ret;
}
int32_t CRYPT_PAILLIER_Add(const void *ctx, const BSL_Param *input, uint8_t *out, uint32_t *outLen)
{
if (ctx == NULL || input == NULL || out == NULL || outLen == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
const CRYPT_PAILLIER_Ctx *paillierCtx = ctx;
if (paillierCtx == NULL || paillierCtx->pubKey == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_NO_KEY_INFO);
return CRYPT_PAILLIER_NO_KEY_INFO;
}
const BSL_Param *ciphertext1Param = BSL_PARAM_FindConstParam(input, CRYPT_PARAM_PKEY_HE_CIPHERTEXT1);
const BSL_Param *ciphertext2Param = BSL_PARAM_FindConstParam(input, CRYPT_PARAM_PKEY_HE_CIPHERTEXT2);
if (ciphertext1Param == NULL || ciphertext2Param == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_INPUT_VALUE);
return CRYPT_PAILLIER_ERR_INPUT_VALUE;
}
uint32_t bits = CRYPT_PAILLIER_GetBits(paillierCtx);
uint32_t n2Bytes = BN_BITS_TO_BYTES(bits) * 2;
int32_t ret = CRYPT_SUCCESS;
uint8_t *ciphertext1 = (uint8_t *)BSL_SAL_Malloc(n2Bytes);
uint8_t *ciphertext2 = (uint8_t *)BSL_SAL_Malloc(n2Bytes);
uint32_t ciphertext1Len = n2Bytes;
uint32_t ciphertext2Len = n2Bytes;
if (ciphertext1 == NULL || ciphertext2 == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
BSL_SAL_Free(ciphertext1);
BSL_SAL_Free(ciphertext2);
return CRYPT_MEM_ALLOC_FAIL;
}
BN_BigNum *c1 = BN_Create(bits);
BN_BigNum *c2 = BN_Create(bits);
BN_BigNum *result = BN_Create(bits);
if (c1 == NULL || c2 == NULL || result == NULL) {
ret = CRYPT_MEM_ALLOC_FAIL;
BN_Destroy(c1);
BN_Destroy(c2);
BN_Destroy(result);
BSL_SAL_Free(ciphertext1);
BSL_SAL_Free(ciphertext2);
return ret;
}
BN_Optimizer *optimizer = BN_OptimizerCreate();
if (optimizer == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
goto EXIT;
}
if (BSL_PARAM_GetValue(ciphertext1Param, CRYPT_PARAM_PKEY_HE_CIPHERTEXT1, BSL_PARAM_TYPE_OCTETS, ciphertext1,
&ciphertext1Len) != BSL_SUCCESS ||
BSL_PARAM_GetValue(ciphertext2Param, CRYPT_PARAM_PKEY_HE_CIPHERTEXT2, BSL_PARAM_TYPE_OCTETS, ciphertext2,
&ciphertext2Len) != BSL_SUCCESS) {
ret = CRYPT_PAILLIER_ERR_INPUT_VALUE;
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
// Check whether the input ciphertext meets the specifications
if (ciphertext1Len != n2Bytes || ciphertext2Len != n2Bytes) {
ret = CRYPT_PAILLIER_ERR_INPUT_VALUE;
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
// Check whether the length of the out is sufficient to place the result
if (*outLen < n2Bytes) {
ret = CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH;
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
if ((ret = BN_Bin2Bn(c1, ciphertext1, ciphertext1Len)) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
if ((ret = BN_Bin2Bn(c2, ciphertext2, ciphertext2Len)) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
// Verify that the ciphertext is within the valid range [0, n^2)
if ((ret = CRYPT_PAILLIER_CheckHECiphertext(c1, paillierCtx->pubKey, optimizer))!= CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
if ((ret = CRYPT_PAILLIER_CheckHECiphertext(c2, paillierCtx->pubKey, optimizer))!= CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
// Add: c_res = c1 * c2 mod n^2
if ((ret = BN_ModMul(result, c1, c2, paillierCtx->pubKey->n2, optimizer)) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
// Export result as fixed-length n^2 bytes with leading-zero padding
uint8_t *tmpBuf = (uint8_t *)BSL_SAL_Malloc(n2Bytes);
if (tmpBuf == NULL) {
ret = CRYPT_MEM_ALLOC_FAIL;
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
uint32_t actualLen = n2Bytes;
ret = BN_Bn2Bin(result, tmpBuf, &actualLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
BSL_SAL_Free(tmpBuf);
goto EXIT;
}
(void)memset_s(out, n2Bytes, 0, n2Bytes);
if (actualLen > 0) {
(void)memcpy_s(out + (n2Bytes - actualLen), actualLen, tmpBuf, actualLen);
}
*outLen = n2Bytes;
BSL_SAL_Free(tmpBuf);
EXIT:
BN_Destroy(c1);
BN_Destroy(c2);
BN_Destroy(result);
BN_OptimizerDestroy(optimizer);
BSL_SAL_Free(ciphertext1);
BSL_SAL_Free(ciphertext2);
return ret;
}
#endif // HITLS_CRYPTO_PAILLIER | 2302_82127028/openHiTLS-examples_1508 | crypto/paillier/src/paillier_encdec.c | C | unknown | 16,085 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_PAILLIER
#include "crypt_paillier.h"
#include "paillier_local.h"
#include "crypt_errno.h"
#include "crypt_utils.h"
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_params_key.h"
CRYPT_PAILLIER_Ctx *CRYPT_PAILLIER_NewCtx(void)
{
CRYPT_PAILLIER_Ctx *ctx = NULL;
ctx = (CRYPT_PAILLIER_Ctx *)BSL_SAL_Malloc(sizeof(CRYPT_PAILLIER_Ctx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
(void)memset_s(ctx, sizeof(CRYPT_PAILLIER_Ctx), 0, sizeof(CRYPT_PAILLIER_Ctx));
BSL_SAL_ReferencesInit(&(ctx->references));
return ctx;
}
CRYPT_PAILLIER_Ctx *CRYPT_PAILLIER_NewCtxEx(void *libCtx)
{
CRYPT_PAILLIER_Ctx *ctx = CRYPT_PAILLIER_NewCtx();
if (ctx == NULL) {
return NULL;
}
ctx->libCtx = libCtx;
return ctx;
}
static CRYPT_PAILLIER_PubKey *PaillierPubKeyDupCtx(CRYPT_PAILLIER_PubKey *pubKey)
{
CRYPT_PAILLIER_PubKey *newPubKey = (CRYPT_PAILLIER_PubKey *)BSL_SAL_Malloc(sizeof(CRYPT_PAILLIER_PubKey));
if (newPubKey == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
(void)memset_s(newPubKey, sizeof(CRYPT_PAILLIER_PubKey), 0, sizeof(CRYPT_PAILLIER_PubKey));
GOTO_ERR_IF_SRC_NOT_NULL(newPubKey->n, pubKey->n, BN_Dup(pubKey->n), CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_SRC_NOT_NULL(newPubKey->g, pubKey->g, BN_Dup(pubKey->g), CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_SRC_NOT_NULL(newPubKey->n2, pubKey->n2, BN_Dup(pubKey->n2), CRYPT_MEM_ALLOC_FAIL);
return newPubKey;
ERR:
PAILLIER_FREE_PUB_KEY(newPubKey);
return NULL;
}
static CRYPT_PAILLIER_PrvKey *PaillierPrvKeyDupCtx(CRYPT_PAILLIER_PrvKey *prvKey)
{
CRYPT_PAILLIER_PrvKey *newPrvKey = (CRYPT_PAILLIER_PrvKey *)BSL_SAL_Malloc(sizeof(CRYPT_PAILLIER_PrvKey));
if (newPrvKey == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
(void)memset_s(newPrvKey, sizeof(CRYPT_PAILLIER_PrvKey), 0, sizeof(CRYPT_PAILLIER_PrvKey));
GOTO_ERR_IF_SRC_NOT_NULL(newPrvKey->n, prvKey->n, BN_Dup(prvKey->n), CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_SRC_NOT_NULL(newPrvKey->lambda, prvKey->lambda, BN_Dup(prvKey->lambda), CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_SRC_NOT_NULL(newPrvKey->mu, prvKey->mu, BN_Dup(prvKey->mu), CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_SRC_NOT_NULL(newPrvKey->n2, prvKey->n2, BN_Dup(prvKey->n2), CRYPT_MEM_ALLOC_FAIL);
return newPrvKey;
ERR:
PAILLIER_FREE_PRV_KEY(newPrvKey);
return NULL;
}
static CRYPT_PAILLIER_Para *PaillierParaDupCtx(CRYPT_PAILLIER_Para *para)
{
CRYPT_PAILLIER_Para *newPara = (CRYPT_PAILLIER_Para *)BSL_SAL_Malloc(sizeof(CRYPT_PAILLIER_Para));
if (newPara == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
(void)memset_s(newPara, sizeof(CRYPT_PAILLIER_Para), 0, sizeof(CRYPT_PAILLIER_Para));
newPara->bits = para->bits;
GOTO_ERR_IF_SRC_NOT_NULL(newPara->p, para->p, BN_Dup(para->p), CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_SRC_NOT_NULL(newPara->q, para->q, BN_Dup(para->q), CRYPT_MEM_ALLOC_FAIL);
return newPara;
ERR:
PAILLIER_FREE_PARA(newPara);
return NULL;
}
CRYPT_PAILLIER_Ctx *CRYPT_PAILLIER_DupCtx(CRYPT_PAILLIER_Ctx *keyCtx)
{
if (keyCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return NULL;
}
CRYPT_PAILLIER_Ctx *newKeyCtx = NULL;
newKeyCtx = BSL_SAL_Malloc(sizeof(CRYPT_PAILLIER_Ctx));
if (newKeyCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
(void)memset_s(newKeyCtx, sizeof(CRYPT_PAILLIER_Ctx), 0, sizeof(CRYPT_PAILLIER_Ctx));
GOTO_ERR_IF_SRC_NOT_NULL(newKeyCtx->prvKey, keyCtx->prvKey, PaillierPrvKeyDupCtx(keyCtx->prvKey),
CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_SRC_NOT_NULL(newKeyCtx->pubKey, keyCtx->pubKey, PaillierPubKeyDupCtx(keyCtx->pubKey),
CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_SRC_NOT_NULL(newKeyCtx->para, keyCtx->para, PaillierParaDupCtx(keyCtx->para), CRYPT_MEM_ALLOC_FAIL);
newKeyCtx->libCtx = keyCtx->libCtx;
BSL_SAL_ReferencesInit(&(newKeyCtx->references));
return newKeyCtx;
ERR:
CRYPT_PAILLIER_FreeCtx(newKeyCtx);
return NULL;
}
static int32_t PaillierNewParaBasicCheck(const CRYPT_PaillierPara *para)
{
if (para == NULL || para->p == NULL || para->pLen == 0 || para->q == NULL ||
para->qLen == 0 || para->bits <= 0 || para->bits > PAILLIER_MAX_MODULUS_BITS) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
/* the length of p and q should be equal to bits */
if (para->pLen != BN_BITS_TO_BYTES(para->bits) || para->qLen != BN_BITS_TO_BYTES(para->bits)) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_KEY_BITS);
return CRYPT_PAILLIER_ERR_KEY_BITS;
}
return CRYPT_SUCCESS;
}
CRYPT_PAILLIER_Para *CRYPT_PAILLIER_NewPara(const CRYPT_PaillierPara *para)
{
int32_t ret = PaillierNewParaBasicCheck(para);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return NULL;
}
CRYPT_PAILLIER_Para *retPara = BSL_SAL_Malloc(sizeof(CRYPT_PAILLIER_Para));
if (retPara == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
retPara->bits = para->bits;
retPara->p = BN_Create(para->bits);
retPara->q = BN_Create(para->bits);
if (retPara->p == NULL || retPara->q == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
goto ERR;
}
return retPara;
ERR:
CRYPT_PAILLIER_FreePara(retPara);
return NULL;
}
void CRYPT_PAILLIER_FreeCtx(CRYPT_PAILLIER_Ctx *ctx)
{
if (ctx == NULL) {
return;
}
int i = 0;
BSL_SAL_AtomicDownReferences(&(ctx->references), &i);
if (i > 0) {
return;
}
BSL_SAL_ReferencesFree(&(ctx->references));
PAILLIER_FREE_PRV_KEY(ctx->prvKey);
PAILLIER_FREE_PUB_KEY(ctx->pubKey);
PAILLIER_FREE_PARA(ctx->para);
BSL_SAL_Free(ctx);
}
void CRYPT_PAILLIER_FreePara(CRYPT_PAILLIER_Para *para)
{
if (para == NULL) {
return;
}
BN_Destroy(para->p);
BN_Destroy(para->q);
BSL_SAL_Free(para);
}
void PAILLIER_FreePrvKey(CRYPT_PAILLIER_PrvKey *prvKey)
{
if (prvKey == NULL) {
return;
}
BN_Destroy(prvKey->n);
BN_Destroy(prvKey->lambda);
BN_Destroy(prvKey->mu);
BN_Destroy(prvKey->n2);
BSL_SAL_Free(prvKey);
}
void PAILLIER_FreePubKey(CRYPT_PAILLIER_PubKey *pubKey)
{
if (pubKey == NULL) {
return;
}
BN_Destroy(pubKey->n);
BN_Destroy(pubKey->g);
BN_Destroy(pubKey->n2);
BSL_SAL_Free(pubKey);
}
static int32_t IsPAILLIERSetParaVaild(const CRYPT_PAILLIER_Ctx *ctx, const CRYPT_PAILLIER_Para *para)
{
if (ctx == NULL || para == NULL || para->p == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (para->bits > PAILLIER_MAX_MODULUS_BITS || para->bits <= 0) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_KEY_BITS);
return CRYPT_PAILLIER_ERR_KEY_BITS;
}
return CRYPT_SUCCESS;
}
CRYPT_PAILLIER_Para *CRYPT_Paillier_DupPara(const CRYPT_PAILLIER_Para *para)
{
CRYPT_PAILLIER_Para *paraCopy = BSL_SAL_Malloc(sizeof(CRYPT_PAILLIER_Para));
if (paraCopy == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
paraCopy->bits = para->bits;
paraCopy->p = BN_Dup(para->p);
paraCopy->q = BN_Dup(para->q);
if (paraCopy->p == NULL || paraCopy->q == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
PAILLIER_FREE_PARA(paraCopy);
return NULL;
}
return paraCopy;
}
int32_t CRYPT_PAILLIER_SetPara(CRYPT_PAILLIER_Ctx *ctx, const CRYPT_PaillierPara *para)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
CRYPT_PAILLIER_Para *paillierPara = CRYPT_PAILLIER_NewPara(para);
if (paillierPara == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
int32_t ret = IsPAILLIERSetParaVaild(ctx, paillierPara);
if (ret != CRYPT_SUCCESS) {
CRYPT_PAILLIER_FreePara(paillierPara);
return ret;
}
PAILLIER_FREE_PARA(ctx->para);
PAILLIER_FREE_PUB_KEY(ctx->pubKey);
PAILLIER_FREE_PRV_KEY(ctx->prvKey);
ctx->para = paillierPara;
return CRYPT_SUCCESS;
}
#ifdef HITLS_BSL_PARAMS
int32_t CRYPT_PAILLIER_SetParaEx(CRYPT_PAILLIER_Ctx *ctx, const BSL_Param *para)
{
if (para == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
CRYPT_PaillierPara paillierPara = {0};
uint32_t bitsLen = sizeof(uint32_t);
int32_t ret = 0;
(void)GetConstParamValue(para, CRYPT_PARAM_PAILLIER_P, &(paillierPara.p), &(paillierPara.pLen));
(void)GetConstParamValue(para, CRYPT_PARAM_PAILLIER_Q, &(paillierPara.q), &(paillierPara.qLen));
const BSL_Param *temp = BSL_PARAM_FindConstParam(para, CRYPT_PARAM_PAILLIER_BITS);
if (temp != NULL) {
RETURN_RET_IF_ERR(BSL_PARAM_GetValue(temp, CRYPT_PARAM_PAILLIER_BITS,
BSL_PARAM_TYPE_UINT32, &paillierPara.bits, &bitsLen), ret);
}
return CRYPT_PAILLIER_SetPara(ctx, &paillierPara);
}
#endif
uint32_t CRYPT_PAILLIER_GetBits(const CRYPT_PAILLIER_Ctx *ctx)
{
if (ctx == NULL) {
return 0;
}
if (ctx->para != NULL) {
return ctx->para->bits;
}
if (ctx->prvKey != NULL) {
return BN_Bits(ctx->prvKey->lambda);
}
if (ctx->pubKey != NULL) {
return BN_Bits(ctx->pubKey->n);
}
return 0;
}
CRYPT_PAILLIER_PrvKey *Paillier_NewPrvKey(uint32_t bits)
{
CRYPT_PAILLIER_PrvKey *prvKey = (CRYPT_PAILLIER_PrvKey *)BSL_SAL_Malloc(sizeof(CRYPT_PAILLIER_PrvKey));
if (prvKey == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
prvKey->n = BN_Create(bits);
prvKey->lambda = BN_Create(bits);
prvKey->mu = BN_Create(bits);
prvKey->n2 = BN_Create(bits);
if (prvKey->n == NULL || prvKey->lambda == NULL || prvKey->mu == NULL || prvKey->n2 == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
PAILLIER_FREE_PRV_KEY(prvKey);
}
return prvKey;
}
CRYPT_PAILLIER_PubKey *Paillier_NewPubKey(uint32_t bits)
{
CRYPT_PAILLIER_PubKey *pubKey = (CRYPT_PAILLIER_PubKey *)BSL_SAL_Malloc(sizeof(CRYPT_PAILLIER_PubKey));
if (pubKey == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
pubKey->n = BN_Create(bits);
pubKey->g = BN_Create(bits);
pubKey->n2 = BN_Create(bits);
if (pubKey->n == NULL || pubKey->g == NULL || pubKey->n2 == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
PAILLIER_FREE_PUB_KEY(pubKey);
}
return pubKey;
}
static int32_t Paillier_GenPQ(CRYPT_PAILLIER_Para *para, BN_Optimizer *optimizer)
{
uint32_t bits = para->bits;
int32_t ret = BN_GenPrime(para->p, NULL, bits, true, optimizer, NULL);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = BN_GenPrime(para->q, NULL, bits, true, optimizer, NULL);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
}
static int32_t Paillier_CalcPubKey(CRYPT_PAILLIER_PubKey *pubKey, CRYPT_PAILLIER_Para *para, BN_Optimizer *optimizer)
{
int32_t ret = BN_Mul(pubKey->n, para->p, para->q, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = BN_AddLimb(pubKey->g, pubKey->n, 1); // g = n + 1
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = BN_Sqr(pubKey->n2, pubKey->n, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
}
static int32_t Paillier_CalcLambda(BN_BigNum *lambda, CRYPT_PAILLIER_Para *para, BN_Optimizer *optimizer)
{
uint32_t bits = para->bits;
BN_BigNum *pMinus1 = BN_Create(bits);
BN_BigNum *qMinus1 = BN_Create(bits);
int32_t ret = CRYPT_MEM_ALLOC_FAIL;
if (pMinus1 == NULL || qMinus1 == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
goto EXIT;
}
ret = BN_SubLimb(pMinus1, para->p, 1);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_SubLimb(qMinus1, para->q, 1);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_Lcm(lambda, pMinus1, qMinus1, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
EXIT:
BN_Destroy(pMinus1);
BN_Destroy(qMinus1);
return ret;
}
static int32_t Paillier_CalcMu(BN_BigNum *mu, const BN_BigNum *lambda, CRYPT_PAILLIER_PubKey *pubKey, uint32_t bits, BN_Optimizer *optimizer)
{
BN_BigNum *x = BN_Create(bits);
BN_BigNum *xMinus1 = BN_Create(bits);
BN_BigNum *Lx = BN_Create(bits);
int32_t ret;
if (x == NULL || xMinus1 == NULL || Lx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
ret = CRYPT_MEM_ALLOC_FAIL;
goto EXIT;
}
ret = BN_ModExp(x, pubKey->g, lambda, pubKey->n2, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_SubLimb(xMinus1, x, 1);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_Div(Lx, NULL, xMinus1, pubKey->n, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_ModInv(mu, Lx, pubKey->n, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
EXIT:
BN_Destroy(x);
BN_Destroy(xMinus1);
BN_Destroy(Lx);
return ret;
}
int32_t Paillier_CalcPrvKey(CRYPT_PAILLIER_Ctx *ctx, BN_Optimizer *optimizer)
{
int32_t ret = Paillier_CalcLambda(ctx->prvKey->lambda, ctx->para, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = Paillier_CalcMu(ctx->prvKey->mu, ctx->prvKey->lambda, ctx->pubKey, ctx->para->bits, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
}
int32_t CRYPT_PAILLIER_Gen(CRYPT_PAILLIER_Ctx *ctx)
{
if (ctx == NULL || ctx->para == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = CRYPT_MEM_ALLOC_FAIL;
BN_Optimizer *optimizer = NULL;
CRYPT_PAILLIER_Ctx *newCtx = CRYPT_PAILLIER_NewCtx();
if (newCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
newCtx->para = CRYPT_Paillier_DupPara(ctx->para);
if (newCtx->para == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
goto ERR;
}
newCtx->prvKey = Paillier_NewPrvKey(newCtx->para->bits);
newCtx->pubKey = Paillier_NewPubKey(newCtx->para->bits);
optimizer = BN_OptimizerCreate();
if (optimizer == NULL || newCtx->prvKey == NULL || newCtx->pubKey == NULL) {
ret = CRYPT_MEM_ALLOC_FAIL;
BSL_ERR_PUSH_ERROR(ret);
goto ERR;
}
BN_OptimizerSetLibCtx(ctx->libCtx, optimizer);
ret = Paillier_GenPQ(newCtx->para, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto ERR;
}
ret = Paillier_CalcPubKey(newCtx->pubKey, newCtx->para, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto ERR;
}
ret = Paillier_CalcPrvKey(newCtx, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto ERR;
}
GOTO_ERR_IF(BN_Copy(newCtx->prvKey->n, newCtx->pubKey->n), ret);
GOTO_ERR_IF(BN_Copy(newCtx->prvKey->n2, newCtx->pubKey->n2), ret);
PAILLIER_FREE_PARA(ctx->para);
PAILLIER_FREE_PRV_KEY(ctx->prvKey);
PAILLIER_FREE_PUB_KEY(ctx->pubKey);
BSL_SAL_ReferencesFree(&(newCtx->references));
ctx->prvKey = newCtx->prvKey;
ctx->pubKey = newCtx->pubKey;
ctx->para = newCtx->para;
BSL_SAL_FREE(newCtx);
BN_OptimizerDestroy(optimizer);
return ret;
ERR:
CRYPT_PAILLIER_FreeCtx(newCtx);
BN_OptimizerDestroy(optimizer);
return ret;
}
#endif // HITLS_CRYPTO_PAILLIER | 2302_82127028/openHiTLS-examples_1508 | crypto/paillier/src/paillier_keygen.c | C | unknown | 16,825 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_PAILLIER
#include "crypt_types.h"
#include "crypt_paillier.h"
#include "crypt_utils.h"
#include "bsl_err_internal.h"
#include "paillier_local.h"
#include "crypt_errno.h"
#include "securec.h"
#include "bsl_sal.h"
#include "crypt_params_key.h"
typedef struct {
BSL_Param *n; /**< Paillier private key parameter marked as n */
BSL_Param *lambda; /**< Paillier private key parameter marked as lambda */
BSL_Param *mu; /**< Paillier private key parameter marked as mu */
BSL_Param *n2; /**< Paillier private key parameter marked as n2 */
} CRYPT_PaillierPrvParam;
typedef struct {
BSL_Param *n; /**< Paillier public key parameter marked as n */
BSL_Param *g; /**< Paillier public key parameter marked as g */
BSL_Param *n2; /**< Paillier public key parameter marked as n2 */
} CRYPT_PaillierPubParam;
#define PARAMISNULL(a) (a == NULL || a->value == NULL)
static int32_t CheckSquare(const BN_BigNum *n2, const BN_BigNum *n, uint32_t bits)
{
BN_BigNum *tmp = BN_Create(bits);
BN_Optimizer *optimizer = BN_OptimizerCreate();
int32_t ret;
if (optimizer == NULL || tmp == NULL) {
ret = CRYPT_MEM_ALLOC_FAIL;
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_Sqr(tmp, n, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
if (BN_Cmp(tmp, n2) != 0) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_INPUT_VALUE);
ret = CRYPT_PAILLIER_ERR_INPUT_VALUE;
}
EXIT:
BN_Destroy(tmp);
BN_OptimizerDestroy(optimizer);
return ret;
}
static int32_t SetPrvPara(const CRYPT_PAILLIER_PrvKey *prvKey, const CRYPT_PaillierPrv *prv)
{
int32_t ret = BN_Bin2Bn(prvKey->n, prv->n, prv->nLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
uint32_t bnBits = BN_Bits(prvKey->n);
if (bnBits > PAILLIER_MAX_MODULUS_BITS || bnBits <= 0) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_KEY_BITS);
return CRYPT_PAILLIER_ERR_KEY_BITS;
}
ret = BN_Bin2Bn(prvKey->lambda, prv->lambda, prv->lambdaLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = BN_Bin2Bn(prvKey->mu, prv->mu, prv->muLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = BN_Bin2Bn(prvKey->n2, prv->n2, prv->n2Len);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = CheckSquare(prvKey->n2, prvKey->n, prv->n2Len * 8);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
if (BN_IsZero(prvKey->mu) || BN_IsOne(prvKey->mu)) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_INPUT_VALUE);
return CRYPT_PAILLIER_ERR_INPUT_VALUE;
}
return ret;
}
static int32_t SetPrvBasicCheck(const CRYPT_PAILLIER_Ctx *ctx, const CRYPT_PaillierPrv *prv)
{
if (ctx == NULL || prv == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (prv->n == NULL || prv->lambda == NULL || prv->mu == NULL || prv->n2 == NULL ||
prv->lambdaLen == 0 || prv->muLen == 0 || prv->nLen == 0 || prv->n2Len == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_INPUT_VALUE);
return CRYPT_PAILLIER_ERR_INPUT_VALUE;
}
return CRYPT_SUCCESS;
}
int32_t CRYPT_PAILLIER_SetPrvKey(CRYPT_PAILLIER_Ctx *ctx, const CRYPT_PaillierPrv *prv)
{
int32_t ret = SetPrvBasicCheck(ctx, prv);
if (ret != CRYPT_SUCCESS) {
return ret;
}
CRYPT_PAILLIER_Ctx *newCtx = CRYPT_PAILLIER_NewCtx();
if (newCtx == NULL) {
return CRYPT_MEM_ALLOC_FAIL;
}
newCtx->prvKey = Paillier_NewPrvKey(prv->lambdaLen * 8); // Bit length is obtained by multiplying byte length by 8.
if (newCtx->prvKey == NULL) {
ret = CRYPT_MEM_ALLOC_FAIL;
BSL_ERR_PUSH_ERROR(ret);
goto ERR;
}
ret = SetPrvPara(newCtx->prvKey, prv);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto ERR;
}
PAILLIER_FREE_PRV_KEY(ctx->prvKey);
ctx->prvKey = newCtx->prvKey;
BSL_SAL_ReferencesFree(&(newCtx->references));
BSL_SAL_FREE(newCtx);
return ret;
ERR:
CRYPT_PAILLIER_FreeCtx(newCtx);
return ret;
}
static int32_t SetPubBasicCheck(const CRYPT_PAILLIER_Ctx *ctx, const CRYPT_PaillierPub *pub)
{
if (ctx == NULL || pub == NULL || pub->n == NULL || pub->g == NULL || pub->n2 == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return CRYPT_SUCCESS;
}
int32_t CRYPT_PAILLIER_SetPubKey(CRYPT_PAILLIER_Ctx *ctx, const CRYPT_PaillierPub *pub)
{
int32_t ret = SetPubBasicCheck(ctx, pub);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
CRYPT_PAILLIER_PubKey *newPub = NULL;
/* Bit length is obtained by multiplying byte length by 8. */
newPub = Paillier_NewPubKey(pub->nLen * 8);
if (newPub == NULL) {
return CRYPT_MEM_ALLOC_FAIL;
}
GOTO_ERR_IF(BN_Bin2Bn(newPub->n, pub->n, pub->nLen), ret);
uint32_t bnBits = BN_Bits(newPub->n);
if (bnBits > PAILLIER_MAX_MODULUS_BITS || bnBits <= 0) {
ret = CRYPT_PAILLIER_ERR_KEY_BITS;
BSL_ERR_PUSH_ERROR(ret);
goto ERR;
}
GOTO_ERR_IF(BN_Bin2Bn(newPub->g, pub->g, pub->gLen), ret);
GOTO_ERR_IF(BN_Bin2Bn(newPub->n2, pub->n2, pub->n2Len), ret);
GOTO_ERR_IF(CheckSquare(newPub->n2, newPub->n, pub->nLen * 8), ret);
PAILLIER_FREE_PUB_KEY(ctx->pubKey);
ctx->pubKey = newPub;
return ret;
ERR:
PAILLIER_FREE_PUB_KEY(newPub);
return ret;
}
int32_t CRYPT_PAILLIER_GetPrvKey(const CRYPT_PAILLIER_Ctx *ctx, CRYPT_PaillierPrv *prv)
{
if (ctx == NULL || ctx->prvKey == NULL || prv == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (prv->lambda == NULL || prv->mu == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_INPUT_VALUE);
return CRYPT_PAILLIER_ERR_INPUT_VALUE;
}
int32_t ret = 0;
GOTO_ERR_IF(BN_Bn2Bin(ctx->prvKey->lambda, prv->lambda, &prv->lambdaLen), ret);
GOTO_ERR_IF(BN_Bn2Bin(ctx->prvKey->mu, prv->mu, &prv->muLen), ret);
if (prv->n != NULL) {
GOTO_ERR_IF(BN_Bn2Bin(ctx->prvKey->n, prv->n, &prv->nLen), ret);
}
if (prv->n2 != NULL) {
GOTO_ERR_IF(BN_Bn2Bin(ctx->prvKey->n2, prv->n2, &prv->n2Len), ret);
}
return CRYPT_SUCCESS;
ERR:
BSL_SAL_CleanseData(prv->lambda, prv->lambdaLen);
BSL_SAL_CleanseData(prv->mu, prv->muLen);
BSL_SAL_CleanseData(prv->n, prv->nLen);
BSL_SAL_CleanseData(prv->n2, prv->n2Len);
prv->lambdaLen = 0;
prv->muLen = 0;
prv->nLen = 0;
prv->n2Len = 0;
return ret;
}
int32_t CRYPT_PAILLIER_GetPubKey(const CRYPT_PAILLIER_Ctx *ctx, CRYPT_PaillierPub *pub)
{
if (ctx == NULL || ctx->pubKey == NULL || pub == NULL ||
pub->n == NULL || pub->g == NULL || pub->n2 == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = 0;
GOTO_ERR_IF(BN_Bn2Bin(ctx->pubKey->g, pub->g, &pub->gLen), ret);
GOTO_ERR_IF(BN_Bn2Bin(ctx->pubKey->n, pub->n, &pub->nLen), ret);
GOTO_ERR_IF(BN_Bn2Bin(ctx->pubKey->n2, pub->n2, &pub->n2Len), ret);
return CRYPT_SUCCESS;
ERR:
BSL_SAL_CleanseData(pub->g, pub->gLen);
BSL_SAL_CleanseData(pub->n, pub->nLen);
BSL_SAL_CleanseData(pub->n2, pub->n2Len);
pub->gLen = 0;
pub->nLen = 0;
pub->n2Len = 0;
return ret;
}
#ifdef HITLS_BSL_PARAMS
int32_t CRYPT_PAILLIER_SetPrvKeyEx(CRYPT_PAILLIER_Ctx *ctx, const BSL_Param *para)
{
if (para == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
CRYPT_PaillierPrv prv = {0};
(void)GetConstParamValue(para, CRYPT_PARAM_PAILLIER_N, &prv.n, &prv.nLen);
(void)GetConstParamValue(para, CRYPT_PARAM_PAILLIER_LAMBDA, &prv.lambda, &prv.lambdaLen);
(void)GetConstParamValue(para, CRYPT_PARAM_PAILLIER_MU, &prv.mu, &prv.muLen);
(void)GetConstParamValue(para, CRYPT_PARAM_PAILLIER_N2, &prv.n2, &prv.n2Len);
return CRYPT_PAILLIER_SetPrvKey(ctx, &prv);
}
int32_t CRYPT_PAILLIER_SetPubKeyEx(CRYPT_PAILLIER_Ctx *ctx, const BSL_Param *para)
{
if (para == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
CRYPT_PaillierPub pub = {0};
(void)GetConstParamValue(para, CRYPT_PARAM_PAILLIER_N, &pub.n, &pub.nLen);
(void)GetConstParamValue(para, CRYPT_PARAM_PAILLIER_G, &pub.g, &pub.gLen);
(void)GetConstParamValue(para, CRYPT_PARAM_PAILLIER_N2, &pub.n2, &pub.n2Len);
return CRYPT_PAILLIER_SetPubKey(ctx, &pub);
}
int32_t CRYPT_PAILLIER_GetPrvKeyEx(const CRYPT_PAILLIER_Ctx *ctx, BSL_Param *para)
{
if (para == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
CRYPT_PaillierPrv prv = {0};
BSL_Param *paramN = GetParamValue(para, CRYPT_PARAM_PAILLIER_N, &prv.n, &(prv.nLen));
BSL_Param *paramLambda = GetParamValue(para, CRYPT_PARAM_PAILLIER_LAMBDA, &prv.lambda, &(prv.lambdaLen));
BSL_Param *paramMu = GetParamValue(para, CRYPT_PARAM_PAILLIER_MU, &prv.mu, &(prv.muLen));
BSL_Param *paramN2 = GetParamValue(para, CRYPT_PARAM_PAILLIER_N2, &prv.n2, &(prv.n2Len));
int32_t ret = CRYPT_PAILLIER_GetPrvKey(ctx, &prv);
if (ret != CRYPT_SUCCESS) {
return ret;
}
paramLambda->useLen = prv.lambdaLen;
paramMu->useLen = prv.muLen;
if (paramN != NULL) {
paramN->useLen = prv.nLen;
}
if (paramN2 != NULL) {
paramN2->useLen = prv.n2Len;
}
return CRYPT_SUCCESS;
}
int32_t CRYPT_PAILLIER_GetPubKeyEx(const CRYPT_PAILLIER_Ctx *ctx, BSL_Param *para)
{
if (para == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
CRYPT_PaillierPub pub = {0};
BSL_Param *paramN = GetParamValue(para, CRYPT_PARAM_PAILLIER_N, &pub.n, &(pub.nLen));
BSL_Param *paramG = GetParamValue(para, CRYPT_PARAM_PAILLIER_G, &pub.g, &(pub.gLen));
BSL_Param *paramN2 = GetParamValue(para, CRYPT_PARAM_PAILLIER_N2, &pub.n2, &(pub.n2Len));
int32_t ret = CRYPT_PAILLIER_GetPubKey(ctx, &pub);
if (ret != CRYPT_SUCCESS) {
return ret;
}
paramN->useLen = pub.nLen;
paramG->useLen = pub.gLen;
paramN2->useLen = pub.n2Len;
return CRYPT_SUCCESS;
}
#endif
int32_t CRYPT_PAILLIER_GetSecBits(const CRYPT_PAILLIER_Ctx *ctx)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return 0;
}
int32_t bits = (int32_t)CRYPT_PAILLIER_GetBits(ctx);
return BN_SecBits(bits, -1);
}
#endif /* HITLS_CRYPTO_PAILLIER */ | 2302_82127028/openHiTLS-examples_1508 | crypto/paillier/src/paillier_keyop.c | C | unknown | 11,292 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef PAILLIER_LOCAL_H
#define PAILLIER_LOCAL_H
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_PAILLIER
#include "crypt_paillier.h"
#include "crypt_bn.h"
#include "crypt_local_types.h"
#include "crypt_types.h"
#include "sal_atomic.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cpluscplus */
typedef struct {
BN_BigNum *n; // modulo Value - converted.Not in char
BN_BigNum *g; // modulo Value -converted.Not in char
BN_BigNum *n2; // square of n
} CRYPT_PAILLIER_PubKey;
typedef struct {
BN_BigNum *n; // pub key n needed for decryption
BN_BigNum *lambda; // modulo Value - converted.Not in char
BN_BigNum *mu; // modulo Value -converted.Not in char
BN_BigNum *n2; // pub key n2 needed for decryption
} CRYPT_PAILLIER_PrvKey;
struct PAILLIER_Para {
BN_BigNum *p; // prime factor p
BN_BigNum *q; // prime factor q
uint32_t bits; // length in bits of modulus
};
struct PAILLIER_Ctx {
CRYPT_PAILLIER_PubKey *pubKey;
CRYPT_PAILLIER_PrvKey *prvKey;
CRYPT_PAILLIER_Para *para;
BSL_SAL_RefCount references;
void *libCtx;
};
CRYPT_PAILLIER_PrvKey *Paillier_NewPrvKey(uint32_t bits);
CRYPT_PAILLIER_PubKey *Paillier_NewPubKey(uint32_t bits);
void PAILLIER_FreePrvKey(CRYPT_PAILLIER_PrvKey *prvKey);
void PAILLIER_FreePubKey(CRYPT_PAILLIER_PubKey *pubKey);
CRYPT_PAILLIER_Para *CRYPT_Paillier_DupPara(const CRYPT_PAILLIER_Para *para);
#define PAILLIER_FREE_PRV_KEY(prvKey_) \
do { \
PAILLIER_FreePrvKey((prvKey_)); \
(prvKey_) = NULL; \
} while (0)
#define PAILLIER_FREE_PUB_KEY(pubKey_) \
do { \
PAILLIER_FreePubKey((pubKey_)); \
(pubKey_) = NULL; \
} while (0)
#define PAILLIER_FREE_PARA(para_) \
do { \
CRYPT_PAILLIER_FreePara((para_)); \
(para_) = NULL; \
} while (0)
#ifdef __cplusplus
}
#endif
#endif // HITLS_CRYPTO_PAILLIER
#endif // PAILLIER_LOCAL_H | 2302_82127028/openHiTLS-examples_1508 | crypto/paillier/src/paillier_local.h | C | unknown | 2,729 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CRYPT_PBKDF2_H
#define CRYPT_PBKDF2_H
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_PBKDF2
#include <stdint.h>
#include "crypt_local_types.h"
#include "bsl_params.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
typedef struct CryptPbkdf2Ctx CRYPT_PBKDF2_Ctx;
/**
* @ingroup PBKDF2
* @brief Generate PBKDF2 context.
*
* @retval Success: PBKDF2 ctx.
* Fails: NULL.
*/
CRYPT_PBKDF2_Ctx* CRYPT_PBKDF2_NewCtx(void);
/**
* @ingroup PBKDF2
* @brief Generate PBKDF2 context.
*
* @param libCtx [in] Library context.
*
* @retval Success: PBKDF2 ctx.
* Fails: NULL.
*/
CRYPT_PBKDF2_Ctx *CRYPT_PBKDF2_NewCtxEx(void *libCtx);
/**
* @ingroup PBKDF2
* @brief Set parameters for the PBKDF2 context.
*
* @param ctx [in, out] Pointer to the PBKDF2 context.
* @param param [in] Either a MAC algorithm ID, a salt, a password, or an iteration count.
*
* @retval Success: CRYPT_SUCCESS
* For other error codes, see crypt_errno.h.
*/
int32_t CRYPT_PBKDF2_SetParam(CRYPT_PBKDF2_Ctx *ctx, const BSL_Param *param);
/**
* @ingroup PBKDF2
* @brief Obtain the derived key based on the passed PBKDF2 context..
*
* @param ctx [in, out] Pointer to the PBKDF2 context.
* @param out [out] Derived key buffer.
* @param out [out] Derived key buffer size.
*
* @retval Success: CRYPT_SUCCESS
* For other error codes, see crypt_errno.h.
*/
int32_t CRYPT_PBKDF2_Derive(CRYPT_PBKDF2_Ctx *ctx, uint8_t *out, uint32_t len);
/**
* @ingroup PBKDF2
* @brief PBKDF2 deinitialization API
*
* @param ctx [in, out] Pointer to the PBKDF2 context.
*
* @retval #CRYPT_SUCCESS Deinitialization succeeded.
* @retval #CRYPT_NULL_INPUT Pointer ctx is NULL
*/
int32_t CRYPT_PBKDF2_Deinit(CRYPT_PBKDF2_Ctx *ctx);
/**
* @ingroup PBKDF2
* @brief free PBKDF2 context.
*
* @param ctx [IN] PBKDF2 handle
*/
void CRYPT_PBKDF2_FreeCtx(CRYPT_PBKDF2_Ctx *ctx);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif // HITLS_CRYPTO_PBKDF2
#endif // CRYPT_PBKDF2_H
| 2302_82127028/openHiTLS-examples_1508 | crypto/pbkdf2/include/crypt_pbkdf2.h | C | unknown | 2,561 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_PBKDF2
#include <stdint.h>
#include "securec.h"
#include "bsl_err_internal.h"
#include "bsl_sal.h"
#include "crypt_local_types.h"
#include "crypt_errno.h"
#include "crypt_utils.h"
#include "crypt_algid.h"
#include "eal_mac_local.h"
#include "crypt_ealinit.h"
#include "pbkdf2_local.h"
#include "bsl_params.h"
#include "crypt_params_key.h"
#include "crypt_pbkdf2.h"
#define PBKDF2_MAX_BLOCKSIZE 64
#define PBKDF2_MAX_KEYLEN 0xFFFFFFFF
static const uint32_t PBKDF_ID_LIST[] = {
CRYPT_MAC_HMAC_MD5,
CRYPT_MAC_HMAC_SHA1,
CRYPT_MAC_HMAC_SHA224,
CRYPT_MAC_HMAC_SHA256,
CRYPT_MAC_HMAC_SHA384,
CRYPT_MAC_HMAC_SHA512,
CRYPT_MAC_HMAC_SM3,
CRYPT_MAC_HMAC_SHA3_224,
CRYPT_MAC_HMAC_SHA3_256,
CRYPT_MAC_HMAC_SHA3_384,
CRYPT_MAC_HMAC_SHA3_512,
};
struct CryptPbkdf2Ctx {
CRYPT_MAC_AlgId macId;
EAL_MacMethod macMeth;
uint32_t mdSize;
void *macCtx;
uint8_t *password;
uint32_t passLen;
uint8_t *salt;
uint32_t saltLen;
uint32_t iterCnt;
#ifdef HITLS_CRYPTO_PROVIDER
void *libCtx;
#endif
bool hasGetMdSize;
};
bool CRYPT_PBKDF2_IsValidAlgId(CRYPT_MAC_AlgId id)
{
return ParamIdIsValid(id, PBKDF_ID_LIST, sizeof(PBKDF_ID_LIST) / sizeof(PBKDF_ID_LIST[0]));
}
int32_t CRYPT_PBKDF2_U1(const CRYPT_PBKDF2_Ctx *pCtx, uint32_t blockCount, uint8_t *u, uint32_t *blockSize)
{
int32_t ret;
const EAL_MacMethod *macMeth = &pCtx->macMeth;
void *macCtx = pCtx->macCtx;
(void)macMeth->reinit(macCtx);
if ((ret = macMeth->update(macCtx, pCtx->salt, pCtx->saltLen)) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
/* processing the big endian */
uint32_t blockCnt = CRYPT_HTONL(blockCount);
if ((ret = macMeth->update(macCtx, (uint8_t *)&blockCnt, sizeof(blockCnt))) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
if ((ret = macMeth->final(macCtx, u, blockSize)) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
return CRYPT_SUCCESS;
}
int32_t CRYPT_PBKDF2_Un(const CRYPT_PBKDF2_Ctx *pCtx, uint8_t *u, uint32_t *blockSize, uint8_t *t, uint32_t tLen)
{
int32_t ret;
const EAL_MacMethod *macMeth = &pCtx->macMeth;
void *macCtx = pCtx->macCtx;
macMeth->reinit(macCtx);
if ((ret = macMeth->update(macCtx, u, *blockSize)) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
if ((ret = macMeth->final(macCtx, u, blockSize)) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
DATA_XOR(t, u, t, tLen);
return CRYPT_SUCCESS;
}
int32_t CRYPT_PBKDF2_CalcT(const CRYPT_PBKDF2_Ctx *pCtx, uint32_t blockCount, uint8_t *t, uint32_t *tlen)
{
uint8_t u[PBKDF2_MAX_BLOCKSIZE] = {0};
uint8_t tmpT[PBKDF2_MAX_BLOCKSIZE] = {0};
uint32_t blockSize = PBKDF2_MAX_BLOCKSIZE;
int32_t ret;
uint32_t iterCnt = pCtx->iterCnt;
/* U1 = PRF(Password, Salt + INT_32_BE(i))
tmpT = U1 */
ret = CRYPT_PBKDF2_U1(pCtx, blockCount, u, &blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
(void)memcpy_s(tmpT, PBKDF2_MAX_BLOCKSIZE, u, blockSize);
for (uint32_t un = 1; un < iterCnt; un++) {
/* t = t ^ Un */
ret = CRYPT_PBKDF2_Un(pCtx, u, &blockSize, tmpT, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
}
uint32_t len = (*tlen > blockSize) ? blockSize : (*tlen);
(void)memcpy_s(t, *tlen, tmpT, len);
*tlen = len;
BSL_SAL_CleanseData(u, PBKDF2_MAX_BLOCKSIZE);
BSL_SAL_CleanseData(tmpT, PBKDF2_MAX_BLOCKSIZE);
return CRYPT_SUCCESS;
}
int32_t CRYPT_PBKDF2_GenDk(const CRYPT_PBKDF2_Ctx *pCtx, uint8_t *dk, uint32_t dkLen)
{
uint32_t curLen;
uint8_t *t = dk;
uint32_t tlen;
uint32_t i;
int32_t ret;
ret = pCtx->macMeth.init(pCtx->macCtx, pCtx->password, pCtx->passLen, NULL);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
/* DK = T1 + T2 + ⋯ + Tdklen/hlen */
for (i = 1, curLen = dkLen; curLen > 0; i++) {
tlen = curLen;
ret = CRYPT_PBKDF2_CalcT(pCtx, i, t, &tlen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
curLen -= tlen;
t += tlen;
}
return CRYPT_SUCCESS;
}
int32_t CRYPT_PBKDF2_HMAC(void *libCtx, const EAL_MacMethod *macMeth, CRYPT_MAC_AlgId macId, const EAL_MdMethod *mdMeth,
const uint8_t *key, uint32_t keyLen,
const uint8_t *salt, uint32_t saltLen,
uint32_t iterCnt, uint8_t *out, uint32_t len)
{
int32_t ret;
CRYPT_PBKDF2_Ctx pCtx;
if (macMeth == NULL || mdMeth == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (key == NULL && keyLen > 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
// add keyLen limit based on rfc2898
if (mdMeth->mdSize == 0 || (keyLen / mdMeth->mdSize) >= PBKDF2_MAX_KEYLEN) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_PARAM_ERROR);
return CRYPT_PBKDF2_PARAM_ERROR;
}
if (salt == NULL && saltLen > 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if ((len == 0) || (iterCnt == 0)) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_PARAM_ERROR);
return CRYPT_PBKDF2_PARAM_ERROR;
}
void *macCtx = macMeth->newCtx(libCtx, macId);
if (macCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
pCtx.macMeth = *macMeth;
pCtx.macCtx = macCtx;
pCtx.password = (uint8_t *)(uintptr_t)key;
pCtx.passLen = keyLen;
pCtx.salt = (uint8_t *)(uintptr_t)salt;
pCtx.saltLen = saltLen;
pCtx.iterCnt = iterCnt;
ret = CRYPT_PBKDF2_GenDk(&pCtx, out, len);
macMeth->deinit(macCtx);
macMeth->freeCtx(macCtx);
macCtx = NULL;
return ret;
}
CRYPT_PBKDF2_Ctx *CRYPT_PBKDF2_NewCtx(void)
{
CRYPT_PBKDF2_Ctx *ctx = BSL_SAL_Calloc(1, sizeof(CRYPT_PBKDF2_Ctx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
return ctx;
}
CRYPT_PBKDF2_Ctx *CRYPT_PBKDF2_NewCtxEx(void *libCtx)
{
(void)libCtx;
CRYPT_PBKDF2_Ctx *ctx = CRYPT_PBKDF2_NewCtx();
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
#ifdef HITLS_CRYPTO_PROVIDER
ctx->libCtx = libCtx;
#endif
return ctx;
}
int32_t CRYPT_PBKDF2_SetMacMethod(CRYPT_PBKDF2_Ctx *ctx, const CRYPT_MAC_AlgId id)
{
#ifdef HITLS_CRYPTO_ASM_CHECK
if (CRYPT_ASMCAP_Mac(id) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
}
#endif
if (!CRYPT_PBKDF2_IsValidAlgId(id)) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_PARAM_ERROR);
return CRYPT_PBKDF2_PARAM_ERROR;
}
// free the old macCtx
if (ctx->macCtx != NULL) {
if (ctx->macMeth.freeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_ERR_MAC_METH);
return CRYPT_PBKDF2_ERR_MAC_METH;
}
ctx->macMeth.freeCtx(ctx->macCtx);
ctx->macCtx = NULL;
(void)memset_s(&ctx->macMeth, sizeof(EAL_MacMethod), 0, sizeof(EAL_MacMethod));
}
EAL_MacMethod *macMeth = EAL_MacFindMethod(id, &ctx->macMeth);
if (macMeth == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_ERR_METH_NULL_MEMBER);
return CRYPT_EAL_ERR_METH_NULL_MEMBER;
}
if (macMeth->newCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_ERR_MAC_METH);
return CRYPT_PBKDF2_ERR_MAC_METH;
}
#ifdef HITLS_CRYPTO_PROVIDER
ctx->macCtx = macMeth->newCtx(ctx->libCtx, id);
#else
ctx->macCtx = macMeth->newCtx(NULL, id);
#endif
if (ctx->macCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
ctx->macId = id;
return CRYPT_SUCCESS;
}
int32_t CRYPT_PBKDF2_SetPassWord(CRYPT_PBKDF2_Ctx *ctx, const uint8_t *password, uint32_t passLen)
{
if (password == NULL && passLen > 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
BSL_SAL_ClearFree(ctx->password, ctx->passLen);
ctx->password = BSL_SAL_Dump(password, passLen);
if (ctx->password == NULL && passLen > 0) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
ctx->passLen = passLen;
return CRYPT_SUCCESS;
}
int32_t CRYPT_PBKDF2_SetSalt(CRYPT_PBKDF2_Ctx *ctx, const uint8_t *salt, uint32_t saltLen)
{
if (salt == NULL && saltLen > 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
BSL_SAL_FREE(ctx->salt);
ctx->salt = BSL_SAL_Dump(salt, saltLen);
if (ctx->salt == NULL && saltLen > 0) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
ctx->saltLen = saltLen;
return CRYPT_SUCCESS;
}
int32_t CRYPT_PBKDF2_SetCnt(CRYPT_PBKDF2_Ctx *ctx, const uint32_t iterCnt)
{
if (iterCnt == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_PARAM_ERROR);
return CRYPT_PBKDF2_PARAM_ERROR;
}
ctx->iterCnt = iterCnt;
return CRYPT_SUCCESS;
}
static int32_t Pbkdf2GetMdSize(CRYPT_PBKDF2_Ctx *ctx, const char *mdAttr)
{
if (ctx->hasGetMdSize) {
return CRYPT_SUCCESS;
}
void *libCtx = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
libCtx = ctx->libCtx;
#endif
EAL_MdMethod mdMeth = {0};
EAL_MacDepMethod depMeth = {.method = {.md = &mdMeth}};
int32_t ret = EAL_MacFindDepMethod(ctx->macId, libCtx, mdAttr, &depMeth, NULL, true);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ctx->mdSize = mdMeth.mdSize;
ctx->hasGetMdSize = true;
return CRYPT_SUCCESS;
}
#ifdef HITLS_CRYPTO_PROVIDER
static int32_t CRYPT_PBKDF2_SetMdAttr(CRYPT_PBKDF2_Ctx *ctx, const char *mdAttr, uint32_t valLen)
{
if (mdAttr == NULL || valLen == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_PARAM_ERROR);
return CRYPT_PBKDF2_PARAM_ERROR;
}
if (ctx->macCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_ERR_MAC_ID_NOT_SET);
return CRYPT_PBKDF2_ERR_MAC_ID_NOT_SET;
}
// Set mdAttr for macCtx
if (ctx->macMeth.setParam == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_ERR_MAC_METH);
return CRYPT_PBKDF2_ERR_MAC_METH;
}
BSL_Param param[] = {
{.key = CRYPT_PARAM_MD_ATTR, .valueType = BSL_PARAM_TYPE_UTF8_STR,
.value = (void *)(uintptr_t)mdAttr, .valueLen = valLen, .useLen = 0},
BSL_PARAM_END
};
int32_t ret = ctx->macMeth.setParam(ctx->macCtx, param);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
return Pbkdf2GetMdSize(ctx, mdAttr);
}
#endif
int32_t CRYPT_PBKDF2_SetParam(CRYPT_PBKDF2_Ctx *ctx, const BSL_Param *param)
{
uint32_t val = 0;
uint32_t len = 0;
const BSL_Param *temp = NULL;
int32_t ret = CRYPT_PBKDF2_PARAM_ERROR;
if (ctx == NULL || param == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if ((temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_KDF_MAC_ID)) != NULL) {
len = sizeof(val);
GOTO_ERR_IF(BSL_PARAM_GetValue(temp, CRYPT_PARAM_KDF_MAC_ID,
BSL_PARAM_TYPE_UINT32, &val, &len), ret);
GOTO_ERR_IF(CRYPT_PBKDF2_SetMacMethod(ctx, val), ret);
}
if ((temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_KDF_PASSWORD)) != NULL) {
GOTO_ERR_IF(CRYPT_PBKDF2_SetPassWord(ctx, temp->value, temp->valueLen), ret);
}
if ((temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_KDF_SALT)) != NULL) {
GOTO_ERR_IF(CRYPT_PBKDF2_SetSalt(ctx, temp->value, temp->valueLen), ret);
}
if ((temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_KDF_ITER)) != NULL) {
len = sizeof(val);
GOTO_ERR_IF(BSL_PARAM_GetValue(temp, CRYPT_PARAM_KDF_ITER,
BSL_PARAM_TYPE_UINT32, &val, &len), ret);
GOTO_ERR_IF(CRYPT_PBKDF2_SetCnt(ctx, val), ret);
}
#ifdef HITLS_CRYPTO_PROVIDER
if ((temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_MD_ATTR)) != NULL) {
GOTO_ERR_IF(CRYPT_PBKDF2_SetMdAttr(ctx, temp->value, temp->valueLen), ret);
}
#endif
ERR:
return ret;
}
int32_t CRYPT_PBKDF2_Derive(CRYPT_PBKDF2_Ctx *ctx, uint8_t *out, uint32_t len)
{
if (ctx == NULL || out == NULL || ctx->macCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (ctx->macMeth.deinit == NULL || ctx->macMeth.freeCtx == NULL || ctx->macMeth.init == NULL ||
ctx->macMeth.reinit == NULL || ctx->macMeth.update == NULL || ctx->macMeth.final == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_ERR_MAC_METH);
return CRYPT_PBKDF2_ERR_MAC_METH;
}
if (ctx->password == NULL && ctx->passLen > 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = Pbkdf2GetMdSize(ctx, NULL);
if (ret != CRYPT_SUCCESS) {
return ret;
}
// add keyLen limit based on rfc2898
if (ctx->mdSize == 0 || (ctx->passLen / ctx->mdSize) >= PBKDF2_MAX_KEYLEN) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_PARAM_ERROR);
return CRYPT_PBKDF2_PARAM_ERROR;
}
if (ctx->salt == NULL && ctx->saltLen > 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if ((len == 0) || (ctx->iterCnt == 0)) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_PARAM_ERROR);
return CRYPT_PBKDF2_PARAM_ERROR;
}
return CRYPT_PBKDF2_GenDk(ctx, out, len);
}
int32_t CRYPT_PBKDF2_Deinit(CRYPT_PBKDF2_Ctx *ctx)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (ctx->macMeth.freeCtx != NULL) {
ctx->macMeth.freeCtx(ctx->macCtx);
ctx->macCtx = NULL;
}
BSL_SAL_ClearFree((void *)ctx->password, ctx->passLen);
BSL_SAL_FREE(ctx->salt);
(void)memset_s(ctx, sizeof(CRYPT_PBKDF2_Ctx), 0, sizeof(CRYPT_PBKDF2_Ctx));
return CRYPT_SUCCESS;
}
void CRYPT_PBKDF2_FreeCtx(CRYPT_PBKDF2_Ctx *ctx)
{
if (ctx == NULL) {
return;
}
if (ctx->macMeth.freeCtx != NULL) {
ctx->macMeth.freeCtx(ctx->macCtx);
}
BSL_SAL_ClearFree((void *)ctx->password, ctx->passLen);
BSL_SAL_FREE(ctx->salt);
BSL_SAL_Free(ctx);
}
#endif // HITLS_CRYPTO_PBKDF2
| 2302_82127028/openHiTLS-examples_1508 | crypto/pbkdf2/src/pbkdf2.c | C | unknown | 15,120 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef PBKDF2_LOCAL_H
#define PBKDF2_LOCAL_H
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_PBKDF2
#include <stdint.h>
#include "crypt_local_types.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
/**
* @brief PBKDF Password-based key derivation function
*
* @param libCtx [IN] Library context
* @param macMeth [IN] Pointer to the HMAC algorithm method
* @param mdMeth [IN] MD algorithm method pointer
* @param key [IN] Password, a string entered by the user.
* @param keyLen [IN] Password length, which can be any length, including 0.
* @param salt [IN] Salt value, a string entered by the user.
* @param saltLen [IN] Salt value length, which can be any length, including 0.
* @param iterCnt [IN] Iteration times. The value can be any positive integer that is not 0.
* The value can be 1000 in special performance cases. The default value is 10000,
* 10000000 is recommended in cases where performance is insensitive or security requirements are high.
* @param out [OUT] Derived key.
* @param len [IN] Length of the derived key. The value range is [1, 0xFFFFFFFF].
*
* @return Success: CRYPT_SUCCESS
* For other error codes, see crypt_errno.h
*/
int32_t CRYPT_PBKDF2_HMAC(void *libCtx, const EAL_MacMethod *macMeth, CRYPT_MAC_AlgId macId, const EAL_MdMethod *mdMeth,
const uint8_t *key, uint32_t keyLen,
const uint8_t *salt, uint32_t saltLen,
uint32_t iterCnt, uint8_t *out, uint32_t len);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif // HITLS_CRYPTO_PBKDF2
#endif // PBKDF2_LOCAL_H
| 2302_82127028/openHiTLS-examples_1508 | crypto/pbkdf2/src/pbkdf2_local.h | C | unknown | 2,115 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/**
* @defgroup crypt_eal_provider
* @ingroup crypt
* @brief default provider impl
*/
#ifndef CRYPT_EAL_DEFAULT_PROVIDERIMPL_H
#define CRYPT_EAL_DEFAULT_PROVIDERIMPL_H
#ifdef HITLS_CRYPTO_PROVIDER
#include "crypt_eal_implprovider.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
#ifdef HITLS_CRYPTO_MD
#ifdef HITLS_CRYPTO_MD5
extern const CRYPT_EAL_Func g_defEalMdMd5[];
#endif // HITLS_CRYPTO_MD5
#ifdef HITLS_CRYPTO_SHA1
extern const CRYPT_EAL_Func g_defEalMdSha1[];
#endif // HITLS_CRYPTO_SHA1
#ifdef HITLS_CRYPTO_SHA224
extern const CRYPT_EAL_Func g_defEalMdSha224[];
#endif // HITLS_CRYPTO_SHA224
#ifdef HITLS_CRYPTO_SHA256
extern const CRYPT_EAL_Func g_defEalMdSha256[];
#endif // HITLS_CRYPTO_SHA256
#ifdef HITLS_CRYPTO_SHA384
extern const CRYPT_EAL_Func g_defEalMdSha384[];
#endif // HITLS_CRYPTO_SHA384
#ifdef HITLS_CRYPTO_SHA512
extern const CRYPT_EAL_Func g_defEalMdSha512[];
#endif // HITLS_CRYPTO_SHA512
#ifdef HITLS_CRYPTO_SHA3
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[];
#endif // HITLS_CRYPTO_SHA3
#ifdef HITLS_CRYPTO_SM3
extern const CRYPT_EAL_Func g_defEalMdSm3[];
#endif // HITLS_CRYPTO_SM3
#endif // HITLS_CRYPTO_MD
#ifdef HITLS_CRYPTO_MAC
#ifdef HITLS_CRYPTO_HMAC
extern const CRYPT_EAL_Func g_defEalMacHmac[];
#endif
#ifdef HITLS_CRYPTO_CMAC
extern const CRYPT_EAL_Func g_defEalMacCmac[];
#endif
#ifdef HITLS_CRYPTO_CBC_MAC
extern const CRYPT_EAL_Func g_defEalMacCbcMac[];
#endif
#ifdef HITLS_CRYPTO_GMAC
extern const CRYPT_EAL_Func g_defEalMacGmac[];
#endif
#ifdef HITLS_CRYPTO_SIPHASH
extern const CRYPT_EAL_Func g_defEalMacSiphash[];
#endif
#endif // HITLS_CRYPTO_MAC
#ifdef HITLS_CRYPTO_KDF
#ifdef HITLS_CRYPTO_SCRYPT
extern const CRYPT_EAL_Func g_defEalKdfScrypt[];
#endif
#ifdef HITLS_CRYPTO_PBKDF2
extern const CRYPT_EAL_Func g_defEalKdfPBKdf2[];
#endif
#ifdef HITLS_CRYPTO_KDFTLS12
extern const CRYPT_EAL_Func g_defEalKdfKdfTLS12[];
#endif
#ifdef HITLS_CRYPTO_HKDF
extern const CRYPT_EAL_Func g_defEalKdfHkdf[];
#endif
#endif // HITLS_CRYPTO_KDF
#ifdef HITLS_CRYPTO_CIPHER
#ifdef HITLS_CRYPTO_CBC
extern const CRYPT_EAL_Func g_defEalCbc[];
#endif
#ifdef HITLS_CRYPTO_CCM
extern const CRYPT_EAL_Func g_defEalCcm[];
#endif
#ifdef HITLS_CRYPTO_CFB
extern const CRYPT_EAL_Func g_defEalCfb[];
#endif
#if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
extern const CRYPT_EAL_Func g_defEalChaCha[];
#endif
#ifdef HITLS_CRYPTO_CTR
extern const CRYPT_EAL_Func g_defEalCtr[];
#endif
#ifdef HITLS_CRYPTO_ECB
extern const CRYPT_EAL_Func g_defEalEcb[];
#endif
#ifdef HITLS_CRYPTO_GCM
extern const CRYPT_EAL_Func g_defEalGcm[];
#endif
#ifdef HITLS_CRYPTO_OFB
extern const CRYPT_EAL_Func g_defEalOfb[];
#endif
#ifdef HITLS_CRYPTO_XTS
extern const CRYPT_EAL_Func g_defEalXts[];
#endif
#endif // HITLS_CRYPTO_CIPHER
#ifdef HITLS_CRYPTO_DRBG
extern const CRYPT_EAL_Func g_defEalRand[];
#endif // HITLS_CRYPTO_DRBG
#ifdef HITLS_CRYPTO_PKEY
#ifdef HITLS_CRYPTO_DSA
extern const CRYPT_EAL_Func g_defEalKeyMgmtDsa[];
#endif
#ifdef HITLS_CRYPTO_ED25519
extern const CRYPT_EAL_Func g_defEalKeyMgmtEd25519[];
#endif
#ifdef HITLS_CRYPTO_X25519
extern const CRYPT_EAL_Func g_defEalKeyMgmtX25519[];
#endif
#ifdef HITLS_CRYPTO_RSA
extern const CRYPT_EAL_Func g_defEalKeyMgmtRsa[];
#endif
#ifdef HITLS_CRYPTO_DH
extern const CRYPT_EAL_Func g_defEalKeyMgmtDh[];
#endif
#ifdef HITLS_CRYPTO_ECDSA
extern const CRYPT_EAL_Func g_defEalKeyMgmtEcdsa[];
#endif
#ifdef HITLS_CRYPTO_ECDH
extern const CRYPT_EAL_Func g_defEalKeyMgmtEcdh[];
#endif
#ifdef HITLS_CRYPTO_SM2
extern const CRYPT_EAL_Func g_defEalKeyMgmtSm2[];
#endif
#ifdef HITLS_CRYPTO_PAILLIER
extern const CRYPT_EAL_Func g_defEalKeyMgmtPaillier[];
#endif
#ifdef HITLS_CRYPTO_ELGAMAL
extern const CRYPT_EAL_Func g_defEalKeyMgmtElGamal[];
#endif
#ifdef HITLS_CRYPTO_MLDSA
extern const CRYPT_EAL_Func g_defEalKeyMgmtMlDsa[];
#endif
#ifdef HITLS_CRYPTO_SLH_DSA
extern const CRYPT_EAL_Func g_defEalKeyMgmtSlhDsa[];
#endif
#ifdef HITLS_CRYPTO_MLKEM
extern const CRYPT_EAL_Func g_defEalKeyMgmtMlKem[];
#endif
#ifdef HITLS_CRYPTO_HYBRIDKEM
extern const CRYPT_EAL_Func g_defEalKeyMgmtHybridKem[];
#endif
#ifdef HITLS_CRYPTO_X25519
extern const CRYPT_EAL_Func g_defEalExchX25519[];
#endif
#ifdef HITLS_CRYPTO_DH
extern const CRYPT_EAL_Func g_defEalExchDh[];
#endif
#ifdef HITLS_CRYPTO_ECDH
extern const CRYPT_EAL_Func g_defEalExchEcdh[];
#endif
#ifdef HITLS_CRYPTO_SM2_EXCH
extern const CRYPT_EAL_Func g_defEalExchSm2[];
#else
#define g_defEalExchSm2 NULL
#endif
#if defined(HITLS_CRYPTO_RSA_ENCRYPT) || defined(HITLS_CRYPTO_RSA_DECRYPT)
extern const CRYPT_EAL_Func g_defEalAsymCipherRsa[];
#else
#define g_defEalAsymCipherRsa NULL
#endif
#ifdef HITLS_CRYPTO_SM2_CRYPT
extern const CRYPT_EAL_Func g_defEalAsymCipherSm2[];
#else
#define g_defEalAsymCipherSm2 NULL
#endif
#ifdef HITLS_CRYPTO_PAILLIER
extern const CRYPT_EAL_Func g_defEalAsymCipherPaillier[];
#endif
#ifdef HITLS_CRYPTO_ELGAMAL
extern const CRYPT_EAL_Func g_defEalAsymCipherElGamal[];
#endif
#ifdef HITLS_CRYPTO_DSA
extern const CRYPT_EAL_Func g_defEalSignDsa[];
#endif
#ifdef HITLS_CRYPTO_ED25519
extern const CRYPT_EAL_Func g_defEalSignEd25519[];
#endif
#if defined(HITLS_CRYPTO_RSA_SIGN) || defined(HITLS_CRYPTO_RSA_VERIFY)
extern const CRYPT_EAL_Func g_defEalSignRsa[];
#else
#define g_defEalSignRsa NULL
#endif
#ifdef HITLS_CRYPTO_ECDSA
extern const CRYPT_EAL_Func g_defEalSignEcdsa[];
#endif
#ifdef HITLS_CRYPTO_SM2_SIGN
extern const CRYPT_EAL_Func g_defEalSignSm2[];
#else
#define g_defEalSignSm2 NULL
#endif
#ifdef HITLS_CRYPTO_MLDSA
extern const CRYPT_EAL_Func g_defEalSignMlDsa[];
#endif
#ifdef HITLS_CRYPTO_SLH_DSA
extern const CRYPT_EAL_Func g_defEalSignSlhDsa[];
#endif
#ifdef HITLS_CRYPTO_MLKEM
extern const CRYPT_EAL_Func g_defEalMlKem[];
#endif
#ifdef HITLS_CRYPTO_HYBRIDKEM
extern const CRYPT_EAL_Func g_defEalHybridKeyKem[];
#endif
#endif // HITLS_CRYPTO_PKEY
#ifdef HITLS_CRYPTO_CODECSKEY
#ifdef HITLS_CRYPTO_KEY_EPKI
extern const CRYPT_EAL_Func g_defEalPrvP8Enc2P8[];
#endif
#ifdef HITLS_BSL_PEM
extern const CRYPT_EAL_Func g_defEalPem2Der[];
#endif
#ifdef HITLS_CRYPTO_RSA
extern const CRYPT_EAL_Func g_defEalRsaPrvDer2Key[];
#endif
#ifdef HITLS_CRYPTO_ECDSA
extern const CRYPT_EAL_Func g_defEalEcdsaPrvDer2Key[];
#endif
#ifdef HITLS_CRYPTO_SM2
extern const CRYPT_EAL_Func g_defEalSm2PrvDer2Key[];
#endif
#ifdef HITLS_CRYPTO_RSA
extern const CRYPT_EAL_Func g_defEalP8Der2RsaKey[];
#endif
#ifdef HITLS_CRYPTO_ECDSA
extern const CRYPT_EAL_Func g_defEalP8Der2EcdsaKey[];
#endif
#ifdef HITLS_CRYPTO_SM2
extern const CRYPT_EAL_Func g_defEalP8Der2Sm2Key[];
#endif
#ifdef HITLS_CRYPTO_ED25519
extern const CRYPT_EAL_Func g_defEalP8Der2Ed25519Key[];
#endif
#ifdef HITLS_CRYPTO_RSA
extern const CRYPT_EAL_Func g_defEalSubPubKeyDer2RsaKey[];
#endif
#ifdef HITLS_CRYPTO_ECDSA
extern const CRYPT_EAL_Func g_defEalSubPubKeyDer2EcdsaKey[];
#endif
#ifdef HITLS_CRYPTO_SM2
extern const CRYPT_EAL_Func g_defEalSubPubKeyDer2Sm2Key[];
#endif
#ifdef HITLS_CRYPTO_ED25519
extern const CRYPT_EAL_Func g_defEalSubPubKeyDer2Ed25519Key[];
#endif
#ifdef HITLS_CRYPTO_RSA
extern const CRYPT_EAL_Func g_defEalSubPubKeyWithoutSeqDer2RsaKey[];
#endif
#ifdef HITLS_CRYPTO_ECDSA
extern const CRYPT_EAL_Func g_defEalSubPubKeyWithoutSeqDer2EcdsaKey[];
#endif
#ifdef HITLS_CRYPTO_SM2
extern const CRYPT_EAL_Func g_defEalSubPubKeyWithoutSeqDer2Sm2Key[];
#endif
#ifdef HITLS_CRYPTO_ED25519
extern const CRYPT_EAL_Func g_defEalSubPubKeyWithoutSeqDer2Ed25519Key[];
#endif
#ifdef HITLS_CRYPTO_RSA
extern const CRYPT_EAL_Func g_defEalLowKeyObject2PkeyObject[];
#endif
#ifdef HITLS_CRYPTO_RSA
extern const CRYPT_EAL_Func g_defEalRsaPubDer2Key[];
#endif
#endif // HITLS_CRYPTO_CODECSKEY
#ifdef __cplusplus
}
#endif // __cplusplus
#endif /* HITLS_CRYPTO_PROVIDER */
#endif // CRYPT_EAL_DEFAULT_PROVIDERIMPL_H | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/include/crypt_default_provderimpl.h | C | unknown | 8,594 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CRYPT_PROVIDER_H
#define CRYPT_PROVIDER_H
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_PROVIDER
#include "crypt_eal_provider.h"
#include "crypt_eal_implprovider.h"
#include "bsl_list.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cpluscplus */
#define CRYPT_EAL_DEFAULT_PROVIDER "default"
// Maximum length of provider name
#define DEFAULT_PROVIDER_NAME_LEN_MAX 255
typedef enum {
CRYPT_PROVIDER_GET_USER_CTX = 1,
CRYPT_PROVIDER_CTRL_MAX,
} CRYPT_ProviderCtrlCmd;
struct EAL_LibCtx {
BslList *providers; // managing providers
BSL_SAL_ThreadLockHandle lock;
char *searchProviderPath;
#ifdef HITLS_CRYPTO_DRBG
void *drbg;
#endif
};
#if defined(HITLS_CRYPTO_ENTROPY) && \
(defined(HITLS_CRYPTO_ENTROPY_GETENTROPY) || defined(HITLS_CRYPTO_ENTROPY_DEVRANDOM) || \
defined(HITLS_CRYPTO_ENTROPY_SYS) || defined(HITLS_CRYPTO_ENTROPY_HARDWARE))
#define HITLS_CRYPTO_ENTROPY_DEFAULT
#endif
int32_t CRYPT_EAL_InitPreDefinedProviders(void);
void CRYPT_EAL_FreePreDefinedProviders(void);
int32_t CRYPT_EAL_DefaultProvInit(CRYPT_EAL_ProvMgrCtx *mgrCtx, BSL_Param *param,
CRYPT_EAL_Func *capFuncs, CRYPT_EAL_Func **outFuncs, void **provCtx);
int32_t CRYPT_EAL_AddNewProvMgrCtx(CRYPT_EAL_LibCtx *libCtx, const char *providerName, const char *providerPath,
CRYPT_EAL_ImplProviderInit init, BSL_Param *param, CRYPT_EAL_ProvMgrCtx **ctx);
int32_t CRYPT_EAL_ProviderGetFuncsAndMgrCtx(CRYPT_EAL_LibCtx *libCtx, int32_t operaId, int32_t algId,
const char *attribute, const CRYPT_EAL_Func **funcs, CRYPT_EAL_ProvMgrCtx **mgrCtx);
CRYPT_EAL_LibCtx* CRYPT_EAL_GetGlobalLibCtx(void);
int32_t CRYPT_EAL_ProviderQuery(CRYPT_EAL_ProvMgrCtx *ctx, int32_t operaId, CRYPT_EAL_AlgInfo **algInfos);
#ifdef __cplusplus
}
#endif /* __cpluscplus */
#endif /* HITLS_CRYPTO_PROVIDER */
#endif /* CRYPT_PROVIDER_H */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/include/crypt_provider.h | C | unknown | 2,443 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include "crypt_cmvp.h"
#include "crypt_errno.h"
#include "bsl_err_internal.h"
#include "crypt_eal_implprovider.h"
#include "crypt_eal_cmvp.h"
#ifdef HITLS_CRYPTO_PROVIDER
static int32_t CRYPT_EAL_SetCmvpSelftestMethod(CRYPT_SelftestCtx *ctx, const CRYPT_EAL_Func *funcs)
{
int32_t index = 0;
EAL_CmvpSelftestMethod *method = BSL_SAL_Calloc(1, sizeof(EAL_CmvpSelftestMethod));
if (method == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
while (funcs[index].id != 0) {
switch (funcs[index].id) {
case CRYPT_EAL_IMPLSELFTEST_NEWCTX:
method->provNewCtx = funcs[index].func;
break;
case CRYPT_EAL_IMPLSELFTEST_GETVERSION:
method->getVersion = funcs[index].func;
break;
case CRYPT_EAL_IMPLSELFTEST_SELFTEST:
method->selftest = funcs[index].func;
break;
case CRYPT_EAL_IMPLSELFTEST_FREECTX:
method->freeCtx = funcs[index].func;
break;
default:
BSL_SAL_FREE(method);
BSL_ERR_PUSH_ERROR(CRYPT_PROVIDER_ERR_UNEXPECTED_IMPL);
return CRYPT_PROVIDER_ERR_UNEXPECTED_IMPL;
}
index++;
}
ctx->method = method;
return CRYPT_SUCCESS;
}
static CRYPT_SelftestCtx *CRYPT_CMVP_SelftestNewCtxInner(CRYPT_EAL_LibCtx *libCtx, const char *attrName)
{
const CRYPT_EAL_Func *funcs = NULL;
void *provCtx = NULL;
int32_t algId = CRYPT_CMVP_PROVIDER_SELFTEST;
int32_t ret = CRYPT_EAL_ProviderGetFuncs(libCtx, CRYPT_EAL_OPERAID_SELFTEST, algId, attrName,
&funcs, &provCtx);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return NULL;
}
CRYPT_SelftestCtx *ctx = BSL_SAL_Calloc(1u, sizeof(CRYPT_SelftestCtx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
ret = CRYPT_EAL_SetCmvpSelftestMethod(ctx, funcs);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
BSL_SAL_FREE(ctx);
return NULL;
}
if (ctx->method->provNewCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_PROVIDER_ERR_IMPL_NULL);
BSL_SAL_FREE(ctx->method);
BSL_SAL_FREE(ctx);
return NULL;
}
ctx->data = ctx->method->provNewCtx(provCtx);
if (ctx->data == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
BSL_SAL_FREE(ctx->method);
BSL_SAL_FREE(ctx);
return NULL;
}
ctx->id = algId;
ctx->isProvider = true;
return ctx;
}
#endif // HITLS_CRYPTO_PROVIDER
CRYPT_SelftestCtx *CRYPT_CMVP_SelftestNewCtx(CRYPT_EAL_LibCtx *libCtx, const char *attrName)
{
#ifdef HITLS_CRYPTO_PROVIDER
return CRYPT_CMVP_SelftestNewCtxInner(libCtx, attrName);
#else
(void)libCtx;
(void)attrName;
return NULL;
#endif
}
const char *CRYPT_CMVP_GetVersion(CRYPT_SelftestCtx *ctx)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return NULL;
}
if (ctx->method == NULL || ctx->method->getVersion == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_NOT_SUPPORT);
return NULL;
}
return ctx->method->getVersion(ctx->data);
}
int32_t CRYPT_CMVP_Selftest(CRYPT_SelftestCtx *ctx, const BSL_Param *param)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (ctx->method == NULL || ctx->method->selftest == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_NOT_SUPPORT);
return CRYPT_EAL_ALG_NOT_SUPPORT;
}
return ctx->method->selftest(ctx->data, param);
}
void CRYPT_CMVP_SelftestFreeCtx(CRYPT_SelftestCtx *ctx)
{
if (ctx == NULL) {
return;
}
if (ctx->method != NULL && ctx->method->freeCtx != NULL) {
ctx->method->freeCtx(ctx->data);
}
BSL_SAL_FREE(ctx->method);
BSL_SAL_FREE(ctx);
}
#endif /* HITLS_CRYPTO_CMVP */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp.c | C | unknown | 4,640 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <dlfcn.h>
#include <syslog.h>
#include <stdarg.h>
#include "securec.h"
#include "crypt_cmvp.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_err.h"
#include "crypt_errno.h"
#include "bsl_sal.h"
#include "crypt_cmvp_selftest.h"
#include "cmvp_integrity_hmac.h"
#include "cmvp_common.h"
#define BSL_PARAM_MAX_NUMBER 1000
uint8_t *CMVP_StringsToBins(const char *in, uint32_t *outLen)
{
if (in == NULL) {
return NULL;
}
uint32_t inLen = (uint32_t)strlen(in);
uint8_t *out = NULL;
if (inLen == 0) {
return NULL;
}
// The length of a hexadecimal string must be a multiple of 2.
if (inLen % 2 != 0) {
return NULL;
}
// Length of the hexadecimal string / 2 = Length of the byte stream
inLen = inLen / 2;
out = BSL_SAL_Malloc(inLen);
if (out == NULL) {
return NULL;
}
*outLen = inLen;
// A group of 2 bytes
for (uint32_t i = 0; i < 2 * inLen; i += 2) {
// Formula for converting hex to int: (Hex% 32 + 9)% 25 = int, hexadecimal, 16: high 4 bits.
out[i / 2] = ((uint8_t)in[i] % 32 + 9) % 25 * 16 + ((uint8_t)in[i + 1] % 32 + 9) % 25;
}
return out;
}
void CMVP_WriteSyslog(const char *ident, int32_t priority, const char *format, ...)
{
va_list vargs;
va_start(vargs, format);
openlog(ident, LOG_PID | LOG_ODELAY, LOG_USER);
vsyslog(priority, format, vargs);
closelog();
va_end(vargs);
}
char *CMVP_ReadFile(const char *path, const char *mode, uint32_t *bufLen)
{
int64_t len;
int64_t readLen;
FILE *fp = NULL;
char *buf = NULL;
fp = fopen(path, mode);
if (fp == NULL) {
return false;
}
GOTO_ERR_IF_TRUE(fseek(fp, 0, SEEK_END) != 0, CRYPT_CMVP_COMMON_ERR);
len = ftell(fp);
GOTO_ERR_IF_TRUE(len == -1, CRYPT_CMVP_COMMON_ERR);
buf = BSL_SAL_Malloc((uint32_t)len + 1);
GOTO_ERR_IF_TRUE(buf == NULL, CRYPT_MEM_ALLOC_FAIL);
buf[len] = '\0';
GOTO_ERR_IF_TRUE(fseek(fp, 0, SEEK_SET) != 0, CRYPT_CMVP_COMMON_ERR);
readLen = (int64_t)fread(buf, sizeof(uint8_t), (uint64_t)len, fp);
GOTO_ERR_IF_TRUE(readLen != len && feof(fp) == 0, CRYPT_CMVP_COMMON_ERR);
*bufLen = (uint32_t)readLen;
(void)fclose(fp);
return buf;
ERR:
BSL_SAL_Free(buf);
(void)fclose(fp);
return NULL;
}
static char *CMVP_GetLibPath(void *func)
{
Dl_info info;
char *path = NULL;
GOTO_ERR_IF_TRUE(dladdr(func, &info) == 0, CRYPT_CMVP_COMMON_ERR);
path = BSL_SAL_Malloc((uint32_t)strlen(info.dli_fname) + 1);
GOTO_ERR_IF_TRUE(path == NULL, CRYPT_MEM_ALLOC_FAIL);
(void)memcpy_s(path, strlen(info.dli_fname), info.dli_fname, strlen(info.dli_fname));
path[strlen(info.dli_fname)] = '\0';
return path;
ERR:
BSL_SAL_Free(path);
return NULL;
}
int32_t CMVP_CheckIntegrity(void *libCtx, const char *attrName, CRYPT_MAC_AlgId macId)
{
int32_t ret = CRYPT_CMVP_ERR_INTEGRITY;
char *libCryptoPath = NULL;
char *libBslPath = NULL;
if (CRYPT_CMVP_SelftestProviderMac(libCtx, attrName, macId) != true) {
return CRYPT_CMVP_ERR_ALGO_SELFTEST;
}
libCryptoPath = CMVP_GetLibPath(CMVP_IntegrityHmac);
GOTO_ERR_IF_TRUE(libCryptoPath == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(CMVP_IntegrityHmac(libCtx, attrName, libCryptoPath, macId) == false, CRYPT_CMVP_ERR_INTEGRITY);
libBslPath = CMVP_GetLibPath(BSL_SAL_Malloc);
GOTO_ERR_IF_TRUE(libBslPath == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(CMVP_IntegrityHmac(libCtx, attrName, libBslPath, macId) == false, CRYPT_CMVP_ERR_INTEGRITY);
ret = CRYPT_SUCCESS;
ERR:
BSL_SAL_Free(libCryptoPath);
BSL_SAL_Free(libBslPath);
return ret;
}
static int32_t CopyParam(BSL_Param *param, int32_t *selfTestFlag, BSL_Param **newParam)
{
int32_t index = 0;
if (param != NULL) {
while (param[index].key != 0 && index < BSL_PARAM_MAX_NUMBER) {
index++;
}
if (index >= BSL_PARAM_MAX_NUMBER) {
BSL_ERR_PUSH_ERROR(CRYPT_CMVP_COMMON_ERR);
return CRYPT_CMVP_COMMON_ERR;
}
}
int32_t count = index + 2;
BSL_Param *tmpParam = (BSL_Param *)BSL_SAL_Calloc(count, sizeof(BSL_Param));
if (tmpParam == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
if (param != NULL) {
(void)memcpy_s(tmpParam, count * sizeof(BSL_Param), param, index * sizeof(BSL_Param));
}
int32_t ret = BSL_PARAM_InitValue(&tmpParam[index], CRYPT_PARAM_CMVP_INTERNAL_LIBCTX_FLAG, BSL_PARAM_TYPE_INT32,
selfTestFlag, sizeof(int32_t));
if (ret != BSL_SUCCESS) {
BSL_SAL_FREE(tmpParam);
return ret;
}
*newParam = tmpParam;
return CRYPT_SUCCESS;
}
int32_t CMVP_CreateInternalLibCtx(BSL_Param *param, CRYPT_EAL_LibCtx **libCtx, void *func)
{
int32_t selfTestFlag = 1;
int32_t ret = CRYPT_SUCCESS;
char *libPath = NULL;
BSL_Param *newParam = NULL;
CRYPT_EAL_LibCtx *ctx = NULL;
do {
ret = CopyParam(param, &selfTestFlag, &newParam);
if (ret != CRYPT_SUCCESS) {
break;
}
ctx = CRYPT_EAL_LibCtxNew();
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
ret = CRYPT_MEM_ALLOC_FAIL;
break;
}
libPath = CMVP_GetLibPath(func);
if (libPath == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_CMVP_COMMON_ERR);
ret = CRYPT_CMVP_COMMON_ERR;
break;
}
ret = CRYPT_EAL_ProviderLoad(ctx, 0, libPath, newParam, NULL);
if (ret != CRYPT_SUCCESS) {
break;
}
*libCtx = ctx;
} while (0);
if (ret != CRYPT_SUCCESS) {
CRYPT_EAL_LibCtxFree(ctx);
}
BSL_SAL_Free(libPath);
BSL_SAL_Free(newParam);
return ret;
}
bool CMVP_CheckIsInternalLibCtx(BSL_Param *param)
{
if (param == NULL) {
return false;
}
BSL_Param *temp = BSL_PARAM_FindParam(param, CRYPT_PARAM_CMVP_INTERNAL_LIBCTX_FLAG);
if (temp != NULL && temp->valueType == BSL_PARAM_TYPE_INT32) {
return true;
}
return false;
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */ | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_common.c | C | unknown | 7,001 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CMVP_COMMON_H
#define CMVP_COMMON_H
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <stdint.h>
#include <stdbool.h>
#include <syslog.h>
#include "crypt_cmvp.h"
#include "crypt_types.h"
#include "crypt_algid.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
uint8_t *CMVP_StringsToBins(const char *in, uint32_t *outLen); // Converting a hexadecimal string to a buf array
void CMVP_WriteSyslog(const char *ident, int32_t priority, const char *format, ...)
__attribute__((format(printf, 3, 4))); // Write syslog
char *CMVP_ReadFile(const char *path, const char *mode, uint32_t *bufLen); // Read file
int32_t CMVP_CheckIntegrity(void *libCtx, const char *attrName, CRYPT_MAC_AlgId macId);
int32_t CMVP_CreateInternalLibCtx(BSL_Param *param, CRYPT_EAL_LibCtx **libCtx, void *func);
bool CMVP_CheckIsInternalLibCtx(BSL_Param *param);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
#endif // CMVP_COMMON_H
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_common.h | C | unknown | 1,652 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "cmvp_common.h"
#include "crypt_eal_mac.h"
#include "crypt_errno.h"
#include "bsl_err.h"
#include "securec.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
#include "cmvp_integrity_hmac.h"
#ifndef CMVP_INTEGRITYKEY
#define CMVP_INTEGRITYKEY ""
#endif
const char *GetIntegrityKey(void)
{
return CMVP_INTEGRITYKEY;
}
static uint8_t *GetLibHmac(void *libCtx, const char *attrName, CRYPT_MAC_AlgId id, const char *libPath,
uint32_t *hmacLen)
{
char *buf = NULL;
uint8_t *hmac = NULL;
uint32_t bufLen;
CRYPT_EAL_MacCtx *ctx = NULL;
buf = CMVP_ReadFile(libPath, "rb", &bufLen);
GOTO_ERR_IF_TRUE(buf == NULL, CRYPT_CMVP_COMMON_ERR);
ctx = CRYPT_EAL_ProviderMacNewCtx(libCtx, id, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
*hmacLen = CRYPT_EAL_GetMacLen(ctx);
hmac = BSL_SAL_Malloc(*hmacLen);
GOTO_ERR_IF_TRUE(hmac == NULL, CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_TRUE(CRYPT_EAL_MacInit(ctx, (const uint8_t *)GetIntegrityKey(), (uint32_t)strlen(GetIntegrityKey())) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_INTEGRITY);
GOTO_ERR_IF_TRUE(CRYPT_EAL_MacUpdate(ctx, (uint8_t *)buf, bufLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_INTEGRITY);
GOTO_ERR_IF_TRUE(CRYPT_EAL_MacFinal(ctx, hmac, hmacLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_INTEGRITY);
BSL_SAL_Free(buf);
CRYPT_EAL_MacFreeCtx(ctx);
return hmac;
ERR:
BSL_SAL_Free(buf);
BSL_SAL_Free(hmac);
CRYPT_EAL_MacFreeCtx(ctx);
return NULL;
}
static uint8_t *GetExpectHmac(const char *hmacPath, uint32_t *hmacLen)
{
uint8_t *hmac = NULL;
char *buf = NULL;
uint32_t bufLen;
char seps[] = " \n";
char *tmp = NULL;
char *nextTmp = NULL;
buf = CMVP_ReadFile(hmacPath, "r", &bufLen);
GOTO_ERR_IF_TRUE(buf == NULL, CRYPT_CMVP_COMMON_ERR);
// HMAC-SHA256(libhitls_crypto.so)= 76a90d73cb68585837a2ebdf009e9e485acba4fd718bae898bdc354537f8a72a\n
// The format of the generated .hmac file is as shown in the preceding figure.
// The content between spaces and newline characters is truncated.
tmp = strtok_s(buf, seps, &nextTmp);
GOTO_ERR_IF_TRUE(tmp == NULL, CRYPT_CMVP_COMMON_ERR);
tmp = strtok_s(NULL, seps, &nextTmp);
GOTO_ERR_IF_TRUE(tmp == NULL, CRYPT_CMVP_COMMON_ERR);
hmac = CMVP_StringsToBins(tmp, hmacLen);
GOTO_ERR_IF_TRUE(hmac == NULL, CRYPT_CMVP_COMMON_ERR);
BSL_SAL_Free(buf);
return hmac;
ERR:
BSL_SAL_Free(buf);
BSL_SAL_Free(hmac);
return NULL;
}
bool CMVP_IntegrityHmac(void *libCtx, const char *attrName, const char *libPath, CRYPT_MAC_AlgId id)
{
bool ret = false;
char *hmacPath = NULL;
uint8_t *hmac = NULL;
uint8_t *expectHmac = NULL;
uint32_t hmacLen, expectHmacLen;
hmacPath = BSL_SAL_Malloc((uint32_t)strlen(libPath) + (uint32_t)strlen(".hmac") + 1);
GOTO_ERR_IF_TRUE(hmacPath == NULL, CRYPT_MEM_ALLOC_FAIL);
(void)sprintf_s(hmacPath, strlen(libPath) + strlen(".hmac") + 1, "%s%s", libPath, ".hmac");
hmacPath[strlen(libPath) + strlen(".hmac")] = '\0';
hmac = GetLibHmac(libCtx, attrName, id, libPath, &hmacLen);
GOTO_ERR_IF_TRUE(hmac == NULL, CRYPT_CMVP_ERR_INTEGRITY);
expectHmac = GetExpectHmac(hmacPath, &expectHmacLen);
GOTO_ERR_IF_TRUE(expectHmac == NULL, CRYPT_CMVP_ERR_INTEGRITY);
GOTO_ERR_IF_TRUE(hmacLen != expectHmacLen, CRYPT_CMVP_ERR_INTEGRITY);
GOTO_ERR_IF_TRUE(memcmp(expectHmac, hmac, hmacLen) != 0, CRYPT_CMVP_ERR_INTEGRITY);
ret = true;
ERR:
BSL_SAL_Free(hmac);
BSL_SAL_Free(expectHmac);
BSL_SAL_Free(hmacPath);
return ret;
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_integrity_hmac.c | C | unknown | 4,406 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CMVP_INTEGRITY_HMAC_H
#define CMVP_INTEGRITY_HMAC_H
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <stdbool.h>
#include "crypt_algid.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
// When the HMAC is used to perform integrity verification, a failure message is returned,
// and the module does not enter the error state.
bool CMVP_IntegrityHmac(void *libCtx, const char *attrName, const char *libPath, CRYPT_MAC_AlgId id);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
#endif /* CMVP_INTEGRITY_HMAC_H */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_integrity_hmac.h | C | unknown | 1,253 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <math.h>
#include <float.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_log_internal.h"
#include "bsl_binlog_id.h"
#include "crypt_errno.h"
#include "crypt_cmvp.h"
#define ALPHA (0.01)
#define MAXITERTIMES 1e5
#define BITSPERBYTE 8
static uint8_t *Byte2Bits(const uint8_t *data, uint32_t len)
{
if (data == NULL || len == 0) {
return NULL;
}
uint8_t *bits = BSL_SAL_Malloc(sizeof(uint8_t) * (len * BITSPERBYTE));
if (bits == NULL) {
return NULL;
}
for (uint32_t i = 0; i < len; i++) {
uint32_t j = i * 8;
bits[j + 7] = data[i] & 0x01; // bit0 offset 7
bits[j + 6] = (data[i] >> 1) & 0x01; // bit1 offset 6
bits[j + 5] = (data[i] >> 2) & 0x01; // bit2 offset 5
bits[j + 4] = (data[i] >> 3) & 0x01; // bit3 offset 4
bits[j + 3] = (data[i] >> 4) & 0x01; // bit4 offset 3
bits[j + 2] = (data[i] >> 5) & 0x01; // bit5 offset 2
bits[j + 1] = (data[i] >> 6) & 0x01; // bit6 offset 1
bits[j] = (data[i] >> 7) & 0x01; // bit7 offset 0
}
return bits;
}
static double IgammaFraction(double a, double x);
static double IgammaSeries(double a, double x);
// Upper Incomplete Gamma Function
static double Igamc(double a, double x)
{
if (a <= 0 || x <= 0) {
return 1.0;
}
if (x < a + 1.0) {
return 1.0 - IgammaSeries(a, x);
} else {
return IgammaFraction(a, x);
}
}
// Evaluate upper igamma by continued fraction
// use Lentz's algorithm to calculate the continued fraction
// where ak = k(a - k), bk = (x - a + 2k + 1)
// define
// C_n = b_n + a_n / C_(n-1)
// D_n = 1 / (b_n + a_n * D_(n - 1))
// then f_n = C_n * D_n * f_n-1 converges to Igamc
// see https://en.wikipedia.org/wiki/Lentz%27s_algorithm for detailed information.
static double IgammaFraction(double a, double x)
{
double an, bn = x + 1.0 - a;
double factor = a * log(x) - x - lgamma(a);
if (factor >= DBL_MAX_EXP) {
return 1.0; // float underflow
}
factor = exp(factor);
double c = 1 / DBL_MIN;
double d = 1.0 / bn;
double prod = d;
for (uint32_t k = 1; k < MAXITERTIMES; k++) {
an = ((double)k) * (a - (double)k); // ak = k(a - k)
bn += 2.0; // bk = (x - a + 2.0 * k + 1)
c = bn + an / c;
d = bn + an * d;
if (fabs(c) < DBL_MIN) {
break; // float underflow
}
if (fabs(d) < DBL_MIN) {
break; // float underflow
}
d = 1 / d;
prod *= (d * c);
}
return factor * prod;
}
// Evaluate lower incomplete gamma function by series representation
static double IgammaSeries(double a, double x)
{
double sum = 0, bn = 1, factor, ak = a;
factor = a * log(x) - x - lgamma(a);
if (factor >= DBL_MAX_EXP) {
return 0.0; // float underflow
}
factor = exp(factor);
for (uint32_t k = 1; k < MAXITERTIMES; k++) {
sum += bn;
ak += 1;
bn *= x / ak;
}
return (sum / a) * factor;
}
static int32_t MonobitTest(const uint8_t *data, uint32_t len)
{
double s = 0.0;
double v;
double pValue;
for (uint32_t i = 0; i < len; i++) {
s += 2 * (data[i]) - 1; // 2: convert 0, 1 to -1, 1
}
v = fabs(s) / sqrt(len);
pValue = erfc((v / sqrt(2.0))); // 2.0: divide by square root of 2.
return pValue >= ALPHA ? CRYPT_SUCCESS : CRYPT_CMVP_RANDOMNESS_ERR;
}
static int32_t CMVP_MonobitTest(const uint8_t *data, uint32_t len)
{
if (data == NULL) {
return CRYPT_CMVP_RANDOMNESS_ERR;
}
// length of data must be larger than 100 bits in GM/T 0005-2016
return len > 100 ? MonobitTest(data, len) : CRYPT_CMVP_RANDOMNESS_ERR;
}
static uint8_t DataToIndex(const uint8_t* data, const int32_t blocklen)
{
uint8_t s = 0;
for (int32_t i = 0; i < blocklen; i++) {
s += (data[i] << (blocklen - i - 1));
}
return s;
}
static int32_t PokerTest(const uint8_t *data, uint32_t len, int32_t blocklen)
{
uint32_t N = len / blocklen;
uint32_t maxComb = (uint32_t)pow(2.0, (double)blocklen);
uint32_t *dict = BSL_SAL_Malloc(maxComb * sizeof(uint32_t));
if (dict == NULL) {
return CRYPT_CMVP_RANDOMNESS_ERR;
}
memset_s(dict, maxComb * sizeof(uint32_t), 0, maxComb * sizeof(uint32_t));
for (uint32_t i = 0; (uint32_t)(i + blocklen) <= len; i += (uint32_t)blocklen) {
dict[DataToIndex(data + i, blocklen)]++;
}
double s = 0.0;
for (uint32_t i = 0; i < maxComb; i++) {
s += pow(dict[i], 2); // 2: square each dict value
}
double v = (pow(2.0, (double)blocklen) / (double) N) * s - N;
double pValue = Igamc(((double)maxComb - 1.0) / 2.0, v / 2.0); // p_value = igamc((2^m - 1) / 2, v / 2)
BSL_SAL_FREE(dict);
return pValue >= ALPHA ? CRYPT_SUCCESS : CRYPT_CMVP_RANDOMNESS_ERR;
}
static int32_t CMVP_PokerTest(const uint8_t *data, uint32_t len)
{
if (data == NULL || len == 0) {
return CRYPT_CMVP_RANDOMNESS_ERR;
}
// blocklen can be 2, 4 or 8 in GM/T 0005-2016, blocklen can't be greater than 8.
for (int blocklen = 8; blocklen >= 2; blocklen -= 2) {
// [n/m] >= 5 * 2^m in GM/T 0005-2016 chart B.1
if ((uint32_t)(len / blocklen) >= 5 * pow(2, blocklen)) {
return PokerTest(data, len, blocklen);
}
}
return CRYPT_CMVP_RANDOMNESS_ERR;
}
typedef struct {
int32_t (*testFunc)(const uint8_t *data, uint32_t len);
char *name;
} DRBG_TEST;
int32_t CRYPT_CMVP_RandomnessTest(const uint8_t *data, const uint32_t len)
{
int32_t ret = CRYPT_SUCCESS;
if (len > UINT32_MAX / BITSPERBYTE) {
return CRYPT_CMVP_RANDOMNESS_ERR;
}
uint8_t *bits = Byte2Bits(data, len);
if (bits == NULL) {
return CRYPT_CMVP_RANDOMNESS_ERR;
}
const DRBG_TEST testList[] = {
{CMVP_MonobitTest, "BIT FREQUENCY TEST"},
{CMVP_PokerTest, "POKER TEST"},
};
for (uint32_t i = 0; i < sizeof(testList) / sizeof(testList[0]); i++) {
if (testList[i].testFunc != NULL && testList[i].testFunc(bits, len * BITSPERBYTE) != CRYPT_SUCCESS) {
ret = CRYPT_CMVP_RANDOMNESS_ERR;
break;
}
}
BSL_SAL_FREE(bits);
return ret;
}
#endif /* HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_randomness.c | C | unknown | 6,960 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_cipher.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
typedef struct {
const char *key;
const char *iv;
const char *aad;
const char *plaintext;
const char *ciphertext;
const char *tag;
} CMVP_CHACHA20POLY1305_VECTOR;
// https://datatracker.ietf.org/doc/html/rfc7539.html#page-22
static const CMVP_CHACHA20POLY1305_VECTOR CHACHA20POLY1305_VECTOR = {
.key = "808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f",
.iv = "070000004041424344454647",
.aad = "50515253c0c1c2c3c4c5c6c7",
.plaintext = "4c616469657320616e642047656e746c656d656e206f662074686520636c617373206f6620273939"
"3a204966204920636f756c64206f6666657220796f75206f6e6c79206f6e652074697020666f7220"
"746865206675747572652c2073756e73637265656e20776f756c642062652069742e",
.ciphertext = "d31a8d34648e60db7b86afbc53ef7ec2a4aded51296e08fea9e2b5a736ee62d63dbea45e8ca96712"
"82fafb69da92728b1a71de0a9e060b2905d6a5b67ecd3b3692ddbd7f2d778b8c9803aee328091b58"
"fab324e4fad675945585808b4831d7bc3ff4def08e4b7a9de576d26586cec64b6116",
.tag = "1ae10b594f09e26a7e902ecbd0600691"
};
static bool GetData(CRYPT_Data *key, CRYPT_Data *iv, CRYPT_Data *aad, CRYPT_Data *data, CRYPT_Data *cipher)
{
key->data = CMVP_StringsToBins(CHACHA20POLY1305_VECTOR.key, &(key->len));
GOTO_ERR_IF_TRUE(key->data == NULL, CRYPT_CMVP_COMMON_ERR);
iv->data = CMVP_StringsToBins(CHACHA20POLY1305_VECTOR.iv, &(iv->len));
GOTO_ERR_IF_TRUE(iv->data == NULL, CRYPT_CMVP_COMMON_ERR);
aad->data = CMVP_StringsToBins(CHACHA20POLY1305_VECTOR.aad, &(aad->len));
GOTO_ERR_IF_TRUE(aad->data == NULL, CRYPT_CMVP_COMMON_ERR);
data->data = CMVP_StringsToBins(CHACHA20POLY1305_VECTOR.plaintext, &(data->len));
GOTO_ERR_IF_TRUE(data->data == NULL, CRYPT_CMVP_COMMON_ERR);
cipher->data = CMVP_StringsToBins(CHACHA20POLY1305_VECTOR.ciphertext, &(cipher->len));
GOTO_ERR_IF_TRUE(cipher->data == NULL, CRYPT_CMVP_COMMON_ERR);
return true;
ERR:
return false;
}
static void FreeData(CRYPT_Data key, CRYPT_Data iv, CRYPT_Data aad, CRYPT_Data data, CRYPT_Data cipher)
{
BSL_SAL_Free(key.data);
BSL_SAL_Free(iv.data);
BSL_SAL_Free(aad.data);
BSL_SAL_Free(data.data);
BSL_SAL_Free(cipher.data);
}
static bool CRYPT_CMVP_SelftestChacha20poly1305Internal(void *libCtx, const char *attrName)
{
bool ret = false;
CRYPT_Data key = { NULL, 0 };
CRYPT_Data iv = { NULL, 0 };
CRYPT_Data aad = { NULL, 0 };
CRYPT_Data data = { NULL, 0 };
CRYPT_Data cipher = { NULL, 0 };
CRYPT_Data tag = { NULL, 0 };
uint8_t *out = NULL;
uint8_t *outTag = NULL;
uint32_t outLen;
uint32_t first;
int32_t err = CRYPT_CMVP_ERR_ALGO_SELFTEST;
CRYPT_EAL_CipherCtx *ctx = NULL;
GOTO_ERR_IF_TRUE(!GetData(&key, &iv, &aad, &data, &cipher), err);
tag.data = CMVP_StringsToBins(CHACHA20POLY1305_VECTOR.tag, &(tag.len));
GOTO_ERR_IF_TRUE(tag.data == NULL, CRYPT_CMVP_COMMON_ERR);
outTag = BSL_SAL_Malloc(tag.len);
outLen = cipher.len;
out = BSL_SAL_Malloc(outLen);
GOTO_ERR_IF_TRUE(outTag == NULL || out == NULL, CRYPT_MEM_ALLOC_FAIL);
first = data.len / 2; // The length of the data in the first operation is 1/2 of the data.
ctx = CRYPT_EAL_ProviderCipherNewCtx(libCtx, CRYPT_CIPHER_CHACHA20_POLY1305, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherInit(ctx, key.data, key.len, iv.data, iv.len, true) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad.data, aad.len) != CRYPT_SUCCESS, err);
outLen = first;
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherUpdate(ctx, data.data, first, out, &outLen) != CRYPT_SUCCESS, err);
outLen = data.len - first;
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherUpdate(ctx, data.data + first, data.len - first,
out + first, &outLen) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, outTag, (uint32_t)tag.len) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(memcmp(out, cipher.data, cipher.len) != 0, err);
GOTO_ERR_IF_TRUE(memcmp(outTag, tag.data, tag.len) != 0, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherInit(ctx, key.data, key.len, iv.data, iv.len, false) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad.data, aad.len) != CRYPT_SUCCESS, err);
outLen = cipher.len;
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherUpdate(ctx, cipher.data, cipher.len, out, &outLen) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(memcmp(out, data.data, data.len) != 0, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, outTag, (uint32_t)tag.len) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(memcmp(outTag, tag.data, tag.len) != 0, err);
ret = true;
ERR:
FreeData(key, iv, aad, data, cipher);
BSL_SAL_Free(tag.data);
BSL_SAL_Free(outTag);
BSL_SAL_Free(out);
CRYPT_EAL_CipherFreeCtx(ctx);
return ret;
}
bool CRYPT_CMVP_SelftestChacha20poly1305(void)
{
return CRYPT_CMVP_SelftestChacha20poly1305Internal(NULL, NULL);
}
bool CRYPT_CMVP_SelftestProviderChacha20poly1305(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestChacha20poly1305Internal(libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */ | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_chacha20poly1305.c | C | unknown | 6,126 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <stdio.h>
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_cipher.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_local_types.h"
#include "bsl_sal.h"
#include <securec.h>
typedef struct {
uint32_t id;
const char *key;
const char *aad;
const char *iv;
const char *plaintext;
const char *ciphertext;
const char *tag;
uint32_t mode;
} CMVP_CIPHER_VECTOR;
// https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38a.pdf
static const CMVP_CIPHER_VECTOR CIPHER_VECTOR[] = {
// CRYPT_CIPHER_AES128_CBC
{
.id = CRYPT_CIPHER_AES128_CBC,
.key = "2b7e151628aed2a6abf7158809cf4f3c",
.aad = NULL,
.iv = "000102030405060708090a0b0c0d0e0f",
.plaintext = "6bc1bee22e409f96e93d7e117393172a",
.ciphertext = "7649abac8119b246cee98e9b12e9197d",
.tag = NULL,
.mode = CRYPT_MODE_CBC
},
// CRYPT_CIPHER_AES192_CBC
{
.id = CRYPT_CIPHER_AES192_CBC,
.key = "8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b",
.aad = NULL,
.iv = "000102030405060708090a0b0c0d0e0f",
.plaintext = "6bc1bee22e409f96e93d7e117393172a",
.ciphertext = "4f021db243bc633d7178183a9fa071e8",
.tag = NULL,
.mode = CRYPT_MODE_CBC
},
// CRYPT_CIPHER_AES256_CBC
{
.id = CRYPT_CIPHER_AES256_CBC,
.key = "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
.aad = NULL,
.iv = "000102030405060708090a0b0c0d0e0f",
.plaintext = "6bc1bee22e409f96e93d7e117393172a",
.ciphertext = "f58c4c04d6e5f1ba779eabfb5f7bfbd6",
.tag = NULL,
.mode = CRYPT_MODE_CBC
},
// CRYPT_CIPHER_AES128_CTR
{
.id = CRYPT_CIPHER_AES128_CTR,
.key = "2b7e151628aed2a6abf7158809cf4f3c",
.aad = NULL,
.iv = "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
.plaintext = "6bc1bee22e409f96e93d7e117393172a",
.ciphertext = "874d6191b620e3261bef6864990db6ce",
.tag = NULL,
.mode = CRYPT_MODE_CTR
},
// CRYPT_CIPHER_AES192_CTR
{
.id = CRYPT_CIPHER_AES192_CTR,
.key = "8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b",
.aad = NULL,
.iv = "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
.plaintext = "6bc1bee22e409f96e93d7e117393172a",
.ciphertext = "1abc932417521ca24f2b0459fe7e6e0b",
.tag = NULL,
.mode = CRYPT_MODE_CTR
},
// CRYPT_CIPHER_AES256_CTR
{
.id = CRYPT_CIPHER_AES256_CTR,
.key = "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
.aad = NULL,
.iv = "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
.plaintext = "6bc1bee22e409f96e93d7e117393172a",
.ciphertext = "601ec313775789a5b7a7f504bbf3d228",
.tag = NULL,
.mode = CRYPT_MODE_CTR
},
// CRYPT_CIPHER_AES128_ECB
// https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/
// aes/XTSTestVectors.zip
{
.id = CRYPT_CIPHER_AES128_ECB,
.key = "2b7e151628aed2a6abf7158809cf4f3c",
.aad = NULL,
.iv = NULL,
.plaintext = "6bc1bee22e409f96e93d7e117393172a",
.ciphertext = "3ad77bb40d7a3660a89ecaf32466ef97",
.tag = NULL,
.mode = CRYPT_MODE_ECB
},
// CRYPT_CIPHER_AES192_ECB
{
.id = CRYPT_CIPHER_AES192_ECB,
.key = "8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b",
.aad = NULL,
.iv = NULL,
.plaintext = "6bc1bee22e409f96e93d7e117393172a",
.ciphertext = "bd334f1d6e45f25ff712a214571fa5cc",
.tag = NULL,
.mode = CRYPT_MODE_ECB
},
// CRYPT_CIPHER_AES256_ECB
{
.id = CRYPT_CIPHER_AES256_ECB,
.key = "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
.aad = NULL,
.iv = NULL,
.plaintext = "6bc1bee22e409f96e93d7e117393172a",
.ciphertext = "f3eed1bdb5d2a03c064b5a7e3db181f8",
.tag = NULL,
.mode = CRYPT_MODE_ECB
},
// CRYPT_CIPHER_AES128_XTS
{
.id = CRYPT_CIPHER_AES128_XTS,
.key = "a1b90cba3f06ac353b2c343876081762090923026e91771815f29dab01932f2f",
.aad = NULL,
.iv = "4faef7117cda59c66e4b92013e768ad5",
.plaintext = "ebabce95b14d3c8d6fb350390790311c",
.ciphertext = "778ae8b43cb98d5a825081d5be471c63",
.tag = NULL,
.mode = CRYPT_MODE_XTS
},
// CRYPT_CIPHER_AES256_XTS
{
.id = CRYPT_CIPHER_AES256_XTS,
.key = "e149be00177d76b7c1d85bcbb6b5054ee10b9f51cd73f59e0840628b9e7d854e2e1c0a"
"b0537186a2a7c314bbc5eb23b6876a26bcdbf9e6b758d1cae053c2f278",
.aad = NULL,
.iv = "0ea18818fab95289b1caab4e61349501",
.plaintext = "f5f101d8e3a7681b1ddb21bd2826b24e32990bca49b39291b5369a9bca277d75",
.ciphertext = "5bf2479393cc673306fbb15e72600598e33d4d8a470727ce098730fd80afa959",
.tag = NULL,
.mode = CRYPT_MODE_XTS
},
// CRYPT_CIPHER_AES128_CCM
// http://csrc.nist.gov/groups/STM/cavp/documents/mac/ccmtestvectors.zip
{
.id = CRYPT_CIPHER_AES128_CCM,
.key = "f149e41d848f59276cfddd743bafa9a9",
.aad = "f5827e",
.iv = "14b756d66fc51134e203d1c6f9",
.plaintext = "9759e6f21f5a588010f57e6d6eae178d8b20ab59cda66f42",
.ciphertext = "f634bf00f1f9f1f93f41049d7f3797b05e805f0b14850f4e78e2a23411147a6187da6818506232ee",
.tag = NULL,
.mode = CRYPT_MODE_CCM
},
// CRYPT_CIPHER_AES192_CCM
{
.id = CRYPT_CIPHER_AES192_CCM,
.key = "393dcac5a28d77297946d7ab471ae03bd303ba3499e2ce26",
.aad = "1c8b",
.iv = "fe7329f343f6e726a90b11ae37",
.plaintext = "262f4ac988812500cb437f52f0c182148e85a0bec67a2736",
.ciphertext = "e6d43f822ad168aa9c2e29c07f4592d7bbeb0203f418f3020ecdbc200be353112faf20e2be711908",
.tag = NULL,
.mode = CRYPT_MODE_CCM
},
// CRYPT_CIPHER_AES256_CCM
{
.id = CRYPT_CIPHER_AES256_CCM,
.key = "c5a850167a5bfdf56636ce9e56e2952855504e35cc4f5d24ee5e168853be82d8",
.aad = "4759557e9bab",
.iv = "c45b165477e8bfa9ca3a1cd3ca",
.plaintext = "e758796d7db73bccb1697c42df691ac57974b40ca9186a43",
.ciphertext = "93ad58bd5f4f77ac4f92b0ae16c62489e4074c7f152e2ed8a88179e0d32f4928eff13b4ce2873338",
.tag = NULL,
.mode = CRYPT_MODE_CCM
},
// CRYPT_CIPHER_AES128_GCM
// http://csrc.nist.gov/groups/STM/cavp/documents/mac/gcmtestvectors.zip
{
.id = CRYPT_CIPHER_AES128_GCM,
.key = "07a6be880a58f572dbc2ad74a56db8b6",
.aad = "de4269feea1a439d6e8990fd6f9f9d5bc67935294425255ea89b6f6772d680fd656b06"
"581a5d8bc5c017ab532b4a9b83a55fde58cdfb3d2a8fef3aa426bc59d3e32f09d3cc20"
"b1ceb9a9e349d1068a0aa3d39617fae0582ccef0",
.iv = "95fc6654e6dc3a8adf5e7a69",
.plaintext = "7680b48b5d28f38cdeab2d5851769394a3e141b990ec4bdf79a33e5315ac0338",
.ciphertext = "095635c7e0eac0fc1059e67e1a936b6f72671121f96699fed520e5f8aff777f0",
.tag = "b2235f6d4bdd7b9c0901711048859d47",
.mode = CRYPT_MODE_GCM
},
// CRYPT_CIPHER_AES192_GCM
{
.id = CRYPT_CIPHER_AES192_GCM,
.key = "4e2d3d59e95884dc3aab32afdb96938cc6e9016d7f21e95f",
.aad = "bd0dbced527c4df9e76c67405cfd0536ef45d6a392b789370356d71a12ee0cacbca6d8a8caa96d4c89923ddb6ba96622",
.iv = "48fd791bf49a798a54fcdc60",
.plaintext = "8e36651ba5bf9a6f903e01080083feeb",
.ciphertext = "f96e2cc58714fd512b1fdbeba770b460",
.tag = "63dfe1bbd756237a43150c82341486",
.mode = CRYPT_MODE_GCM
},
// CRYPT_CIPHER_AES256_GCM
{
.id = CRYPT_CIPHER_AES256_GCM,
.key = "4c8cacccd8a55ec4222f3ec3996b23c4e86f9ab9c1312d53a7eb9b8891085ad9",
.aad = "7dc38ba88808f3e0c7c08111e3f305b7f26ebb0f8915ab1d06b6eaa09ec9258fef04f4"
"0c174d7cf4161653582058e611d667077""cbf0a974b632ed8d486dd807e2d9e8d8ef3"
"749d2b2105e2a3161fe0b42b09fae30db42958aa94",
.iv = "d9e80f9ab45c186c846b3605",
.plaintext = "24ed8a0023a9e11d127488234c285956",
.ciphertext = "4df94bd82b1b284e2dda6dccbbe5076f",
.tag = "241e6c864aabc4a99e344a5d",
.mode = CRYPT_MODE_GCM
},
// CRYPT_CIPHER_CHACHA20_POLY1305
{
.id = CRYPT_CIPHER_CHACHA20_POLY1305,
.key = NULL,
.aad = NULL,
.iv = NULL,
.plaintext = NULL,
.ciphertext = NULL,
.tag = NULL,
.mode = CRYPT_MODE_CHACHA20_POLY1305
},
// CRYPT_CIPHER_SM4_CBC
// http://c.gb688.cn/bzgk/gb/showGb?type=online&hcno=4F89D833626340B1F71068D25EAC737D
// GB/T 17964-2021
{
.id = CRYPT_CIPHER_SM4_CBC,
.key = "2b7e151628aed2a6abf7158809cf4f3c",
.aad = NULL,
.iv = "000102030405060708090A0b0C0D0E0F",
.plaintext = "6BC1BEE22E409F96E93D7E117393172A",
.ciphertext = "AC529AF989A62FCE9CDDC5FFB84125CA",
.tag = NULL,
.mode = CRYPT_MODE_CBC
},
// CRYPT_CIPHER_SM4_XTS
// GB/T 17964-2021
{
.id = CRYPT_CIPHER_SM4_XTS,
.key = "2b7e151628aed2a6abf7158809cf4f3c000102030405060708090a0b0c0d0e0f",
.aad = NULL,
.iv = "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
.plaintext = "6BC1BEE22E409F96E93D7E117393172AAE2D8A571E03AC9C9EB76FAC45AF8E5130C81C46A35CE411E5FBC1191A0A52EFF69F2445DF4F9B17",
.ciphertext = "E9538251C71D7B80BBE4483FEF497BD12C5C581BD6242FC51E08964FB4F60FDB0BA42F63499279213D318D2C11F6886E903BE7F93A1B3479",
.tag = NULL,
.mode = CRYPT_MODE_XTS
},
// CRYPT_CIPHER_SM4_ECB
// GB/T 17964-2021
{
.id = CRYPT_CIPHER_SM4_ECB,
.key = "2b7e151628aed2a6abf7158809cf4f3c",
.aad = NULL,
.iv = NULL,
.plaintext = "6BC1BEE22E409F96E93D7E117393172A",
.ciphertext = "A51411ff04a711443891fce7ab842a29",
.tag = NULL,
.mode = CRYPT_MODE_ECB
},
// CRYPT_CIPHER_SM4_CTR
// GB/T 17964-2021
{
.id = CRYPT_CIPHER_SM4_CTR,
.key = "2b7e151628aed2a6abf7158809cf4f3c",
.aad = NULL,
.iv = "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
.plaintext = "6BC1BEE22E409F96E93D7E117393172A",
.ciphertext = "14AE4A72B97A93CE1216CCD998E371C1",
.tag = NULL,
.mode = CRYPT_MODE_CTR
},
// CRYPT_CIPHER_SM4_GCM
// https://www.rfc-editor.org/rfc/rfc8998.html
{
.id = CRYPT_CIPHER_SM4_GCM,
.key = "0123456789ABCDEFFEDCBA9876543210",
.aad = "FEEDFACEDEADBEEFFEEDFACEDEADBEEFABADDAD2",
.iv = "00001234567800000000ABCD",
.plaintext = "AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFEEEEEEEEEEEEEEEEAAAAAAAAAAAAAAAA",
.ciphertext = "17F399F08C67D5EE19D0DC9969C4BB7D5FD46FD3756489069157B282BB200735D82710CA5C22F0CCFA7CBF93D496AC15A56834CBCF98C397B4024A2691233B8D",
.tag = "83DE3541E4C2B58177E065A9BF7B62EC",
.mode = CRYPT_MODE_GCM
},
// CRYPT_CIPHER_SM4_CFB
// GB/T 17964-2021
{
.id = CRYPT_CIPHER_SM4_CFB,
.key = "2b7e151628aed2a6abf7158809cf4f3c",
.aad = NULL,
.iv = "000102030405060708090A0B0C0D0E0F",
.plaintext = "6BC1BEE22E409F96E93D7E117393172A",
.ciphertext = "bc710d762d070b26361da82b54565e46",
.tag = NULL,
.mode = CRYPT_MODE_CFB
},
// CRYPT_CIPHER_SM4_OFB
// GB/T 17964-2021
{
.id = CRYPT_CIPHER_SM4_OFB,
.key = "2b7e151628aed2a6abf7158809cf4f3c",
.aad = NULL,
.iv = "000102030405060708090A0B0C0D0E0F",
.plaintext = "6BC1BEE22E409F96E93D7E117393172A",
.ciphertext = "BC710D762D070B26361DA82B54565E46",
.tag = NULL,
.mode = CRYPT_MODE_OFB
},
// https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38a.pdf
// CRYPT_CIPHER_AES128_CFB
{
.id = CRYPT_CIPHER_AES128_CFB,
.key = "2b7e151628aed2a6abf7158809cf4f3c",
.aad = NULL,
.iv = "000102030405060708090a0b0c0d0e0f",
.plaintext = "6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c8"
"1c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710",
.ciphertext = "3b3fd92eb72dad20333449f8e83cfb4ac8a64537a0b3a93fcde3cdad9f1ce58b2675"
"1f67a3cbb140b1808cf187a4f4dfc04b05357c5d1c0eeac4c66f9ff7f2e6",
.tag = NULL,
.mode = CRYPT_MODE_CFB
},
// CRYPT_CIPHER_AES192_CFB
{
.id = CRYPT_CIPHER_AES192_CFB,
.key = "8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b",
.aad = NULL,
.iv = "000102030405060708090a0b0c0d0e0f",
.plaintext = "6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c8"
"1c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710",
.ciphertext = "cdc80d6fddf18cab34c25909c99a417467ce7f7f81173621961a2b70171d3d7a2e1e"
"8a1dd59b88b1c8e60fed1efac4c9c05f9f9ca9834fa042ae8fba584b09ff",
.tag = NULL,
.mode = CRYPT_MODE_CFB
},
// CRYPT_CIPHER_AES256_CFB
{
.id = CRYPT_CIPHER_AES256_CFB,
.key = "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
.aad = NULL,
.iv = "000102030405060708090a0b0c0d0e0f",
.plaintext = "6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c8"
"1c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710",
.ciphertext = "dc7e84bfda79164b7ecd8486985d386039ffed143b28b1c832113c6331e5407bdf10"
"132415e54b92a13ed0a8267ae2f975a385741ab9cef82031623d55b1e471",
.tag = NULL,
.mode = CRYPT_MODE_CFB
},
// CRYPT_CIPHER_AES128_OFB
{
.id = CRYPT_CIPHER_AES128_OFB,
.key = "2b7e151628aed2a6abf7158809cf4f3c",
.aad = NULL,
.iv = "000102030405060708090a0b0c0d0e0f",
.plaintext = "6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c8"
"1c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710",
.ciphertext = "3b3fd92eb72dad20333449f8e83cfb4a7789508d16918f03f53c52dac54ed8259740"
"051e9c5fecf64344f7a82260edcc304c6528f659c77866a510d9c1d6ae5e",
.tag = NULL,
.mode = CRYPT_MODE_OFB
},
// CRYPT_CIPHER_AES192_OFB
{
.id = CRYPT_CIPHER_AES192_OFB,
.key = "8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b",
.aad = NULL,
.iv = "000102030405060708090a0b0c0d0e0f",
.plaintext = "6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c8"
"1c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710",
.ciphertext = "cdc80d6fddf18cab34c25909c99a4174fcc28b8d4c63837c09e81700c11004018d9a"
"9aeac0f6596f559c6d4daf59a5f26d9f200857ca6c3e9cac524bd9acc92a",
.tag = NULL,
.mode = CRYPT_MODE_OFB
},
// CRYPT_CIPHER_AES256_OFB
{
.id = CRYPT_CIPHER_AES256_OFB,
.key = "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
.aad = NULL,
.iv = "000102030405060708090a0b0c0d0e0f",
.plaintext = "6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c8"
"1c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710",
.ciphertext = "dc7e84bfda79164b7ecd8486985d38604febdc6740d20b3ac88f6ad82a4fb08d71ab"
"47a086e86eedf39d1c5bba97c4080126141d67f37be8538f5a8be740e484",
.tag = NULL,
.mode = CRYPT_MODE_OFB
}
};
typedef struct {
CRYPT_Data key;
CRYPT_Data iv;
CRYPT_Data aad;
CRYPT_Data plainText;
CRYPT_Data cipherText;
CRYPT_Data tag;
} CIPHER_SELFTEST_DATA;
bool CipherEnc(void *libCtx, const char *attrName, CRYPT_CIPHER_AlgId id, CIPHER_SELFTEST_DATA data)
{
bool ret = false;
CRYPT_EAL_CipherCtx *ctx = NULL;
uint32_t finLen;
uint32_t len = data.cipherText.len;
uint8_t *out = BSL_SAL_Malloc(len);
GOTO_ERR_IF_TRUE(out == NULL, CRYPT_MEM_ALLOC_FAIL);
memset_s(out, len, 0, len);
ctx = CRYPT_EAL_ProviderCipherNewCtx(libCtx, id, attrName);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherInit(ctx, data.key.data, data.key.len, data.iv.data, data.iv.len, true) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherUpdate(ctx, data.plainText.data, data.plainText.len, out, &len) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(data.cipherText.len < len, CRYPT_CMVP_ERR_ALGO_SELFTEST);
finLen = data.cipherText.len - len;
CRYPT_EAL_CipherFinal(ctx, out + len, &finLen);
GOTO_ERR_IF_TRUE(memcmp(out, data.cipherText.data, data.cipherText.len) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(out);
CRYPT_EAL_CipherFreeCtx(ctx);
return ret;
}
bool CipherDec(void *libCtx, const char *attrName, CRYPT_CIPHER_AlgId id, CIPHER_SELFTEST_DATA data)
{
bool ret = false;
CRYPT_EAL_CipherCtx *ctx = NULL;
uint32_t finLen;
uint32_t len = data.plainText.len;
uint8_t *out = BSL_SAL_Malloc(len);
GOTO_ERR_IF_TRUE(out == NULL, CRYPT_MEM_ALLOC_FAIL);
ctx = CRYPT_EAL_ProviderCipherNewCtx(libCtx, id, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherInit(ctx, data.key.data, data.key.len, data.iv.data, data.iv.len, false) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherUpdate(ctx, data.cipherText.data, data.cipherText.len, out, &len) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(data.plainText.len < len, CRYPT_CMVP_ERR_ALGO_SELFTEST);
finLen = data.plainText.len - len;
CRYPT_EAL_CipherFinal(ctx, out + len, &finLen);
GOTO_ERR_IF_TRUE(memcmp(out, data.plainText.data, data.plainText.len) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(out);
CRYPT_EAL_CipherFreeCtx(ctx);
return ret;
}
bool AesAeadEnc(void *libCtx, const char *attrName, const CMVP_CIPHER_VECTOR *cipherVec, CIPHER_SELFTEST_DATA data)
{
bool ret = false;
uint64_t msgLen = data.plainText.len;
uint32_t cipherLen = data.cipherText.len;
uint8_t *cipher = NULL;
uint32_t tagLen;
uint8_t *tag = NULL;
uint32_t finLen;
CRYPT_EAL_CipherCtx *ctx = NULL;
cipher = BSL_SAL_Malloc(cipherLen);
GOTO_ERR_IF_TRUE(cipher == NULL, CRYPT_MEM_ALLOC_FAIL);
if (cipherVec->mode == CRYPT_MODE_GCM) {
tagLen = data.tag.len;
tag = BSL_SAL_Malloc(tagLen);
GOTO_ERR_IF_TRUE(tag == NULL, CRYPT_ERR_ALGID);
} else {
tagLen = data.cipherText.len - data.plainText.len;
}
ctx = CRYPT_EAL_ProviderCipherNewCtx(libCtx, cipherVec->id, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherInit(ctx, data.key.data, data.key.len, data.iv.data, data.iv.len, true) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
if (cipherVec->mode == CRYPT_MODE_CCM) {
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &msgLen, sizeof(msgLen)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, data.aad.data, data.aad.len) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
cipherLen = data.plainText.len;
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherUpdate(ctx, data.plainText.data, data.plainText.len, cipher, &cipherLen) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(data.cipherText.len < cipherLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
finLen = data.cipherText.len - cipherLen;
if (cipherVec->mode != CRYPT_MODE_CCM && cipherVec->mode != CRYPT_MODE_GCM) {
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherFinal(ctx, cipher + cipherLen, &finLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
if (cipherVec->mode == CRYPT_MODE_CCM) {
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, cipher + msgLen, tagLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(cipher, data.cipherText.data, data.cipherText.len) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
} else {
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(cipher, data.cipherText.data, data.cipherText.len) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(tag, data.tag.data, data.tag.len) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
ret = true;
ERR:
BSL_SAL_Free(tag);
BSL_SAL_Free(cipher);
CRYPT_EAL_CipherFreeCtx(ctx);
return ret;
}
bool AesAeadDec(void *libCtx, const char *attrName, const CMVP_CIPHER_VECTOR *cipherVec, CIPHER_SELFTEST_DATA data)
{
bool ret = false;
uint32_t tagLen;
uint8_t *tag = NULL;
uint64_t msgLen = data.plainText.len;
uint32_t plainLen = data.plainText.len;
uint8_t *plain = NULL;
CRYPT_EAL_CipherCtx *ctx = NULL;
plain = BSL_SAL_Malloc(plainLen);
GOTO_ERR_IF_TRUE(plain == NULL, CRYPT_MEM_ALLOC_FAIL);
if (cipherVec->mode == CRYPT_MODE_CCM) {
tagLen = data.cipherText.len - data.plainText.len;
} else {
tagLen = data.tag.len;
}
tag = BSL_SAL_Malloc(tagLen);
GOTO_ERR_IF_TRUE(tag == NULL, CRYPT_MEM_ALLOC_FAIL);
ctx = CRYPT_EAL_ProviderCipherNewCtx(libCtx, cipherVec->id, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherInit(ctx, data.key.data, data.key.len, data.iv.data, data.iv.len, false) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
if (cipherVec->mode == CRYPT_MODE_CCM) {
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &msgLen, sizeof(msgLen)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, data.aad.data, data.aad.len) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherUpdate(ctx, data.cipherText.data, data.plainText.len, plain, &plainLen) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(data.plainText.len != plainLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(plain, data.plainText.data, data.plainText.len) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
if (cipherVec->mode == CRYPT_MODE_CCM) {
GOTO_ERR_IF_TRUE(memcmp(tag, data.cipherText.data + msgLen, tagLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
} else {
GOTO_ERR_IF_TRUE(memcmp(tag, data.tag.data, tagLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
ret = true;
ERR:
BSL_SAL_Free(tag);
BSL_SAL_Free(plain);
CRYPT_EAL_CipherFreeCtx(ctx);
return ret;
}
const CMVP_CIPHER_VECTOR *FindCipherVectorById(CRYPT_CIPHER_AlgId id)
{
uint32_t num = sizeof(CIPHER_VECTOR) / sizeof(CIPHER_VECTOR[0]);
const CMVP_CIPHER_VECTOR *cipherVec = NULL;
for (uint32_t i = 0; i < num; i++) {
if (CIPHER_VECTOR[i].id == id) {
cipherVec = &CIPHER_VECTOR[i];
return cipherVec;
}
}
return NULL;
}
static bool CRYPT_CMVP_SelftestCipherInternal(void *libCtx, const char *attrName, CRYPT_CIPHER_AlgId id)
{
const CMVP_CIPHER_VECTOR *cipherVec = FindCipherVectorById(id);
if (cipherVec == NULL || cipherVec->key == NULL) {
return false;
}
bool ret = false;
CIPHER_SELFTEST_DATA data = {
{ NULL, 0 }, { NULL, 0 }, { NULL, 0 }, { NULL, 0 }, { NULL, 0 }, { NULL, 0 },
};
data.key.data = CMVP_StringsToBins(cipherVec->key, &(data.key.len));
GOTO_ERR_IF_TRUE(data.key.data == NULL, CRYPT_CMVP_COMMON_ERR);
if (cipherVec->iv != NULL) {
data.iv.data = CMVP_StringsToBins(cipherVec->iv, &(data.iv.len));
GOTO_ERR_IF_TRUE(data.iv.data == NULL, CRYPT_CMVP_COMMON_ERR);
}
data.plainText.data = CMVP_StringsToBins(cipherVec->plaintext, &(data.plainText.len));
GOTO_ERR_IF_TRUE(data.plainText.data == NULL, CRYPT_CMVP_COMMON_ERR);
data.cipherText.data = CMVP_StringsToBins(cipherVec->ciphertext, &(data.cipherText.len));
GOTO_ERR_IF_TRUE(data.cipherText.data == NULL, CRYPT_CMVP_COMMON_ERR);
if (cipherVec->aad != NULL) {
data.aad.data = CMVP_StringsToBins(cipherVec->aad, &(data.aad.len));
GOTO_ERR_IF_TRUE(data.aad.data == NULL, CRYPT_CMVP_COMMON_ERR);
}
if (cipherVec->tag != NULL) {
data.tag.data = CMVP_StringsToBins(cipherVec->tag, &(data.tag.len));
GOTO_ERR_IF_TRUE(data.tag.data == NULL, CRYPT_CMVP_COMMON_ERR);
}
if (cipherVec->mode == CRYPT_MODE_CCM || cipherVec->mode == CRYPT_MODE_GCM) {
GOTO_ERR_IF_TRUE(AesAeadEnc(libCtx, attrName, cipherVec, data) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(AesAeadDec(libCtx, attrName, cipherVec, data) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
} else {
GOTO_ERR_IF_TRUE(CipherEnc(libCtx, attrName, id, data) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CipherDec(libCtx, attrName, id, data) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
ret = true;
ERR:
BSL_SAL_Free(data.key.data);
BSL_SAL_Free(data.iv.data);
BSL_SAL_Free(data.cipherText.data);
BSL_SAL_Free(data.plainText.data);
BSL_SAL_Free(data.aad.data);
BSL_SAL_Free(data.tag.data);
return ret;
}
bool CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AlgId id)
{
return CRYPT_CMVP_SelftestCipherInternal(NULL, NULL, id);
}
bool CRYPT_CMVP_SelftestProviderCipher(void *libCtx, const char *attrName, CRYPT_CIPHER_AlgId id)
{
return CRYPT_CMVP_SelftestCipherInternal(libCtx, attrName, id);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_cipher.c | C | unknown | 27,208 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
typedef struct {
CRYPT_PKEY_ParaId paraId;
const char *p;
const char *q;
const char *g;
const char *xa;
const char *ya;
const char *xb;
const char *yb;
const char *z;
} CMVP_DH_VECTOR;
// https://csrc.nist.gov/projects/cryptographic-algorithm-validation-program/key-management
static const CMVP_DH_VECTOR DH_VECTOR_MODP2048 = {
.paraId = CRYPT_DH_RFC3526_2048,
.p = "f528aa2762df76d7802fea087005d76feb69b7afd9e7fb363715a1b44f09dbda5d06a6"
"3e3d512abe9c6810abba2bfd48cf554513712df25f786265a75f4e1dacaacbbe9e528a"
"6346a8bf38015ecbc523d4e78d738b8852bcd66600dc434286c78f6ccae992568b258b"
"b0d3b503e37e7a956ec1616978c1e7989229e39914ea7c1bea3902e669dfc62368da13"
"7448350c1def54bf3ee2142c065601dfae6bca07e93cc463393cbc483b2c7272553788"
"2ed5b96074f519fc738f5033b87b5edca0ec4a34dc0f84d2fa2c365f691a8fc7dc64bc"
"0839a5813fef9af385c68e952af566f79b0802be9900cf0838032ed249afea05572154"
"0c8961e6300ad5dec651c7",
.q = "fa472bf5133f45b4c7ab14078e1281b487fc4fde1422ba4cafa2a64ea1aad989",
.g = "085c0a0512c241b583d41703edfbfea2a3e863deac68855097707967e097186ef89d05"
"c65227f56b12de6123bac86c3c13d680994bffaf24b2a1ed7f01c108b06593f22f74b4"
"af222b46e5fb89482fbd96f5451c9f45393136ec037aa81a81245459ec018024518394"
"f4d936596dc53c3d8a9f732903719796c045b62fadea9dd1b2fabec1560ddb3b780d96"
"46ad0dd3168c07cc994f79ee804cae07573912511de050d05a0d58b819ec41e7c1205d"
"c7199fc65a6a1a4ffcb4df38d9b6757269003401d84c732385a55174f27d4b493cb710"
"980c3af98be7bcff9467e81792f2d2f9a2f8d5d0ddc9a229790192a194da5b2032f2f0"
"cc23ffbcb2cc166f2128ee",
.xa = "e62d8fdb14fcdc8e4b0c254216eb584a8e79115a294119806ac660cc9d0e3222",
.ya = "815e1c8e64be6786b6c2194506b661199a56c807c6340a83697d3bc75304fbeb91bb15"
"ac7981babba260a653e666b0da8012042a088547f0fbd1ef56d1d1f65ed809ca854513"
"9f57d3ebda3e0f13e7ef19bded4a8dfa204f2457a3d392839dd70bec538a29d7887470"
"9f905ec28740be157696aa862b57ab51ef20033601ff83ba3fb0e80255674e0e6e7269"
"cd85ca10379d418b737d3cdeb5f31fb06f4a141145936a9eec0551b4ba59c59d2b3edd"
"c19ea18978279cf11f21a65a9d2a104cfe6af93fa8a1ccd18b03017a8ab31943993192"
"f794d87bbc273ef9160af954480783cfb6a37ba085503ba258169a8daba71d4c52de7c"
"4e65472223c202ad277e93",
.xb = "561c948be9d0d968cdfc6d27cbfe52cda342f544f56d57f118866326f76e1f70",
.yb = "3c24973b3296269759ce38e2e525c0095d4b5c34be5d13b45b222b8e489c27fb4442f3"
"2cc764665e28a06655c71fb37fd875a921d179551a1e4f2a9054a76cae2a61d3cbec55"
"c3be19853a5409d9ff914b93bc78b8aa1525b908f32419a88d7726ead76a3f8895d630"
"71a9b0a63fe4728d19518d1d08088141b8269f0b0cd77112d476af9efcc7f590af8fc1"
"f9dc5e4c00cd5dfa64a33b2df4db9d8594d87489bea6f6f37958bfb598e5692b81bf11"
"6b60227b6252a6438f049c5c449bab027740f8551bf1ffe25084f231ff646388d009ba"
"22193262029ba19af2643dd679f283212a2d26ad917efe9642c748fceb33fb0a6c132f"
"378dada2cccede086d8a31",
.z = "ec2309a7d238aeb06714c27c1bbbb1b1c5aa3cdddd76a419b1f3704dd3437cd1f2c884"
"3f350d67872ee325973f4e5ace7d406be5de75d9a9120af67e32f0291e77e7a3976249"
"29d63dc0c42ef8f442ce89a39b192fee386ce68301c4b828ea9189798346b60f615dd9"
"639105ffea6ec61ee5e4a7d68ce72bbf1281d6864e30181ce419952a3ef83a9ad7b26f"
"c7292ad745bfb543e5c2ea310a4159e9d660279d12c1e03850e837c01c542a0f59ad61"
"d0731005e8009a3d8406691abb22f5f2e96ae345783c403e59b9e948addbea8ac7d770"
"821044e03f15ae6fc367ddc85ba62a26b4d94d7705f5ecad8aa21b619d0e09f124bee8"
"658a2187f7029107105dbf"
};
// Test vectors sourced from NIST ACVP-Server.
static const CMVP_DH_VECTOR DH_VECTOR_FFDHE2048 = {
.paraId = CRYPT_DH_RFC7919_2048,
.p = NULL,
.q = NULL,
.g = NULL,
.xa = "39983F0CD77A92B44E304AF18C811DB1DB2B820055F1A6CC8B78BFFFA57EB08299664B"
"2CF76C3D5564FEC48C2F2F56AA63ACED5D11AB0B3390C008A94BD4351416DC978F5750"
"410A2B618105EE9847DC9AB12AB39C971522EF97919E57C4DE706614FE20037738F871"
"7895D5BC41458C437DA33F89745D6D742CC29632C0AF0A36CE0B99E0231D4C27833E71"
"60F2687801462D5AA038B89A802B5E1ADF42A1D97C142D5851103E9034AE33B7916397"
"D23BA16B9FF481FC1FD45FE35AA85E27B0E6A58A60A8E37D2A4D237793C4FA4E1E04ED"
"F6090A4331237C9F8C2C19076367762D92491024A5F6B3BA510496154E05B43CE1A722"
"9F793ABD2458095B3D9C78",
.ya = "5FA0CB4D5A976B11442FFDA4569FFF10058E41988C78D0AB6E39B2E226EEFB7C13B9FD"
"65720940118134762CD1ADE1EA83AF64548D8C8BFFA564C8747860FF816AE9C6F13797"
"9FA7C2A4D3E12A3DE68986B43F14CC808E61FAEBAF702FF523795459CFCD19F83563F2"
"5EFC0E57277512FAA8FA23CEF3C8F1D517ABED113FECEE21D926D96BA52A716B5FCDF1"
"87D1ACD999A9CFA951311A042C55C693B20B0DDD98C2F2BBEF67E77FD9E18F0D52045E"
"0B424ED3ECBBD2F34E008FD5C7B482B99CED2A7963DFCA54C5EF9E1FB56F4450B7312C"
"F389D66A696479A6BFEE031D2ECED27969A4061E73331C63B6F21BD7D6E8358FF052F8"
"71DE595DFD57752016D1CA",
.xb = "78502F2AF8969B51D50D2756BAA5EF936FA735B2B2F8423E00D347FF6FB078F14BFA8B"
"2A01A4CBF700C4861A7C65C7EFA026B6AAA7A60B944B09364D29AC3A9C10F6066AA0BB"
"0115BA15E3934A6C9E981B5732E03A32FC23B3B320089F4EA6CFB31C6C7107E99C3063"
"751238D21352BE40B602F94131D9C2D26E3444437D58ED0793D48ACC50749235F26B66"
"837923750E5801F91ED3584A585A0FB213142312A438BE35A309D87009C30F40D49D2E"
"D554F9D6BCBE84F54AB6382E7425FCADAED9D11909FA4624647B963605BC68896A34DA"
"5C7F20447AD19C3381F87F40DC63969855A50E92D4448E432189697F7CAB4191D2B175"
"6BB01FF62D4CA1661F6A33",
.yb = "8CDD3810AA88A5410A5E416A68E9CD31A4542EEC0073A67D12300D3DC1EE5890AFE2DA"
"CA654BFC29C63E1D011C7A52E3DE8D89A3771F43F6921521BB137D25459C90E46F090B"
"FD53B58901109A28F587B96A35828C3464ACF6F80D9646494CF4389FD82BFE4E7AE2BB"
"E5CA2694D7967F56A0E92D43E8C119BD81B7A50516BFA8B39BBEA538AE56556808F4B5"
"C3BAD84A76A5EB373D596DBEF75AB90A49C902615C7386334B70BAE9AC0C4E953DB03B"
"883B64E7E3C3FDD547C6BC3C004D032A57BA40E06DCB0E87016DDADED991FF34FD6ECA"
"06635041DD98C0C4C1DEF942C751DB3F5218BC7C2F6039AF2323F473D3775ED27936FD"
"2E209541C9FAEAE2A75874",
.z = "024E9786943F8AA48E0FC7B2862D620A6DDA720F7CEFB53A38D8DEDC8D8E29737BA62A"
"2E4D04B7E64B2B23396497FBDE5FE803437199C1703C6DA3ED9867FCB358EFD5B98B8B"
"077E608F39DFBF574A89AA5521F78856E04D05E02B525928C437DF2E2AD5D45B0E6E3C"
"5D656CE2434D4D8BB4DCD11496C30615EB1970CA3DE40723518D79E8ED1A07BE59C486"
"134E5075367A74CF1F9DCBFB85BA36E643D4915C481B3129BD6988CB2E7BE441DA257C"
"924C34B431CE048F8F7BC21B601F51D1EA009C77D3E10F3A59196ED40EE2D80699970F"
"76EEC65142617CF427F1386566FDCE92FBA5FE734071B504EED601797589BF7C7F9EAD"
"508A7B5B4915DD477009E1",
};
static bool GetPara(const CMVP_DH_VECTOR *vector, CRYPT_EAL_PkeyPara *para)
{
para->id = CRYPT_PKEY_DH;
para->para.dhPara.p = CMVP_StringsToBins(vector->p, &(para->para.dhPara.pLen));
GOTO_ERR_IF_TRUE(para->para.dhPara.p == NULL, CRYPT_CMVP_COMMON_ERR);
para->para.dhPara.q = CMVP_StringsToBins(vector->q, &(para->para.dhPara.qLen));
GOTO_ERR_IF_TRUE(para->para.dhPara.q == NULL, CRYPT_CMVP_COMMON_ERR);
para->para.dhPara.g = CMVP_StringsToBins(vector->g, &(para->para.dhPara.gLen));
GOTO_ERR_IF_TRUE(para->para.dhPara.g == NULL, CRYPT_CMVP_COMMON_ERR);
return true;
ERR:
return false;
}
static bool GetKey(const CMVP_DH_VECTOR *vector, CRYPT_EAL_PkeyPrv *prv1, CRYPT_EAL_PkeyPub *pub1,
CRYPT_EAL_PkeyPrv *prv2, CRYPT_EAL_PkeyPub *pub2)
{
prv1->id = CRYPT_PKEY_DH;
prv1->key.dhPrv.data = CMVP_StringsToBins(vector->xa, &(prv1->key.dhPrv.len));
GOTO_ERR_IF_TRUE(prv1->key.dhPrv.data == NULL, CRYPT_CMVP_COMMON_ERR);
pub1->id = CRYPT_PKEY_DH;
pub1->key.dhPub.data = CMVP_StringsToBins(vector->ya, &(pub1->key.dhPub.len));
GOTO_ERR_IF_TRUE(pub1->key.dhPub.data == NULL, CRYPT_CMVP_COMMON_ERR);
prv2->id = CRYPT_PKEY_DH;
prv2->key.dhPrv.data = CMVP_StringsToBins(vector->xb, &(prv2->key.dhPrv.len));
GOTO_ERR_IF_TRUE(prv2->key.dhPrv.data == NULL, CRYPT_CMVP_COMMON_ERR);
pub2->id = CRYPT_PKEY_DH;
pub2->key.dhPub.data = CMVP_StringsToBins(vector->yb, &(pub2->key.dhPub.len));
GOTO_ERR_IF_TRUE(pub2->key.dhPub.data == NULL, CRYPT_CMVP_COMMON_ERR);
return true;
ERR:
return false;
}
static bool ComputeShareKey(const CMVP_DH_VECTOR *vector, CRYPT_EAL_PkeyCtx *prv, CRYPT_EAL_PkeyCtx *pub)
{
bool ret = false;
uint8_t *expShare = NULL;
uint8_t *share = NULL;
uint32_t expShareLen;
uint32_t shareLen;
expShare = CMVP_StringsToBins(vector->z, &expShareLen);
GOTO_ERR_IF_TRUE(expShare == NULL, CRYPT_CMVP_COMMON_ERR);
shareLen = expShareLen;
share = BSL_SAL_Malloc(shareLen);
GOTO_ERR_IF_TRUE(share == NULL, CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyComputeShareKey(prv, pub, share, &shareLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(shareLen != expShareLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(share, expShare, expShareLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(expShare);
BSL_SAL_Free(share);
return ret;
}
static void FreeData(CRYPT_EAL_PkeyPara para, CRYPT_EAL_PkeyPrv prv1, CRYPT_EAL_PkeyPub pub1, CRYPT_EAL_PkeyPrv prv2,
CRYPT_EAL_PkeyPub pub2)
{
BSL_SAL_Free(para.para.dhPara.p);
BSL_SAL_Free(para.para.dhPara.q);
BSL_SAL_Free(para.para.dhPara.g);
BSL_SAL_Free(prv1.key.dhPrv.data);
BSL_SAL_Free(pub1.key.dhPub.data);
BSL_SAL_Free(prv2.key.dhPrv.data);
BSL_SAL_Free(pub2.key.dhPub.data);
}
static bool CRYPT_CMVP_SelftestDhInternal(const CMVP_DH_VECTOR *vector, void *libCtx, const char *attrName)
{
bool ret = false;
CRYPT_EAL_PkeyPara para;
para.para.dhPara.p = NULL;
para.para.dhPara.q = NULL;
para.para.dhPara.g = NULL;
CRYPT_EAL_PkeyPrv prv1 = {0};
prv1.key.dhPrv.data = NULL;
CRYPT_EAL_PkeyPub pub1;
pub1.key.dhPub.data = NULL;
CRYPT_EAL_PkeyPrv prv2 = {0};
prv2.key.dhPrv.data = NULL;
CRYPT_EAL_PkeyPub pub2;
pub2.key.dhPub.data = NULL;
CRYPT_EAL_PkeyCtx *pkeyPrv = NULL;
CRYPT_EAL_PkeyCtx *pkeyPub = NULL;
if (vector->paraId == CRYPT_DH_RFC3526_2048) {
GOTO_ERR_IF_TRUE(GetPara(vector, ¶) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
GOTO_ERR_IF_TRUE(GetKey(vector, &prv1, &pub1, &prv2, &pub2) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
pkeyPrv = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_DH, 0, attrName);
pkeyPub = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_DH, 0, attrName);
GOTO_ERR_IF_TRUE(pkeyPrv == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(pkeyPub == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
if (vector->paraId == CRYPT_DH_RFC3526_2048) {
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPara(pkeyPrv, ¶) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
} else {
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetParaById(pkeyPrv, vector->paraId) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(pkeyPrv, &prv1) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(pkeyPub, &pub2) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(ComputeShareKey(vector, pkeyPrv, pkeyPub) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(pkeyPrv, &prv2) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(pkeyPub, &pub1) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(ComputeShareKey(vector, pkeyPrv, pkeyPub) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
FreeData(para, prv1, pub1, prv2, pub2);
CRYPT_EAL_PkeyFreeCtx(pkeyPrv);
CRYPT_EAL_PkeyFreeCtx(pkeyPub);
return ret;
}
bool CRYPT_CMVP_SelftestDh(void)
{
return CRYPT_CMVP_SelftestDhInternal(&DH_VECTOR_MODP2048, NULL, NULL) &&
CRYPT_CMVP_SelftestDhInternal(&DH_VECTOR_FFDHE2048, NULL, NULL);
}
bool CRYPT_CMVP_SelftestProviderDh(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestDhInternal(&DH_VECTOR_MODP2048, libCtx, attrName) &&
CRYPT_CMVP_SelftestDhInternal(&DH_VECTOR_FFDHE2048, libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_dh.c | C | unknown | 13,410 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_rand.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
#define DRBG_PARAM_COUNT 6
typedef enum {
CMVP_DRBG_INSTANTIATE,
CMVP_DRBG_SEED,
CMVP_DRBG_MAX,
} CMVP_DrbgState;
typedef struct {
uint32_t id;
const char *entropy; // EntropyInput
const char *nonce; // Nonce
const char *pers; // PersonalizationString
const char *entropySeed; // EntropyInputReseed
const char *adinSeed; // AdditionalInputReseed
const char *adin1; // AdditionalInput
const char *adin2; // AdditionalInput
const char *retBits; // ReturnedBits
} CMVP_DRBG_VECTOR;
typedef struct {
CMVP_DrbgState state;
CRYPT_RAND_AlgId id;
} CMVP_DRBG_SEEDCTX;
const CMVP_DRBG_VECTOR *g_currentTestVector = NULL;
/**
* Test Vector Execution Order:
* 1. Instantiate
* 2. Reseed
* 3. Generate Random Bits
* 4. Generate Random Bits
* 5. Uninstantiate
* Data Source:
* https://csrc.nist.gov/Projects/cryptographic-algorithm-validation-program/Random-Number-Generators
* NON PR
*/
static const CMVP_DRBG_VECTOR DRBG_VECTOR[] = {
// CRYPT_RAND_SHA1
{
.id = CRYPT_RAND_SHA1,
.entropy = "48a1a97ccc49d7ccf6e378a2f16b0fcd",
.nonce = "b091d2ec12a839fe",
.pers = "3dc16c1add9cac4ebbb0b889e43b9e12",
.entropySeed = "ba5da6791237243fea6050f5b99ecdf5",
.adinSeed = "d123e38e4c97e82994a9717ac6f17c08",
.adin1 = "800bed9729cfade6680dfe53ba0c1e28",
.adin2 = "251e66b9e385ac1c17fb771b5dc76cf2",
.retBits = "a1b2ee86a0f1dab79383133a62279908953a1c9a987760121119cc78b8512bd537a19db973ca397a"
"dd9233786d5d41fffae98059048521e25284bc6fdb97f34e6a127acd410f50682846be569e9a6bc8"
},
// CRYPT_RAND_SHA224
{
.id = CRYPT_RAND_SHA224,
.entropy = "184cbf7f1c462f27fc640ccf2aac1b26174ee41e42dcceaa",
.nonce = "09f9d8acd06aba74b9f849f7",
.pers = "5a5afe330e898ca94fad05b0e6b3f8146f46c90379a0b1eb",
.entropySeed = "b5eb44d3515c74d2cbd28c4ac5edb5fb95846e74e8398ce5",
.adinSeed = "a793fefe0f2ab3e9a0d1ddbc058d78369b03597f44099a81",
.adin1 = "930ef8531a344fef957660cbb401583afa0f016b7023a9db",
.adin2 = "2ee03b7314fb00e1e2616799c144cd58f051cde370588d70",
.retBits = "22b856603db40f1b6d439d5b88fbe4734f7fdee15f4df47dfd418b362f23e48fef0f48f03d1a7b7b"
"0de607c2a8288b1aaa01bc84646c322a88b2351855d7fa1b66b0b12baccbaa5ad6cc71833998f899"
"8712bddf54ab8af329c55791b7576cf36ade4b921009ffe32a8d22ecf4747571"
},
// CRYPT_RAND_SHA256
{
.id = CRYPT_RAND_SHA256,
.entropy = "6c623aea73bc8a59e28c6cd9c7c7ec8ca2e75190bd5dcae5978cf0c199c23f4f",
.nonce = "e55db067a0ed537e66886b7cda02f772",
.pers = "1e59d798810083d1ff848e90b25c9927e3dfb55a0888b0339566a9f9ca7542dc",
.entropySeed = "9ab40164744c7d00c78b4196f6f917ec33d70030a0812cd4606c5a25387568a9",
.adinSeed = "4e8bead7cbba7a7bc9ae1e1617222c4139661347599950e7225d1e2faa5d57f5",
.adin1 = "dcb22a5d9f149858636f3ede2253e419816fb7b1103194451ed6a573a8fe6271",
.adin2 = "8f9d5c78cdabc32e71ac3b3c49239caddf96053250f4fd92056efbd0be487d36",
.retBits = "6e98a3b1f686f6ffa79355c9d8a5ab7f93312159d52659a2298315f10007c71adabc0b5ccb4164c0"
"949fbdb221b43acdb62bed3099596f2d7bd5d0048173dd2360a543b234ab61a441ddb9299af84ca4"
"5c6e618fd521366dbf509d4ec06174da924361d642b107e5564ac1b32340dd2f3158bf4c00bcb4dc"
"f12c6d67af4b74ee"
},
// CRYPT_RAND_SHA384
{
.id = CRYPT_RAND_SHA384,
.entropy = "f411e1feeccf01c0d4bde61ca2384a2640b41e383a055b374e0acfa8170c2f28",
.nonce = "7cf75b960dcd0a0a9d2a4e7e8d5e47d3",
.pers = "25d6dfee3e74d3b6a9f459094203fc76e0e589fa879cc445008c80e3736fc0a9",
.entropySeed = "d222df563773906b875d55dc1aef90337ff59fc3ca5ed0af5e46d306d630c7e3",
.adinSeed = "07a576624662253737789e543734d7c35ded8d74a3b53919b1c28c21a2b5ebc5",
.adin1 = "2561c8591281f0682d3811387d0cdc16c137edfcc9527134212701f73550c572",
.adin2 = "870441d9435f2cbf16f1168f50e32d9b8811be7adc10a5070c5eb993372c5732",
.retBits = "9107af002a8bc3e0f0394eb0db3a801ca73844db0600873d1d576ccfbdd88dfc3eaa101e52e4c4ad"
"9958d9d0e5f1eb555cd0d93ad2745a1302dfead60c42ef28e7211740b1dc694fdf72dd066d1d66a5"
"8aceeb9a8c6a9c67a75326f97b742b85e7abdc853b01bd799bb9f3e8e6b5f2a41919543b17c0da4e"
"4e25f04e1c2859a56466689ab85c46cb9f593abff0f058f7d26f2c09e379e5e0b6e123f24fb9bcfb"
"a9a468dcb38a9577d63251d20f09b8d2b4dad74fb52e1e8dbdde6e0436563d66"
},
// CRYPT_RAND_SHA512
{
.id = CRYPT_RAND_SHA512,
.entropy = "4b23595b0a3640cfabb0ec34df6a613308b0448488a5d9ff99da4278e072eb34",
.nonce = "8e696bffd9ca3a71d2e2f05e600c8364",
.pers = "010ba93ea68a3d4a200e5145859e299c5b5349b7645fb5bbcad687aba7d67313",
.entropySeed = "04de4babdbe143bde99aa4452f9aa43b0a164eb927555c0496aa0fc9328a521c",
.adinSeed = "2b0c7c3efb36b71b917a44086d168313675b426b17c5ab3d0eb6af753f6040e0",
.adin1 = "d0b7d1d12ab15d3bba8f4eba07fee0974838962b247be480683b8e3d4a91033a",
.adin2 = "66c78ca12e45bdca003b49cb6440b977dd85b167e7c803890ed1a73666eaa869",
.retBits = "4008cbd8281dc82fd6c368f650ef2609bb771e80c63d478a77fa938248dcbb8b79e54ead0265f6ff"
"1ebfafe4e387c6e27df9f03e4a5225e86a4436e56ebf03b3be2cfbcb49c89c92ec1dfa5ee445dd4f"
"6f64e02a2423a0b18ebd02eec52f5cc21bc3565e796b3ded6552f1b5a574a201c3b11018222806f9"
"618d23d77fd02db879cf87fe24ed7ba11b3b108b559633db1f95c5121b28011aa4dd20399bd4978e"
"1f8b8880c333a47ff1750679bf28d329347b26d347aae90ee562ae8029579cbe0336e066d6b8ba5e"
"0169fec804c30189a4434c1bf8a5b0a249951d3d89554da38ff0751b8b1fef9ae18a0aa2bc477736"
"d199a06f61d400039a4cc03869bb10ca"
},
// CRYPT_RAND_SM3
{
.id = CRYPT_RAND_SM3,
.entropy = "8c6368232f5cc9da92e5877fd368c5769ecf1f4eaf011a89e11686af8e379895",
.nonce = "8dd1cfbcbd615a47e1298a94ca12f248",
.pers = "c325c1db2ddaa54616b2b804cca6f1a8",
.entropySeed = "5c638a5bc1ffd99fa58b0e2482347f9d5c638a5bc1ffd99fa58b0e2482347f9d",
.adinSeed = "b05a4b1751cd5fb3e583966cf888d44d",
.adin1 = "81b5bbc2ec9e7ae9c2f999ff58d28f2b",
.adin2 = "7af5ca6867e0211baad5b24c6229d6a5",
.retBits = "05a2637f235e86be101ec21b1e75ae26"
},
// CRYPT_RAND_HMAC_SHA1
{
.id = CRYPT_RAND_HMAC_SHA1,
.entropy = "03e7b41c95818eb0b667bfa8a175a824",
.nonce = "66a1e417a9b6b92f",
.pers = "126dded5eb0bc81be37c10bcd9d5f793",
.entropySeed = "d17e98c2e50ee0db00d25c3364451e95",
.adinSeed = "dc596d188e2343802240bc7f5cc60516",
.adin1 = "14c8ec10f5bdde6b9e75898d7f9f03d0",
.adin2 = "31aa842afcc1daa94098241a87d6ddfc",
.retBits = "4739b1bcf87404a2290829bd7a61f0b391a794c71c055c7cc513b28dcb5fdc88645bc9cb490f41fa"
"b134c6b33ce9336571762754343961de671b02a47960b4b4e23c5bfb87dcc19b260b3bcb921ae325"
},
// CRYPT_RAND_HMAC_SHA224
{
.id = CRYPT_RAND_HMAC_SHA224,
.entropy = "96ae702af50c50c7c38818a5133938bd7ce51197fc78e218",
.nonce = "15b6c5a7ff9c0395d764159f",
.pers = "e96554644097e9932585b7f4bb14d101f24c8b0376f38c05",
.entropySeed = "707d5813e5bf47c1b8232b44a007bf7decfef499d758ed53",
.adinSeed = "3f698a5f6f4fe67ef2ddf23bd5a67c1a2df4f3b19425fb85",
.adin1 = "fe1f6a90fc0ed396bca21c0d40a1bb583eb63df78c98adac",
.adin2 = "5942b56148f27dd5388f00caa47ffd4925e854237fe14454",
.retBits = "150b9260ce9aa419fe1860332ae7c9f42d9ada1649679b53f46bc9d20de3431186a54afb5df7b626"
"9cdc05540a93fdd50a2cd3a862372d862841768df02846b057993dd6aa32f874b7220a5a1fd9cb57"
"3d720a54af5715cedfc16f0d9a467735e253b2b1a6e97421fcee1f2d670dec1a"
},
// CRYPT_RAND_HMAC_SHA256
{
.id = CRYPT_RAND_HMAC_SHA256,
.entropy = "cdb0d9117cc6dbc9ef9dcb06a97579841d72dc18b2d46a1cb61e314012bdf416",
.nonce = "d0c0d01d156016d0eb6b7e9c7c3c8da8",
.pers = "6f0fb9eab3f9ea7ab0a719bfa879bf0aaed683307fda0c6d73ce018b6e34faaa",
.entropySeed = "8ec6f7d5a8e2e88f43986f70b86e050d07c84b931bcf18e601c5a3eee3064c82",
.adinSeed = "1ab4ca9014fa98a55938316de8ba5a68c629b0741bdd058c4d70c91cda5099b3",
.adin1 = "16e2d0721b58d839a122852abd3bf2c942a31c84d82fca74211871880d7162ff",
.adin2 = "53686f042a7b087d5d2eca0d2a96de131f275ed7151189f7ca52deaa78b79fb2",
.retBits = "dda04a2ca7b8147af1548f5d086591ca4fd951a345ce52b3cd49d47e84aa31a183e31fbc42a1ff1d"
"95afec7143c8008c97bc2a9c091df0a763848391f68cb4a366ad89857ac725a53b303ddea767be8d"
"c5f605b1b95f6d24c9f06be65a973a089320b3cc42569dcfd4b92b62a993785b0301b3fc45244565"
"6fce22664827b88f"
},
// CRYPT_RAND_HMAC_SHA384
{
.id = CRYPT_RAND_HMAC_SHA384,
.entropy = "c4868db5c46fde0a10008838b5be62c349209fded42fab461b01e11723c8242a",
.nonce = "618faba54acba1e0afd4b27cbd731ed9",
.pers = "135132cf2b8a57554bdc13c68e90dc434353e4f65a4d5ca07c3e0a13c62e7265",
.entropySeed = "d30016b5827dc2bfe4034c6654d69775fe98432b19e3da373213d939d391f54a",
.adinSeed = "a0bbd02f6aa71a06d1642ca2cc7cdc5e8857e431b176bcf1ecd20f041467bd2d",
.adin1 = "93ee30a9e7a0e244aa91da62f2215c7233bdfc415740d2770780cbbad61b9ba2",
.adin2 = "36d922cacca00ae89db8f0c1cae5a47d2de8e61ae09357ca431c28a07907fce1",
.retBits = "2aac4cebed080c68ef0dcff348506eca568180f7370c020deda1a4c9050ce94d4db90fd827165846"
"d6dd6cb2031eec1634b0e7f3e0e89504e34d248e23a8fb31cd32ff39a486946b2940f54c968f96cf"
"c508cd871c84e68458ca7dccabc6dcfb1e9fbef9a47caae14c5239c28686e0fc0942b0c847c9d8d9"
"87970c1c5f5f06eaa8385575dacb1e925c0ed85e13edbb9922083f9bbbb79405411ff5dfe7061568"
"5df1f1e49867d0b6ed69afe8ac5e76ffab6ff3d71b4dae998faf8c7d5bc6ae4d"
},
// CRYPT_RAND_HMAC_SHA512
{
.id = CRYPT_RAND_HMAC_SHA512,
.entropy = "da740cbc36057a8e282ae717fe7dfbb245e9e5d49908a0119c5dbcf0a1f2d5ab",
.nonce = "46561ff612217ba3ff91baa06d4b5440",
.pers = "fc227293523ecb5b1e28c87863626627d958acc558a672b148ce19e2abd2dde4",
.entropySeed = "1d61d4d8a41c3254b92104fd555adae0569d1835bb52657ec7fbba0fe03579c5",
.adinSeed = "b9ed8e35ad018a375b61189c8d365b00507cb1b4510d21cac212356b5bbaa8b2",
.adin1 = "b7998998eaf9e5d34e64ff7f03de765b31f407899d20535573e670c1b402c26a",
.adin2 = "2089d49d63e0c4df58879d0cb1ba998e5b3d1a7786b785e7cf13ca5ea5e33cfd",
.retBits = "5b70f3e4da95264233efbab155b828d4e231b67cc92757feca407cc9615a660871cb07ad1a2e9a99"
"412feda8ee34dc9c57fa08d3f8225b30d29887d20907d12330fffd14d1697ba0756d37491b0a8814"
"106e46c8677d49d9157109c402ad0c247a2f50cd5d99e538c850b906937a05dbb8888d984bc77f6c"
"a00b0e3bc97b16d6d25814a54aa12143afddd8b2263690565d545f4137e593bb3ca88a37b0aadf79"
"726b95c61906257e6dc47acd5b6b7e4b534243b13c16ad5a0a1163c0099fce43f428cd27c3e6463c"
"f5e9a9621f4b3d0b3d4654316f4707675df39278d5783823049477dcce8c57fdbd576711c91301e9"
"bd6bb0d3e72dc46d480ed8f61fd63811"
},
// CRYPT_RAND_AES128_CTR
{
.id = CRYPT_RAND_AES128_CTR,
.entropy = "289e5c8283cbd7dbe707255cb3cf2907d8a5ce5b347314966f9b2bebb1a1e200",
.nonce = NULL,
.pers = "7f7b59f23510b976fe155d047525c94e2dacb30d77ac8b09281544dd815d5293",
.entropySeed = "98c522028f36fc6b85a8f3c003efd4b130dd90180ec81cf7c67d4c53d10f0022",
.adinSeed = "f7a0378328d939f0f8521e39409d7175d87319c7597a9050414f7adc392a328d",
.adin1 = "19c286f5b36194d1cc62c0188140bc9d61d2a9c5d88bb5aebc224bfb04dfca83",
.adin2 = "820650c3201d347f5b20d3d25d1c8c7bef4d9f66a5a04c7dd9d669e95182a0c4",
.retBits = "79a79d44edada58e3fc12a4e36ae900eeace290265f01262f40f2958a70dcbd4d4185f708c088ede"
"7ff8c8375f44f4012f2512d38328a5df171a17029d90f185"
},
// CRYPT_RAND_AES192_CTR
{
.id = CRYPT_RAND_AES192_CTR,
.entropy = "4b58271b116237eedd4e9ff9360382a59f3e2a173d860f2bbd8b2bace142b2395c67cf5a513f06f3",
.nonce = NULL,
.pers = "cf76c16cd5d270707ea9acc39744db69bfac63e566256fd6917bf9819679840f3fea2aa535d8df01",
.entropySeed = "1867f371a345eef98b2d70fc1960397892645b7b29a4ead252e8835e0b600618a9bd6ff99785d890",
.adinSeed = "6d44839aff8b7165deebd489ad088ecb7dcec11c32b1e747dba8f0e8a0b89f74a84ea8a05586fe9e",
.adin1 = "42248fce0994e0e63504209d629a6943eb3e2ad512f03f79cbd5102928392bce1cacbba056ac6ca9",
.adin2 = "bd529b600273329423a58d6f8a12be0f17989a02e73e347bc7d49d9169337a6cff7c07e8a807a80a",
.retBits = "02486d32cd55954f406ba55705f1460d384439592dede81a84fda221fd45c0d651d67ec4a81a8b40"
"4151a643f331ad051cb004352289de37bca71e8cc0a6aeab"
},
// CRYPT_RAND_AES256_CTR
{
.id = CRYPT_RAND_AES256_CTR,
.entropy = "ae7ebe062971f5eb32e5b21444750785de816595ad2cbe80a209c8f8ab04b5468166de8c6ae522d8"
"f10b56386a3b424f",
.nonce = NULL,
.pers = "55860dae57fcac297087c137efb796878a75868f6e7681114e9b73ed0c67e3c62bfc9f5d77e8caa5"
"9bcdb223f4ffd247",
.entropySeed = "a42407931bfeca70e6ee5dd197021a129525051c07468e8b25587c5ad50abe9204e882fe847b8fd4"
"7cf7b4360e5aa034",
.adinSeed = "ee4c88d1eb05f4853663eada501d2fc4b4984b283a88db579af2113031e03d9bc570de943dd16891"
"8f3ba8065581fea7",
.adin1 = "4b4b03ef19b0f259dca2b3ee3ae4cd86c3895a784b3d8eee043a2003c08289f8fffdad141e6b1ab2"
"174d8d5d79c1e581",
.adin2 = "3062b33f116b46e20fe3c354726ae9b2a3a4c51922c8107863cb86f1f0bdad7554075659d91c371e"
"2b11b1e8106a1ed5",
.retBits = "0d270518baeafac160ff1cb28c11ef68712c764c0c01674e6c9ca2cc9c7e0e8accfd3c753635ee07"
"0081eee7628af6187fbc2854b3c204461a796cf3f3fcb092"
},
// CRYPT_RAND_AES128_CTR_DF
{
.id = CRYPT_RAND_AES128_CTR_DF,
.entropy = "e14ed7064a97814dd326b9a05bc44543",
.nonce = "876240c1f7de3dba",
.pers = "26ccf56848a048721d0aad87d6fc65f0",
.entropySeed = "7ec4ac660fa0bbfa66ac3802e511901f",
.adinSeed = "8835d28e7f85a4e95087bdd1bb7ad57e",
.adin1 = "2a9bd50bbb20fefe24649f5f80eede66",
.adin2 = "f7ce3d5c6c381e56b25410c6909c1074",
.retBits = "d2f3130d309bed1da65545b9d793e035fd2564303d1fdcfb6c7fee019500d9f5d434fab2d3c8d15e"
"39a25f965aaa804c7141407e90c4a86a6c8d303ce83bfb34"
},
// CRYPT_RAND_AES192_CTR_DF
{
.id = CRYPT_RAND_AES192_CTR_DF,
.entropy = "c4b1e6a99587eacd7ec8517f40f9433ca432cea8686433f0",
.nonce = "d03a29e548e58ca7cbf0ac707b1464e3",
.pers = "0daaead21779b2a428d2b7fb12d9ab8316899edbe26b5460de1549c99e4781c9",
.entropySeed = "2229144c1b4efb79ab5fe079cda26bc33acbb2a0a87f642c",
.adinSeed = "f116a683ca485fda846a598b8d9b079e78c2828286ad530bf01f693cc8af9f84",
.adin1 = "7c89de353298935bd26aa18517355313df0630da5f45ea0240e809179363080b",
.adin2 = "e978b8fe56afc908bed129a46d57a8698d66034d4dbcc7aba3a33d5796fb7559",
.retBits = "8ce7e9589c2975fd6989a450aa65da9114e515777c97351da037ccb72d4987eb69c680411724ed60"
"2e6ac76cd2d085725616c92777a4664d43a59c3ae9946134"
},
// CRYPT_RAND_AES256_CTR_DF
{
.id = CRYPT_RAND_AES256_CTR_DF,
.entropy = "174b46250051a9e3d80c56ae7163dafe7e54481a56cafd3b8625f99bbb29c442",
.nonce = "98ffd99c466e0e94a45da7e0e82dbc6b",
.pers = "7095268e99938b3e042734b9176c9aa051f00a5f8d2a89ada214b89beef18ebf",
.entropySeed = "e88be1967c5503f65d23867bbc891bd679db03b4878663f6c877592df25f0d9a",
.adinSeed = "cdf6ad549e45b6aa5cd67d024931c33cd133d52d5ae500c3015020beb30da063",
.adin1 = "c7228e90c62f896a09e11684530102f926ec90a3255f6c21b857883c75800143",
.adin2 = "76a94f224178fe4cbf9e2b8acc53c9dc3e50bb613aac8936601453cda3293b17",
.retBits = "1a6d8dbd642076d13916e5e23038b60b26061f13dd4e006277e0268698ffb2c87e453bae1251631a"
"c90c701a9849d933995e8b0221fe9aca1985c546c2079027"
},
// CRYPT_RAND_SM4_CTR_DF
{
.id = CRYPT_RAND_SM4_CTR_DF,
.entropy = "8c6368232f5cc9da92e5877fd368c5769ecf1f4eaf011a89e11686af8e379895",
.nonce = "8dd1cfbcbd615a47e1298a94ca12f248",
.pers = "c325c1db2ddaa54616b2b804cca6f1a8",
.entropySeed = "5c638a5bc1ffd99fa58b0e2482347f9d5c638a5bc1ffd99fa58b0e2482347f9d",
.adinSeed = "b05a4b1751cd5fb3e583966cf888d44d",
.adin1 = "81b5bbc2ec9e7ae9c2f999ff58d28f2b",
.adin2 = "7af5ca6867e0211baad5b24c6229d6a5",
.retBits = "5e9a44ce51ee802f2fc49335d8b4588b"
},
};
static int32_t CMVP_DrbgGetEntropy(void *ctx, CRYPT_Data *entropy, uint32_t strength, CRYPT_Range *lenRange)
{
CMVP_DRBG_SEEDCTX *seedCtx = (CMVP_DRBG_SEEDCTX *)ctx;
const CMVP_DRBG_VECTOR *vector = g_currentTestVector;
GOTO_ERR_IF_TRUE(vector == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(vector->entropy == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
if (seedCtx->state == CMVP_DRBG_INSTANTIATE) {
entropy->data = CMVP_StringsToBins(vector->entropy, &(entropy->len));
GOTO_ERR_IF_TRUE(entropy->data == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
seedCtx->state = CMVP_DRBG_SEED;
} else if (seedCtx->state == CMVP_DRBG_SEED) {
entropy->data = CMVP_StringsToBins(vector->entropySeed, &(entropy->len));
GOTO_ERR_IF_TRUE(entropy->data == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
seedCtx->state = CMVP_DRBG_MAX;
}
(void)strength;
(void)lenRange;
return CRYPT_SUCCESS;
ERR:
return CRYPT_CMVP_ERR_ALGO_SELFTEST;
}
static void CMVP_DrbgCleanData(void *ctx, CRYPT_Data *data)
{
BSL_SAL_Free(data->data);
data->data = NULL;
data->len = 0;
(void)ctx;
}
static int32_t CMVP_DrbgGetNonce(void *ctx, CRYPT_Data *nonce, uint32_t strength, CRYPT_Range *lenRange)
{
(void)ctx;
uint8_t *data = NULL;
uint32_t dataLen;
const CMVP_DRBG_VECTOR *vector = g_currentTestVector;
GOTO_ERR_IF_TRUE(vector == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(vector->nonce == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
data = CMVP_StringsToBins(vector->nonce, &dataLen);
GOTO_ERR_IF_TRUE(data == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
nonce->data = data;
nonce->len = dataLen;
(void)strength;
(void)lenRange;
return CRYPT_SUCCESS;
ERR:
BSL_SAL_Free(data);
return CRYPT_CMVP_ERR_ALGO_SELFTEST;
}
static CRYPT_EAL_RndCtx *CMVP_DrbgInit(void *libCtx, const char *attrName, const CMVP_DRBG_VECTOR *drbgVec,
CMVP_DRBG_SEEDCTX *seedCtx)
{
CRYPT_EAL_RndCtx *ctx = NULL;
uint8_t *pers = NULL;
uint32_t persLen;
CRYPT_RandSeedMethod method;
const CMVP_DRBG_VECTOR *vector = drbgVec;
GOTO_ERR_IF_TRUE(vector->pers == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
pers = CMVP_StringsToBins(vector->pers, &persLen);
GOTO_ERR_IF_TRUE(pers == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
method.getEntropy = CMVP_DrbgGetEntropy;
method.cleanEntropy = CMVP_DrbgCleanData;
method.getNonce = CMVP_DrbgGetNonce;
method.cleanNonce = CMVP_DrbgCleanData;
int32_t index = 0;
BSL_Param param[DRBG_PARAM_COUNT] = {0};
(void)BSL_PARAM_InitValue(¶m[index++], CRYPT_PARAM_RAND_SEEDCTX, BSL_PARAM_TYPE_CTX_PTR,
seedCtx, 0);
(void)BSL_PARAM_InitValue(¶m[index++], CRYPT_PARAM_RAND_SEED_GETENTROPY, BSL_PARAM_TYPE_FUNC_PTR,
method.getEntropy, 0);
(void)BSL_PARAM_InitValue(¶m[index++], CRYPT_PARAM_RAND_SEED_CLEANENTROPY, BSL_PARAM_TYPE_FUNC_PTR,
method.cleanEntropy, 0);
(void)BSL_PARAM_InitValue(¶m[index++], CRYPT_PARAM_RAND_SEED_GETNONCE, BSL_PARAM_TYPE_FUNC_PTR,
method.getNonce, 0);
(void)BSL_PARAM_InitValue(¶m[index++], CRYPT_PARAM_RAND_SEED_CLEANNONCE, BSL_PARAM_TYPE_FUNC_PTR,
method.cleanNonce, 0);
ctx = CRYPT_EAL_ProviderDrbgNewCtx(libCtx, drbgVec->id, attrName, param);
GOTO_ERR_IF_TRUE(ctx == NULL,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_DrbgInstantiate(ctx, pers, persLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
BSL_SAL_Free(pers);
return ctx;
ERR:
CRYPT_EAL_DrbgDeinit(ctx);
BSL_SAL_Free(pers);
return NULL;
}
static void FreeData(uint8_t *rand, uint8_t *expectRand, uint8_t *adinSeed, uint8_t *adin1, uint8_t *adin2)
{
BSL_SAL_Free(rand);
BSL_SAL_Free(expectRand);
BSL_SAL_Free(adinSeed);
BSL_SAL_Free(adin1);
BSL_SAL_Free(adin2);
}
static uint8_t *ExecDrbg(CRYPT_EAL_RndCtx *ctx, uint32_t randLen, uint8_t *adin1, uint32_t adin1Len,
uint8_t *adin2, uint32_t adin2Len)
{
uint8_t *rand = NULL;
rand = BSL_SAL_Malloc(randLen);
GOTO_ERR_IF_TRUE(rand == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_DrbgbytesWithAdin(ctx, rand, randLen, adin1, adin1Len) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_DrbgbytesWithAdin(ctx, rand, randLen, adin2, adin2Len) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
return rand;
ERR:
BSL_SAL_Free(rand);
return NULL;
}
static bool GetData(const CMVP_DRBG_VECTOR *drbgVec, CRYPT_Data *expectRand, CRYPT_Data *adinSeed, CRYPT_Data *adin1,
CRYPT_Data *adin2)
{
expectRand->data = CMVP_StringsToBins(drbgVec->retBits, &(expectRand->len));
GOTO_ERR_IF_TRUE(expectRand->data == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
adin1->data = CMVP_StringsToBins(drbgVec->adin1, &(adin1->len));
GOTO_ERR_IF_TRUE(adin1->data == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
adin2->data = CMVP_StringsToBins(drbgVec->adin2, &(adin2->len));
GOTO_ERR_IF_TRUE(adin2->data == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
adinSeed->data = CMVP_StringsToBins(drbgVec->adinSeed, &(adinSeed->len));
GOTO_ERR_IF_TRUE(adinSeed->data == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
return true;
ERR:
return false;
}
const CMVP_DRBG_VECTOR *FindDrbgVectorById(CRYPT_RAND_AlgId id)
{
uint32_t num = sizeof(DRBG_VECTOR) / sizeof(DRBG_VECTOR[0]);
const CMVP_DRBG_VECTOR *drbgVec = NULL;
for (uint32_t i = 0; i < num; i++) {
if (DRBG_VECTOR[i].id == id) {
drbgVec = &DRBG_VECTOR[i];
return drbgVec;
}
}
return NULL;
}
static bool CRYPT_CMVP_SelftestDrbgInternal(void *libCtx, const char *attrName, CRYPT_RAND_AlgId id)
{
bool ret = false;
CRYPT_EAL_RndCtx *ctx = NULL;
uint8_t *rand = NULL;
CRYPT_Data expectRand = { NULL, 0 };
CRYPT_Data adinSeed = { NULL, 0 };
CRYPT_Data adin1 = { NULL, 0 };
CRYPT_Data adin2 = { NULL, 0 };
CMVP_DRBG_SEEDCTX seedCtx = { CMVP_DRBG_INSTANTIATE, id };
const CMVP_DRBG_VECTOR *drbgVec = FindDrbgVectorById(id);
if (drbgVec == NULL || drbgVec->entropy == NULL) {
return false;
}
g_currentTestVector = drbgVec;
GOTO_ERR_IF_TRUE(!GetData(drbgVec, &expectRand, &adinSeed, &adin1, &adin2), CRYPT_CMVP_ERR_ALGO_SELFTEST);
ctx = CMVP_DrbgInit(libCtx, attrName, drbgVec, &seedCtx);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_DrbgSeedWithAdin(ctx, adinSeed.data, adinSeed.len) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
// 2: One byte and two characters
rand = ExecDrbg(ctx, (uint32_t)strlen(drbgVec->retBits) / 2, adin1.data, adin1.len, adin2.data, adin2.len);
GOTO_ERR_IF_TRUE(rand == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(rand, expectRand.data, expectRand.len) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
CRYPT_EAL_DrbgDeinit(ctx);
FreeData(rand, expectRand.data, adinSeed.data, adin1.data, adin2.data);
return ret;
}
bool CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_AlgId id)
{
return CRYPT_CMVP_SelftestDrbgInternal(NULL, NULL, id);
}
bool CRYPT_CMVP_SelftestProviderDrbg(void *libCtx, const char *attrName, CRYPT_RAND_AlgId id)
{
return CRYPT_CMVP_SelftestDrbgInternal(libCtx, attrName, id);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_drbg.c | C | unknown | 25,307 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_bn.h"
#include "crypt_encode_internal.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_rand.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_util_rand.h"
#include "bsl_sal.h"
#define BITS_OF_BYTE 8
typedef struct {
const char *p;
const char *q;
const char *g;
const char *msg;
const char *x; // The private key.
const char *y;
const char *k;
const char *r;
const char *s;
CRYPT_MD_AlgId mdId;
} CMVP_DSA_VECTOR;
// https://www.rfc-editor.org/rfc/rfc6979#page-27
static const CMVP_DSA_VECTOR DSA_VECTOR = {
.p = "a8adb6c0b4cf9588012e5deff1a871d383e0e2a85b5e8e03d814fe13a059705e"
"663230a377bf7323a8fa117100200bfd5adf857393b0bbd67906c081e585410e"
"38480ead51684dac3a38f7b64c9eb109f19739a4517cd7d5d6291e8af20a3fbf"
"17336c7bf80ee718ee087e322ee41047dabefbcc34d10b66b644ddb3160a28c0"
"639563d71993a26543eadb7718f317bf5d9577a6156561b082a10029cd44012b"
"18de6844509fe058ba87980792285f2750969fe89c2cd6498db3545638d5379d"
"125dccf64e06c1af33a6190841d223da1513333a7c9d78462abaab31b9f96d5f"
"34445ceb6309f2f6d2c8dde06441e87980d303ef9a1ff007e8be2f0be06cc15f",
.q = "e71f8567447f42e75f5ef85ca20fe557ab0343d37ed09edc3f6e68604d6b9dfb",
.g = "5ba24de9607b8998e66ce6c4f812a314c6935842f7ab54cd82b19fa104abfb5d"
"84579a623b2574b37d22ccae9b3e415e48f5c0f9bcbdff8071d63b9bb956e547"
"af3a8df99e5d3061979652ff96b765cb3ee493643544c75dbe5bb39834531952"
"a0fb4b0378b3fcbb4c8b5800a5330392a2a04e700bb6ed7e0b85795ea38b1b96"
"2741b3f33b9dde2f4ec1354f09e2eb78e95f037a5804b6171659f88715ce1a9b"
"0cc90c27f35ef2f10ff0c7c7a2bb0154d9b8ebe76a3d764aa879af372f4240de"
"8347937e5a90cec9f41ff2f26b8da9a94a225d1a913717d73f10397d2183f1ba"
"3b7b45a68f1ff1893caf69a827802f7b6a48d51da6fbefb64fd9a6c5b75c4561",
.msg = "4e3a28bcf90d1d2e75f075d9fbe55b36c5529b17bc3a9ccaba6935c9e2054825"
"5b3dfae0f91db030c12f2c344b3a29c4151c5b209f5e319fdf1c23b190f64f1f"
"e5b330cb7c8fa952f9d90f13aff1cb11d63181da9efc6f7e15bfed4862d1a62c"
"7dcf3ba8bf1ff304b102b1ec3f1497dddf09712cf323f5610a9d10c3d9132659",
.x = "446969025446247f84fdea74d02d7dd13672b2deb7c085be11111441955a377b",
.y = "5a55dceddd1134ee5f11ed85deb4d634a3643f5f36dc3a70689256469a0b651a"
"d22880f14ab85719434f9c0e407e60ea420e2a0cd29422c4899c416359dbb1e5"
"92456f2b3cce233259c117542fd05f31ea25b015d9121c890b90e0bad033be13"
"68d229985aac7226d1c8c2eab325ef3b2cd59d3b9f7de7dbc94af1a9339eb430"
"ca36c26c46ecfa6c5481711496f624e188ad7540ef5df26f8efacb820bd17a1f"
"618acb50c9bc197d4cb7ccac45d824a3bf795c234b556b06aeb9291734532520"
"84003f69fe98045fe74002ba658f93475622f76791d9b2623d1b5fff2cc16844"
"746efd2d30a6a8134bfc4c8cc80a46107901fb973c28fc553130f3286c1489da",
.k = "117a529e3fdfc79843a5a4c07539036b865214e014b4928c2a31f47bf62a4fdb",
.r = "633055e055f237c38999d81c397848c38cce80a55b649d9e7905c298e2a51447",
.s = "2bbf68317660ec1e4b154915027b0bc00ee19cfc0bf75d01930504f2ce10a8b0",
.mdId = CRYPT_MD_SHA256
};
static bool GetPkey(void *libCtx, const char *attrName, CRYPT_EAL_PkeyCtx **pkeyPrv, CRYPT_EAL_PkeyCtx **pkeyPub,
CRYPT_EAL_PkeyPara *para, CRYPT_EAL_PkeyPub *pub, CRYPT_EAL_PkeyPrv *prv)
{
*pkeyPrv = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_DSA, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPrv == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
*pkeyPub = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_DSA, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPub == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
para->para.dsaPara.p = CMVP_StringsToBins(DSA_VECTOR.p, &(para->para.dsaPara.pLen));
GOTO_ERR_IF_TRUE(para->para.dsaPara.p == NULL, CRYPT_CMVP_COMMON_ERR);
para->para.dsaPara.q = CMVP_StringsToBins(DSA_VECTOR.q, &(para->para.dsaPara.qLen));
GOTO_ERR_IF_TRUE(para->para.dsaPara.q == NULL, CRYPT_CMVP_COMMON_ERR);
para->para.dsaPara.g = CMVP_StringsToBins(DSA_VECTOR.g, &(para->para.dsaPara.gLen));
GOTO_ERR_IF_TRUE(para->para.dsaPara.g == NULL, CRYPT_CMVP_COMMON_ERR);
prv->key.dsaPrv.data = CMVP_StringsToBins(DSA_VECTOR.x, &(prv->key.dsaPrv.len));
GOTO_ERR_IF_TRUE(prv->key.dsaPrv.data == NULL, CRYPT_CMVP_COMMON_ERR);
pub->key.dsaPub.data = CMVP_StringsToBins(DSA_VECTOR.y, &(pub->key.dsaPub.len));
GOTO_ERR_IF_TRUE(pub->key.dsaPub.data == NULL, CRYPT_CMVP_COMMON_ERR);
para->id = CRYPT_PKEY_DSA;
pub->id = CRYPT_PKEY_DSA;
prv->id = CRYPT_PKEY_DSA;
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPara(*pkeyPrv, para) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPara(*pkeyPub, para) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(*pkeyPrv, prv) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(*pkeyPub, pub) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
return true;
ERR:
return false;
}
static int32_t TestVectorRandom(uint8_t *r, uint32_t rLen)
{
uint8_t *rand = NULL;
uint32_t randLen;
rand = CMVP_StringsToBins(DSA_VECTOR.k, &randLen);
if (rand == NULL) {
return CRYPT_MEM_ALLOC_FAIL;
}
if (randLen < rLen) {
BSL_SAL_Free(rand);
return CRYPT_CMVP_ERR_ALGO_SELFTEST;
}
for (uint32_t i = 0; i < randLen; i++) {
r[i] = rand[i];
}
BSL_SAL_Free(rand);
return 0;
}
static int32_t SignEncode(const char *signR, const char *signS, uint8_t *vectorSign, uint32_t *vectorSignLen)
{
int ret = CRYPT_CMVP_ERR_ALGO_SELFTEST;
BN_BigNum *bnR = NULL;
BN_BigNum *bnS = NULL;
uint8_t *r = NULL;
uint8_t *s = NULL;
uint32_t rLen, sLen;
r = CMVP_StringsToBins(signR, &rLen);
GOTO_ERR_IF_TRUE(r == NULL, CRYPT_CMVP_COMMON_ERR);
s = CMVP_StringsToBins(signS, &sLen);
GOTO_ERR_IF_TRUE(s == NULL, CRYPT_CMVP_COMMON_ERR);
bnR = BN_Create(rLen * BITS_OF_BYTE);
bnS = BN_Create(sLen * BITS_OF_BYTE);
GOTO_ERR_IF_TRUE(BN_Bin2Bn(bnR, r, rLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(BN_Bin2Bn(bnS, s, sLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = CRYPT_EAL_EncodeSign(bnR, bnS, vectorSign, vectorSignLen);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = CRYPT_SUCCESS;
ERR:
BSL_SAL_Free(r);
BSL_SAL_Free(s);
BN_Destroy(bnR);
BN_Destroy(bnS);
return ret;
}
static void FreeData(CRYPT_EAL_PkeyPara para, CRYPT_EAL_PkeyPub pub, CRYPT_EAL_PkeyPrv prv, uint8_t *msg, uint8_t *sign)
{
BSL_SAL_Free(para.para.dsaPara.p);
BSL_SAL_Free(para.para.dsaPara.q);
BSL_SAL_Free(para.para.dsaPara.g);
BSL_SAL_Free(msg);
BSL_SAL_Free(pub.key.dsaPub.data);
BSL_SAL_Free(prv.key.dsaPrv.data);
BSL_SAL_Free(sign);
}
static bool CRYPT_CMVP_SelftestDsaInternal(void *libCtx, const char *attrName)
{
bool ret = false;
uint8_t *msg = NULL;
uint8_t *sign = NULL;
uint8_t *signVec = NULL;
uint32_t msgLen, signLen;
uint32_t signVecLen = 0;
CRYPT_EAL_PkeyCtx *pkeyPrv = NULL;
CRYPT_EAL_PkeyCtx *pkeyPub = NULL;
CRYPT_EAL_PkeyPara para = { 0 };
CRYPT_EAL_PkeyPub pub = { 0 };
CRYPT_EAL_PkeyPrv prv = { 0 };
CRYPT_EAL_RandFunc func = CRYPT_RandRegistGet();
CRYPT_EAL_RandFuncEx funcEx = CRYPT_RandRegistExGet();
CRYPT_RandRegistEx(NULL);
msg = CMVP_StringsToBins(DSA_VECTOR.msg, &msgLen);
GOTO_ERR_IF_TRUE(msg == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(!GetPkey(libCtx, attrName, &pkeyPrv, &pkeyPub, ¶, &pub, &prv), CRYPT_CMVP_ERR_ALGO_SELFTEST);
signLen = CRYPT_EAL_PkeyGetSignLen(pkeyPrv);
sign = BSL_SAL_Malloc(signLen);
signVecLen = signLen;
GOTO_ERR_IF_TRUE(sign == NULL, CRYPT_MEM_ALLOC_FAIL);
signVec = BSL_SAL_Malloc(signLen);
GOTO_ERR_IF_TRUE(signVec == NULL, CRYPT_MEM_ALLOC_FAIL);
// regist rand function
CRYPT_RandRegist(TestVectorRandom);
// sign
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySign(pkeyPrv, DSA_VECTOR.mdId, msg, msgLen, sign, &signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
// compare the signature
GOTO_ERR_IF_TRUE(SignEncode(DSA_VECTOR.r, DSA_VECTOR.s, signVec, &signVecLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(signLen != signVecLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(signVec, sign, signLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
// verify
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyVerify(pkeyPub, DSA_VECTOR.mdId, msg, msgLen, sign, signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
FreeData(para, pub, prv, msg, sign);
BSL_SAL_Free(signVec);
CRYPT_EAL_PkeyFreeCtx(pkeyPrv);
CRYPT_EAL_PkeyFreeCtx(pkeyPub);
CRYPT_RandRegist(func);
CRYPT_RandRegistEx(funcEx);
return ret;
}
bool CRYPT_CMVP_SelftestDsa(void)
{
return CRYPT_CMVP_SelftestDsaInternal(NULL, NULL);
}
bool CRYPT_CMVP_SelftestProviderDsa(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestDsaInternal(libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_dsa.c | C | unknown | 9,983 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "securec.h"
#include "bsl_sal.h"
typedef struct {
const char *bobD;
const char *bobX;
const char *bobY;
const char *aliceD;
const char *aliceX;
const char *aliceY;
const char *shareKey;
int32_t curveId;
CRYPT_MD_AlgId mdId;
} CMVP_EcdhVector;
// https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/keymgmt/KASTestVectorsECC2016.zip
static const CMVP_EcdhVector ECDH_VECTOR = {
.bobD = "d58751997b3a551ccdc6f507bf6ab87e2be7f8267067a455a5815a54",
.bobX = "c7893ced15c3009b93cb0abeaea2ede308b67fbbd902c6c5d94c24a4",
.bobY = "858afc2edd61fcefef3469dd5a004e74a3c727d16498a9408a8e3224",
.aliceD = "e935434303d842605d07112b3b7789ccbe4c6d987db5fa15ea1cdadb",
.aliceX = "784028a2246950401ec81f8e4e03fd3765c4da4d45eba652ed5ba2b5",
.aliceY = "d071c32634bcf058f072493b6943453a0bd117f5ee5c5866f037f6ab",
.shareKey = "dfd0570d4ae5c9f690c757aead04f7e14758fdc4ee05d8f0d089b91a",
.curveId = CRYPT_ECC_NISTP224,
.mdId = CRYPT_MD_SHA224
};
static bool GetPkey(void *libCtx, const char *attrName, bool isBob, CRYPT_EAL_PkeyCtx **pkeyPrv,
CRYPT_EAL_PkeyCtx **pkeyPub, CRYPT_EAL_PkeyPub *pub, CRYPT_EAL_PkeyPrv *prv)
{
bool ret = false;
uint8_t *x = NULL;
uint8_t *y = NULL;
uint32_t xLen, yLen;
*pkeyPrv = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_ECDH, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPrv == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
*pkeyPub = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_ECDH, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPub == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
prv->id = CRYPT_PKEY_ECDH;
if (isBob == true) {
prv->key.eccPrv.data = CMVP_StringsToBins(ECDH_VECTOR.bobD, &(prv->key.eccPrv.len));
} else {
prv->key.eccPrv.data = CMVP_StringsToBins(ECDH_VECTOR.aliceD, &(prv->key.eccPrv.len));
}
GOTO_ERR_IF_TRUE(prv->key.eccPrv.data == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetParaById(*pkeyPrv, ECDH_VECTOR.curveId) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(*pkeyPrv, prv) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
pub->id = CRYPT_PKEY_ECDH;
if (isBob == true) {
x = CMVP_StringsToBins(ECDH_VECTOR.bobX, &xLen);
y = CMVP_StringsToBins(ECDH_VECTOR.bobY, &yLen);
} else {
x = CMVP_StringsToBins(ECDH_VECTOR.aliceX, &xLen);
y = CMVP_StringsToBins(ECDH_VECTOR.aliceY, &yLen);
}
GOTO_ERR_IF_TRUE(x == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(y == NULL, CRYPT_CMVP_COMMON_ERR);
pub->key.eccPub.len = xLen + yLen + 1;
pub->key.eccPub.data = BSL_SAL_Malloc(pub->key.eccPub.len);
GOTO_ERR_IF_TRUE(pub->key.eccPub.data == NULL, CRYPT_MEM_ALLOC_FAIL);
pub->key.eccPub.data[0] = 0x04; // CRYPT_POINT_UNCOMPRESSED标记头
GOTO_ERR_IF_TRUE(memcpy_s(pub->key.eccPub.data + 1, pub->key.eccPub.len, x, xLen) != EOK, CRYPT_SECUREC_FAIL);
GOTO_ERR_IF_TRUE(
memcpy_s(pub->key.eccPub.data + 1 + xLen, pub->key.eccPub.len, y, yLen) != EOK, CRYPT_SECUREC_FAIL);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetParaById(*pkeyPub, ECDH_VECTOR.curveId) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(*pkeyPub, pub) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_FREE(x);
BSL_SAL_FREE(y);
return ret;
}
static bool CRYPT_CMVP_SelftestEcdhInternal(void *libCtx, const char *attrName)
{
bool ret = false;
CRYPT_EAL_PkeyCtx *bobPrvPkey = NULL;
CRYPT_EAL_PkeyCtx *bobPubPkey = NULL;
CRYPT_EAL_PkeyPub bobPub = { 0 };
CRYPT_EAL_PkeyPrv bobPrv = { 0 };
CRYPT_EAL_PkeyCtx *alicePrvPkey = NULL;
CRYPT_EAL_PkeyCtx *alicePubPkey = NULL;
CRYPT_EAL_PkeyPub alicePub = { 0 };
CRYPT_EAL_PkeyPrv alicePrv = { 0 };
uint8_t *shareKey = NULL;
uint32_t shareKeyLen;
uint8_t *expShareKey = NULL;
uint32_t expShareKeyLen;
expShareKey = CMVP_StringsToBins(ECDH_VECTOR.shareKey, &expShareKeyLen);
GOTO_ERR_IF_TRUE(expShareKey == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(GetPkey(libCtx, attrName, true, &bobPrvPkey, &bobPubPkey, &bobPub, &bobPrv) != true,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(GetPkey(libCtx, attrName, false, &alicePrvPkey, &alicePubPkey, &alicePub, &alicePrv) != true,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
shareKeyLen = CRYPT_EAL_PkeyGetKeyLen(bobPrvPkey);
shareKey = BSL_SAL_Malloc(shareKeyLen);
GOTO_ERR_IF_TRUE(shareKey == NULL, CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyComputeShareKey(bobPrvPkey, alicePubPkey, shareKey, &shareKeyLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(shareKeyLen != expShareKeyLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(expShareKey, shareKey, shareKeyLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
shareKeyLen = CRYPT_EAL_PkeyGetKeyLen(bobPrvPkey);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyComputeShareKey(alicePrvPkey, bobPubPkey, shareKey, &shareKeyLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(shareKeyLen != expShareKeyLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(expShareKey, shareKey, shareKeyLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(bobPub.key.eccPub.data);
BSL_SAL_Free(bobPrv.key.eccPrv.data);
CRYPT_EAL_PkeyFreeCtx(bobPrvPkey);
CRYPT_EAL_PkeyFreeCtx(bobPubPkey);
BSL_SAL_Free(alicePub.key.eccPub.data);
BSL_SAL_Free(alicePrv.key.eccPrv.data);
CRYPT_EAL_PkeyFreeCtx(alicePrvPkey);
CRYPT_EAL_PkeyFreeCtx(alicePubPkey);
BSL_SAL_Free(shareKey);
BSL_SAL_Free(expShareKey);
return ret;
}
bool CRYPT_CMVP_SelftestEcdh(void)
{
return CRYPT_CMVP_SelftestEcdhInternal(NULL, NULL);
}
bool CRYPT_CMVP_SelftestProviderEcdh(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestEcdhInternal(libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_ecdh.c | C | unknown | 6,935 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_bn.h"
#include "crypt_encode_internal.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_rand.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_util_rand.h"
#include "securec.h"
#include "bsl_sal.h"
#define BITS_OF_BYTE 8
typedef struct {
const char *msg;
const char *d;
const char *qX;
const char *qY;
const char *k;
const char *signR;
const char *signS;
int32_t curveId;
CRYPT_MD_AlgId mdId;
} CMVP_EcdsaVector;
// https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/dss/186-4ecdsatestvectors.zip
static const CMVP_EcdsaVector ECDSA_VECTOR = {
.msg = "ff624d0ba02c7b6370c1622eec3fa2186ea681d1659e0a845448e777b75a8e77"
"a77bb26e5733179d58ef9bc8a4e8b6971aef2539f77ab0963a3415bbd6258339"
"bd1bf55de65db520c63f5b8eab3d55debd05e9494212170f5d65b3286b8b6687"
"05b1e2b2b5568610617abb51d2dd0cb450ef59df4b907da90cfa7b268de8c4c2",
.d = "708309a7449e156b0db70e5b52e606c7e094ed676ce8953bf6c14757c826f590",
.qX = "29578c7ab6ce0d11493c95d5ea05d299d536801ca9cbd50e9924e43b733b83ab",
.qY = "08c8049879c6278b2273348474158515accaa38344106ef96803c5a05adc4800",
.k = "58f741771620bdc428e91a32d86d230873e9140336fcfb1e122892ee1d501bdc",
.signR = "4a19274429e40522234b8785dc25fc524f179dcc95ff09b3c9770fc71f54ca0d",
.signS = "58982b79a65b7320f5b92d13bdaecdd1259e760f0f718ba933fd098f6f75d4b7",
.curveId = CRYPT_ECC_NISTP256,
.mdId = CRYPT_MD_SHA224
};
static bool GetPkey(void *libCtx, const char *attrName, CRYPT_EAL_PkeyCtx **pkeyPrv, CRYPT_EAL_PkeyCtx **pkeyPub,
CRYPT_EAL_PkeyPub *pub, CRYPT_EAL_PkeyPrv *prv)
{
bool ret = false;
uint8_t *x = NULL;
uint8_t *y = NULL;
uint32_t xLen, yLen;
*pkeyPrv = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_ECDSA, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPrv == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
*pkeyPub = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_ECDSA, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPub == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
prv->id = CRYPT_PKEY_ECDSA;
prv->key.eccPrv.data = CMVP_StringsToBins(ECDSA_VECTOR.d, &(prv->key.eccPrv.len));
GOTO_ERR_IF_TRUE(prv->key.eccPrv.data == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetParaById(*pkeyPrv, ECDSA_VECTOR.curveId) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(*pkeyPrv, prv) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
pub->id = CRYPT_PKEY_ECDSA;
x = CMVP_StringsToBins(ECDSA_VECTOR.qX, &xLen);
GOTO_ERR_IF_TRUE(x == NULL, CRYPT_CMVP_COMMON_ERR);
y = CMVP_StringsToBins(ECDSA_VECTOR.qY, &yLen);
GOTO_ERR_IF_TRUE(y == NULL, CRYPT_CMVP_COMMON_ERR);
pub->key.eccPub.len = xLen + yLen + 1;
pub->key.eccPub.data = BSL_SAL_Malloc(pub->key.eccPub.len);
GOTO_ERR_IF_TRUE(pub->key.eccPub.data == NULL, CRYPT_MEM_ALLOC_FAIL);
pub->key.eccPub.data[0] = 0x04; // CRYPT_POINT_UNCOMPRESSED标记头
GOTO_ERR_IF_TRUE(memcpy_s(pub->key.eccPub.data + 1, pub->key.eccPub.len, x, xLen) != EOK, CRYPT_SECUREC_FAIL);
GOTO_ERR_IF_TRUE(
memcpy_s(pub->key.eccPub.data + 1 + xLen, pub->key.eccPub.len, y, yLen) != EOK, CRYPT_SECUREC_FAIL);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetParaById(*pkeyPub, ECDSA_VECTOR.curveId) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(*pkeyPub, pub) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(x);
BSL_SAL_Free(y);
return ret;
}
static int32_t TestVectorRandom(uint8_t *r, uint32_t rLen)
{
uint8_t *rand = NULL;
uint32_t randLen;
rand = CMVP_StringsToBins(ECDSA_VECTOR.k, &randLen);
if (rand == NULL) {
return CRYPT_MEM_ALLOC_FAIL;
}
if (randLen < rLen) {
BSL_SAL_Free(rand);
return CRYPT_CMVP_ERR_ALGO_SELFTEST;
}
for (uint32_t i = 0; i < randLen; i++) {
r[i] = rand[i];
}
BSL_SAL_Free(rand);
return 0;
}
static int SignEncode(const char *signR, const char *signS, uint8_t *vectorSign, uint32_t *vectorSignLen)
{
int ret = CRYPT_CMVP_ERR_ALGO_SELFTEST;
BN_BigNum *bnR = NULL;
BN_BigNum *bnS = NULL;
uint8_t *r = NULL;
uint8_t *s = NULL;
uint32_t rLen, sLen;
r = CMVP_StringsToBins(signR, &rLen);
GOTO_ERR_IF_TRUE(r == NULL, CRYPT_CMVP_COMMON_ERR);
s = CMVP_StringsToBins(signS, &sLen);
GOTO_ERR_IF_TRUE(s == NULL, CRYPT_CMVP_COMMON_ERR);
bnR = BN_Create(rLen * BITS_OF_BYTE);
bnS = BN_Create(sLen * BITS_OF_BYTE);
GOTO_ERR_IF_TRUE(BN_Bin2Bn(bnR, r, rLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(BN_Bin2Bn(bnS, s, sLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = CRYPT_EAL_EncodeSign(bnR, bnS, vectorSign, vectorSignLen);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = CRYPT_SUCCESS;
ERR:
BSL_SAL_Free(r);
BSL_SAL_Free(s);
BN_Destroy(bnR);
BN_Destroy(bnS);
return ret;
}
static bool CRYPT_CMVP_SelftestEcdsaInternal(void *libCtx, const char *attrName)
{
bool ret = false;
uint8_t *sign = NULL;
uint8_t *signVec = NULL;
uint32_t signLen;
uint32_t signVecLen = 0;
uint8_t *msg = NULL;
uint32_t msgLen;
CRYPT_EAL_PkeyCtx *pkeyPrv = NULL;
CRYPT_EAL_PkeyCtx *pkeyPub = NULL;
CRYPT_EAL_PkeyPub pub = { 0 };
CRYPT_EAL_PkeyPrv prv = { 0 };
CRYPT_EAL_RandFunc func = CRYPT_RandRegistGet();
CRYPT_EAL_RandFuncEx funcEx = CRYPT_RandRegistExGet();
CRYPT_RandRegistEx(NULL);
msg = CMVP_StringsToBins(ECDSA_VECTOR.msg, &msgLen);
GOTO_ERR_IF_TRUE(msg == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(GetPkey(libCtx, attrName, &pkeyPrv, &pkeyPub, &pub, &prv) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
signLen = CRYPT_EAL_PkeyGetSignLen(pkeyPrv);
sign = BSL_SAL_Malloc(signLen);
signVecLen = signLen;
GOTO_ERR_IF_TRUE(sign == NULL, CRYPT_MEM_ALLOC_FAIL);
signVec = BSL_SAL_Malloc(signLen);
GOTO_ERR_IF_TRUE(signVec == NULL, CRYPT_MEM_ALLOC_FAIL);
// regist rand function
CRYPT_RandRegist(TestVectorRandom);
// sign
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySign(pkeyPrv, ECDSA_VECTOR.mdId, msg, msgLen, sign, &signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
// compare the signature
GOTO_ERR_IF_TRUE(SignEncode(ECDSA_VECTOR.signR, ECDSA_VECTOR.signS, signVec, &signVecLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(signLen != signVecLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(signVec, sign, signLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
// verify
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyVerify(pkeyPub, ECDSA_VECTOR.mdId, msg, msgLen, sign, signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(pub.key.eccPub.data);
BSL_SAL_Free(prv.key.eccPrv.data);
BSL_SAL_Free(sign);
BSL_SAL_Free(signVec);
BSL_SAL_Free(msg);
CRYPT_EAL_PkeyFreeCtx(pkeyPrv);
CRYPT_EAL_PkeyFreeCtx(pkeyPub);
CRYPT_RandRegist(func);
CRYPT_RandRegistEx(funcEx);
return ret;
}
bool CRYPT_CMVP_SelftestEcdsa(void)
{
return CRYPT_CMVP_SelftestEcdsaInternal(NULL, NULL);
}
bool CRYPT_CMVP_SelftestProviderEcdsa(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestEcdsaInternal(libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_ecdsa.c | C | unknown | 8,267 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
typedef struct {
const char *prv;
const char *pub;
const char *msg;
const char *sign;
CRYPT_MD_AlgId mdId;
} CMVP_ED25519_VECTOR;
// https://datatracker.ietf.org/doc/html/rfc8032.html#page-24
static const CMVP_ED25519_VECTOR ED25519_VECTOR = {
.prv = "4ccd089b28ff96da9db6c346ec114e0f5b8a319f35aba624da8cf6ed4fb8a6fb",
.pub = "3d4017c3e843895a92b70aa74d1b7ebc9c982ccf2ec4968cc0cd55f12af4660c",
.msg = "72",
.sign = "92a009a9f0d4cab8720e820b5f642540a2b27b5416503f8fb3762223ebdb69da085ac1e43e15996e"
"458f3613d0f11d8c387b2eaeb4302aeeb00d291612bb0c00",
.mdId = CRYPT_MD_SHA512
};
static void FreeData(uint8_t *prv, uint8_t *pub, uint8_t *msg, uint8_t *expSign, uint8_t *sign)
{
BSL_SAL_Free(prv);
BSL_SAL_Free(pub);
BSL_SAL_Free(msg);
BSL_SAL_Free(expSign);
BSL_SAL_Free(sign);
}
static bool CRYPT_CMVP_SelftestEd25519Internal(void *libCtx, const char *attrName)
{
bool ret = false;
uint8_t *prv = NULL;
uint8_t *pub = NULL;
uint8_t *msg = NULL;
uint8_t *expSign = NULL;
uint8_t *sign = NULL;
uint32_t prvLen, pubLen, msgLen, expSignLen, signLen;
CRYPT_EAL_PkeyCtx *prvCtx = NULL;
CRYPT_EAL_PkeyCtx *pubCtx = NULL;
CRYPT_EAL_PkeyPrv prvKey = {0};
CRYPT_EAL_PkeyPub pubKey;
prv = CMVP_StringsToBins(ED25519_VECTOR.prv, &prvLen);
GOTO_ERR_IF_TRUE(prv == NULL, CRYPT_CMVP_COMMON_ERR);
pub = CMVP_StringsToBins(ED25519_VECTOR.pub, &pubLen);
GOTO_ERR_IF_TRUE(pub == NULL, CRYPT_CMVP_COMMON_ERR);
msg = CMVP_StringsToBins(ED25519_VECTOR.msg, &msgLen);
GOTO_ERR_IF_TRUE(msg == NULL, CRYPT_CMVP_COMMON_ERR);
expSign = CMVP_StringsToBins(ED25519_VECTOR.sign, &expSignLen);
GOTO_ERR_IF_TRUE(expSign == NULL, CRYPT_CMVP_COMMON_ERR);
signLen = expSignLen;
sign = BSL_SAL_Malloc(signLen);
GOTO_ERR_IF_TRUE(sign == NULL, CRYPT_MEM_ALLOC_FAIL);
prvKey.id = CRYPT_PKEY_ED25519;
prvKey.key.curve25519Prv.data = prv;
prvKey.key.curve25519Prv.len = prvLen;
prvCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_ED25519, 0, attrName);
GOTO_ERR_IF_TRUE(prvCtx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySign(prvCtx, ED25519_VECTOR.mdId, msg, msgLen, sign, &signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(signLen != expSignLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(expSign, sign, signLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
pubKey.id = CRYPT_PKEY_ED25519;
pubKey.key.curve25519Pub.data = pub;
pubKey.key.curve25519Pub.len = pubLen;
pubCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_ED25519, 0, attrName);
GOTO_ERR_IF_TRUE(pubCtx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(pubCtx, &pubKey) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyVerify(pubCtx, ED25519_VECTOR.mdId, msg, msgLen, sign, signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
FreeData(prv, pub, msg, expSign, sign);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
CRYPT_EAL_PkeyFreeCtx(pubCtx);
return ret;
}
bool CRYPT_CMVP_SelftestEd25519(void)
{
return CRYPT_CMVP_SelftestEd25519Internal(NULL, NULL);
}
bool CRYPT_CMVP_SelftestProviderEd25519(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestEd25519Internal(libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_ed25519.c | C | unknown | 4,464 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "crypt_params_key.h"
#include "crypt_errno.h"
#include "crypt_eal_kdf.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
typedef struct {
const char *ikm;
const char *salt;
const char *info;
const char *okm;
CRYPT_MAC_AlgId id;
} CMVP_HKDF_VECTOR;
// https://datatracker.ietf.org/doc/html/rfc5869.html#appendix-A
static const CMVP_HKDF_VECTOR HKDF_VECTOR = {
.ikm = "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
.salt = "000102030405060708090a0b0c",
.info = "f0f1f2f3f4f5f6f7f8f9",
.okm = "3cb25f25faacd57a90434f64d0362f2a2d2d0a90cf1a5a4c5db02d56ecc4c5bf34007208d5b887185865",
.id = CRYPT_MAC_HMAC_SHA256
};
static bool CRYPT_CMVP_SelftestHkdfInternal(void *libCtx, const char *attrName)
{
bool ret = false;
uint8_t *key = NULL;
uint8_t *salt = NULL;
uint8_t *info = NULL;
uint8_t *expOut = NULL;
uint8_t *out = NULL;
uint32_t keyLen, saltLen, infoLen, expOutLen;
CRYPT_EAL_KdfCTX *ctx = NULL;
CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_FULL;
CRYPT_MAC_AlgId id = CRYPT_MAC_HMAC_SHA256;
key = CMVP_StringsToBins(HKDF_VECTOR.ikm, &keyLen);
GOTO_ERR_IF_TRUE(key == NULL, CRYPT_CMVP_COMMON_ERR);
salt = CMVP_StringsToBins(HKDF_VECTOR.salt, &saltLen);
GOTO_ERR_IF_TRUE(salt == NULL, CRYPT_CMVP_COMMON_ERR);
info = CMVP_StringsToBins(HKDF_VECTOR.info, &infoLen);
GOTO_ERR_IF_TRUE(info == NULL, CRYPT_CMVP_COMMON_ERR);
expOut = CMVP_StringsToBins(HKDF_VECTOR.okm, &expOutLen);
GOTO_ERR_IF_TRUE(expOut == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(expOut == NULL, CRYPT_CMVP_COMMON_ERR);
out = BSL_SAL_Malloc(expOutLen);
GOTO_ERR_IF_TRUE(out == NULL, CRYPT_MEM_ALLOC_FAIL);
ctx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_HKDF, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
BSL_Param param[6] = {
{CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32, &id, sizeof(id), 0},
{CRYPT_PARAM_KDF_MODE, BSL_PARAM_TYPE_UINT32, &mode, sizeof(mode), 0},
{CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS, key, keyLen, 0},
{CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS, salt, saltLen, 0},
{CRYPT_PARAM_KDF_INFO, BSL_PARAM_TYPE_OCTETS, info, infoLen, 0},
BSL_PARAM_END
};
GOTO_ERR_IF_TRUE(CRYPT_EAL_KdfSetParam(ctx, param) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_KdfDerive(ctx, out, expOutLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(out, expOut, expOutLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(key);
BSL_SAL_Free(salt);
BSL_SAL_Free(info);
BSL_SAL_Free(expOut);
BSL_SAL_Free(out);
CRYPT_EAL_KdfFreeCtx(ctx);
return ret;
}
bool CRYPT_CMVP_SelftestHkdf(void)
{
return CRYPT_CMVP_SelftestHkdfInternal(NULL, NULL);
}
bool CRYPT_CMVP_SelftestProviderHkdf(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestHkdfInternal(libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_hkdf.c | C | unknown | 3,825 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_kdf.h"
#include "crypt_params_key.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
typedef struct {
const char *key;
const char *label;
const char *seed;
const char *dk;
CRYPT_MAC_AlgId id;
} CMVP_KDFTLS12_VECTOR;
// https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/components/800-135testvectors/tls.zip
static const CMVP_KDFTLS12_VECTOR KDF_TLS12_VECTOR = {
.key = "202c88c00f84a17a20027079604787461176455539e705be730890602c289a5001e34eeb3a043e5d52a65e66125188bf",
.label = "6b657920657870616e73696f6eae6c806f8ad4d80784549dff28a4b58fd837681a51d928c3e30ee5ff14f3986862e1fd91",
.seed = "f23f558a605f28478c58cf72637b89784d959df7e946d3f07bd1b616",
.dk = "d06139889fffac1e3a71865f504aa5d0d2a2e89506c6f2279b670c3e1b74f531016a25"
"30c51a3a0f7e1d6590d0f0566b2f387f8d11fd4f731cdd572d2eae927f6f2f81410b25"
"e6960be68985add6c38445ad9f8c64bf8068bf9a6679485d966f1ad6f68b43495b10a6"
"83755ea2b858d70ccac7ec8b053c6bd41ca299d4e51928",
.id = CRYPT_MAC_HMAC_SHA256
};
static bool CRYPT_CMVP_SelftestKdfTls12Internal(void *libCtx, const char *attrName)
{
bool ret = false;
uint8_t *key = NULL;
uint8_t *label = NULL;
uint8_t *seed = NULL;
uint8_t *expDk = NULL;
uint8_t *dk = NULL;
uint32_t keyLen, labelLen, seedLen, expDkLen;
CRYPT_EAL_KdfCTX *ctx = NULL;
CRYPT_MAC_AlgId id = CRYPT_MAC_HMAC_SHA256;
key = CMVP_StringsToBins(KDF_TLS12_VECTOR.key, &keyLen);
GOTO_ERR_IF_TRUE(key == NULL, CRYPT_CMVP_COMMON_ERR);
label = CMVP_StringsToBins(KDF_TLS12_VECTOR.label, &labelLen);
GOTO_ERR_IF_TRUE(label == NULL, CRYPT_CMVP_COMMON_ERR);
seed = CMVP_StringsToBins(KDF_TLS12_VECTOR.seed, &seedLen);
GOTO_ERR_IF_TRUE(seed == NULL, CRYPT_CMVP_COMMON_ERR);
expDk = CMVP_StringsToBins(KDF_TLS12_VECTOR.dk, &expDkLen);
GOTO_ERR_IF_TRUE(expDk == NULL, CRYPT_CMVP_COMMON_ERR);
dk = BSL_SAL_Malloc(expDkLen);
GOTO_ERR_IF_TRUE(dk == NULL, CRYPT_MEM_ALLOC_FAIL);
ctx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_KDFTLS12, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
BSL_Param param[5] = {
{CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32, &id, sizeof(id), 0},
{CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS, key, keyLen, 0},
{CRYPT_PARAM_KDF_LABEL, BSL_PARAM_TYPE_OCTETS, label, labelLen, 0},
{CRYPT_PARAM_KDF_SEED, BSL_PARAM_TYPE_OCTETS, seed, seedLen, 0},
BSL_PARAM_END
};
GOTO_ERR_IF_TRUE(CRYPT_EAL_KdfSetParam(ctx, param) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_KdfDerive(ctx, dk, expDkLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(dk, expDk, expDkLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(key);
BSL_SAL_Free(label);
BSL_SAL_Free(seed);
BSL_SAL_Free(expDk);
BSL_SAL_Free(dk);
CRYPT_EAL_KdfFreeCtx(ctx);
return ret;
}
bool CRYPT_CMVP_SelftestKdfTls12(void)
{
return CRYPT_CMVP_SelftestKdfTls12Internal(NULL, NULL);
}
bool CRYPT_CMVP_SelftestProviderKdfTls12(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestKdfTls12Internal(libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_kdftls12.c | C | unknown | 4,134 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_mac.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
#include "crypt_local_types.h"
#define MAC_TYPE_HMAC_CMAC 1
#define MAC_TYPE_GMAC 2
#define MAC_TYPE_CBC_MAC 3
typedef struct {
uint32_t id;
const char *key;
const char *msg;
const char *mac;
const char *iv;
uint32_t type;
} CMVP_MAC_VECTOR;
static const CMVP_MAC_VECTOR MAC_VECTOR[] = {
// CRYPT_MAC_HMAC_MD5
// https://datatracker.ietf.org/doc/html/rfc2202
{
.id = CRYPT_MAC_HMAC_MD5,
.key = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
.msg = "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD",
.mac = "56be34521d144c88dbb8c733f0e8b3f6",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_HMAC_SHA1
// https://datatracker.ietf.org/doc/html/rfc2202
{
.id = CRYPT_MAC_HMAC_SHA1,
.key = "0102030405060708090a0b0c0d0e0f10111213141516171819",
.msg = "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
.mac = "4c9007f4026250c6bc8414f9bf50c86c2d7235da",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_HMAC_SHA224
// https://datatracker.ietf.org/doc/html/rfc4231.html#page-4
{
.id = CRYPT_MAC_HMAC_SHA224,
.key = "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
.msg = "4869205468657265",
.mac = "896fb1128abbdf196832107cd49df33f47b4b1169912ba4f53684b22",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_HMAC_SHA256
// https://datatracker.ietf.org/doc/html/rfc4231.html#page-4
{
.id = CRYPT_MAC_HMAC_SHA256,
.key = "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
.msg = "4869205468657265",
.mac = "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_HMAC_SHA384
// https://datatracker.ietf.org/doc/html/rfc4231.html#page-4
{
.id = CRYPT_MAC_HMAC_SHA384,
.key = "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
.msg = "4869205468657265",
.mac = "afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c7cebc59cfaea9ea9076ede7f4af152e8b2fa9cb6",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_HMAC_SHA512
// https://datatracker.ietf.org/doc/html/rfc4231.html#page-4
{
.id = CRYPT_MAC_HMAC_SHA512,
.key = "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
.msg = "4869205468657265",
.mac = "87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cdedaa833"
"b7d6b8a702038b274eaea3f4e4be9d914""eeb61f1702e696c203a126854",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_HMAC_SM3
{
.id = CRYPT_MAC_HMAC_SM3,
.key = "00112233445566778899aabbccddeeff",
.msg = "6162636465666768696A6B6C6D6E6F707172737475767778797A", // abcdefghijklmnopqrstuvwxyz
.mac = "a51ce58c52ae29edd66a53e6aaf0745bf4fedbde899973b2d817290e646df87e",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_CMAC_AES128
// https://csrc.nist.gov/Projects/cryptographic-algorithm-validation-program/cavp-testing-block-cipher-modes#CMAC
{
.id = CRYPT_MAC_CMAC_AES128,
.key = "5fcad38ae778394912f8f1b8413cf773",
.msg = "07185502bf6d275c84e3ac4f5f77c3d4",
.mac = "fd44fbc0dd9719e8b569ff10421df4",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_CMAC_AES192
// https://csrc.nist.gov/Projects/cryptographic-algorithm-validation-program/cavp-testing-block-cipher-modes#CMAC
{
.id = CRYPT_MAC_CMAC_AES192,
.key = "7fea563a866571822472dade8a0bec4b98202d47a3443129",
.msg = "a206a1eb70a9d24bb5e72f314e7d91de074f59055653bdd24aab5f2bbe112436",
.mac = "3bfe96f05e9cf96a98bd",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_CMAC_AES256
// https://csrc.nist.gov/Projects/cryptographic-algorithm-validation-program/cavp-testing-block-cipher-modes#CMAC
{
.id = CRYPT_MAC_CMAC_AES256,
.key = "7bef8d35616108922aab78936967204980b8a4945b31602f5ef2feec9b144841",
.msg = "40affd355416200191ba64edec8d7d27ead235a7b2e01a12662273deb36379b8a748c422c31e046152d6f196f94e852b",
.mac = "b2d078071e318ec88de9",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_CMAC_SM4
// GB/T 15852.1-2020 B.6
{
.id = CRYPT_MAC_CMAC_SM4,
.key = "0123456789ABCDEFFEDCBA9876543210",
.msg = "54686973206973207468652074657374206d65737361676520666f72206d6163", // "This is the test message for mac"
.mac = "692c437100f3b5ee2b8abcef373d990c",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_GMAC_AES128
// https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/mac/gcmtestvectors.zip
{
.id = CRYPT_MAC_GMAC_AES128,
.key = "bea48ae4980d27f357611014d4486625",
.msg = "8a50b0b8c7654bced884f7f3afda2ead",
.mac = "8e0f6d8bf05ffebe6f500eb1",
.iv = "32bddb5c3aa998a08556454c",
.type = MAC_TYPE_GMAC
},
// CRYPT_MAC_GMAC_AES192
// https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/mac/gcmtestvectors.zip
{
.id = CRYPT_MAC_GMAC_AES192,
.key = "41c5da8667ef725220ffe39ae0ac590ac9fca729ab60ada0",
.msg = "8b5c124bef6e2f0fe4d8c95cd5fa4cf1",
.mac = "204bdb1bd62154bf08922aaa54eed705",
.iv = "05ad13a5e2c2ab667e1a6fbc",
.type = MAC_TYPE_GMAC
},
// CRYPT_MAC_GMAC_AES256
// https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/mac/gcmtestvectors.zip
{
.id = CRYPT_MAC_GMAC_AES256,
.key = "78dc4e0aaf52d935c3c01eea57428f00ca1fd475f5da86a49c8dd73d68c8e223",
.msg = "b96baa8c1c75a671bfb2d08d06be5f36",
.mac = "3e5d486aa2e30b22e040b85723a06e76",
.iv = "d79cf22d504cc793c3fb6c8a",
.type = MAC_TYPE_GMAC
},
// CRYPT_MAC_CBC_MAC_SM4
// GB/T 15852.1-2020 B.2
{
.id = CRYPT_MAC_CBC_MAC_SM4,
.key = "0123456789ABCDEFFEDCBA9876543210",
.msg = "54686973206973207468652074657374206d65737361676520666f72206d6163", // "This is the test message for mac"
.mac = "16e02904efb765b706459c9edabdb519",
.iv = NULL,
.type = MAC_TYPE_CBC_MAC
},
{
.id = CRYPT_MAC_MAX,
.key = NULL,
.msg = NULL,
.mac = NULL,
.iv = NULL,
.type = 0
}
};
static void FreeData(uint8_t *key, uint8_t *msg, uint8_t *mac, uint8_t *expectMac, uint8_t *iv)
{
BSL_SAL_Free(key);
BSL_SAL_Free(msg);
BSL_SAL_Free(mac);
BSL_SAL_Free(expectMac);
BSL_SAL_Free(iv);
}
static bool GetData(const CMVP_MAC_VECTOR *macVec, CRYPT_Data *key, CRYPT_Data *msg,
CRYPT_Data *expectMac, CRYPT_Data *iv)
{
key->data = CMVP_StringsToBins(macVec->key, &(key->len));
GOTO_ERR_IF_TRUE(key->data == NULL, CRYPT_CMVP_COMMON_ERR);
msg->data = CMVP_StringsToBins(macVec->msg, &(msg->len));
GOTO_ERR_IF_TRUE(msg->data == NULL, CRYPT_CMVP_COMMON_ERR);
expectMac->data = CMVP_StringsToBins(macVec->mac, &(expectMac->len));
GOTO_ERR_IF_TRUE(expectMac->data == NULL, CRYPT_CMVP_COMMON_ERR);
if (macVec->iv != NULL) {
iv->data = CMVP_StringsToBins(macVec->iv, &(iv->len));
GOTO_ERR_IF_TRUE(iv->data == NULL, CRYPT_CMVP_COMMON_ERR);
}
return true;
ERR:
return false;
}
const CMVP_MAC_VECTOR *FindMacVectorById(CRYPT_MAC_AlgId id)
{
uint32_t num = sizeof(MAC_VECTOR) / sizeof(MAC_VECTOR[0]);
const CMVP_MAC_VECTOR *macVec = NULL;
for (uint32_t i = 0; i < num; i++) {
if (MAC_VECTOR[i].id == id) {
macVec = &MAC_VECTOR[i];
return macVec;
}
}
return NULL;
}
static bool CRYPT_CMVP_SelftestMacInternal(void *libCtx, const char *attrName, CRYPT_MAC_AlgId id)
{
bool ret = false;
CRYPT_EAL_MacCtx *ctx = NULL;
CRYPT_Data key = { NULL, 0 };
CRYPT_Data msg = { NULL, 0 };
CRYPT_Data iv = { NULL, 0 };
uint8_t *mac = NULL;
uint32_t macLen = 0;
CRYPT_Data expectMac = { NULL, 0 };
const CMVP_MAC_VECTOR *macVec = FindMacVectorById(id);
// HMAC-MD5 is a non-approved algorithm and does not provide self-test.
if (macVec == NULL || macVec->msg == NULL || macVec->id == CRYPT_MAC_HMAC_MD5) {
return false;
}
GOTO_ERR_IF_TRUE(!GetData(macVec, &key, &msg, &expectMac, &iv), CRYPT_CMVP_ERR_ALGO_SELFTEST);
ctx = CRYPT_EAL_ProviderMacNewCtx(libCtx, id, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
if (macVec->type == MAC_TYPE_GMAC) {
macLen = expectMac.len;
} else {
macLen = CRYPT_EAL_GetMacLen(ctx);
}
mac = BSL_SAL_Malloc(macLen);
GOTO_ERR_IF_TRUE(mac == NULL, CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_TRUE(CRYPT_EAL_MacInit(ctx, key.data, key.len) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
if (macVec->type == MAC_TYPE_GMAC) {
GOTO_ERR_IF_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_IV, iv.data, iv.len) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &macLen, sizeof(uint32_t)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
if (macVec->type == MAC_TYPE_CBC_MAC) {
CRYPT_PaddingType padType = CRYPT_PADDING_ZEROS;
GOTO_ERR_IF_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_CBC_MAC_PADDING, &padType, sizeof(CRYPT_PaddingType)) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
GOTO_ERR_IF_TRUE(CRYPT_EAL_MacUpdate(ctx, msg.data, msg.len) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(mac, expectMac.data, expectMac.len) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
FreeData(key.data, msg.data, mac, expectMac.data, iv.data);
CRYPT_EAL_MacDeinit(ctx);
CRYPT_EAL_MacFreeCtx(ctx);
return ret;
}
bool CRYPT_CMVP_SelftestMac(CRYPT_MAC_AlgId id)
{
return CRYPT_CMVP_SelftestMacInternal(NULL, NULL, id);
}
bool CRYPT_CMVP_SelftestProviderMac(void *libCtx, const char *attrName, CRYPT_MAC_AlgId id)
{
return CRYPT_CMVP_SelftestMacInternal(libCtx, attrName, id);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_mac.c | C | unknown | 11,545 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_md.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
typedef struct {
uint32_t id;
const char *msg;
const char *md;
} CMVP_HASH_VECTOR;
static const CMVP_HASH_VECTOR HASH_VECTOR[] = {
// CRYPT_MD_MD5
{
.id = CRYPT_MD_MD5,
.msg = NULL,
.md = NULL
},
// CRYPT_MD_SHA1
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHA1,
.msg = "7e3d7b3eada98866",
.md = "24a2c34b976305277ce58c2f42d5092031572520"
},
// CRYPT_MD_SHA224
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHA224,
.msg = "5f77b3664823c33e",
.md = "bdf21ff325f754157ccf417f4855360a72e8fd117d28c8fe7da3ea38"
},
// CRYPT_MD_SHA256
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHA256,
.msg = "5738c929c4f4ccb6",
.md = "963bb88f27f512777aab6c8b1a02c70ec0ad651d428f870036e1917120fb48bf"
},
// CRYPT_MD_SHA384
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHA384,
.msg = "de60275bdafce4b1",
.md = "a3d861d866c1362423eb21c6bec8e44b74ce993c55baa2b6640567560ebecdaeda07183dbbbd95e0"
"f522caee5ddbdaf0"
},
// CRYPT_MD_SHA512
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHA512,
.msg = "6f8d58b7cab1888c",
.md = "a3941def2803c8dfc08f20c06ba7e9a332ae0c67e47ae57365c243ef40059b11be22c91da6a80c2c"
"ff0742a8f4bcd941bdee0b861ec872b215433ce8dcf3c031"
},
// CRYPT_MD_SHA3_224
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHA3_224,
.msg = "d85e470a7c6988",
.md = "8a134c33c7abd673cd3d0c33956700760de980c5aee74c96e6ba08b2"
},
// CRYPT_MD_SHA3_256
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHA3_256,
.msg = "8bca931c8a132d2f",
.md = "dbb8be5dec1d715bd117b24566dc3f24f2cc0c799795d0638d9537481ef1e03e"
},
// CRYPT_MD_SHA3_384
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHA3_384,
.msg = "c44a2c58c84c393a",
.md = "60ad40f964d0edcf19281e415f7389968275ff613199a069c916a0ff7ef65503b740683162a622b913d43a46559e913c"
},
// CRYPT_MD_SHA3_512
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHA3_512,
.msg = "af53fa3ff8a3cfb2",
.md = "03c2ac02de1765497a0a6af466fb64758e3283ed83d02c0edb3904fd3cf296442e790018d4bf4ce55bc869"
"cebb4aa1a799afc9d987e776fef5dfe6628e24de97"
},
// CRYPT_MD_SHAKE128
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHAKE128,
.msg = "7bf2fef375bcaff3",
.md = "5ef5578b89c50532131b7843de7329a3"
},
// CRYPT_MD_SHAKE256
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHAKE256,
.msg = "587cb398fe82ffda",
.md = "54f5dddb85f62dba7dc4727d502bdee959fb665bd482bd0ce31cbdd1a042e4b5"
},
// CRYPT_MD_SM3
{
.id = CRYPT_MD_SM3,
.msg = "616263",
.md = "66c7f0f462eeedd9d1f2d46bdc10e4e24167c4875cf2f7a2297da02b8f4ba8e0"
},
{
.id = CRYPT_MD_MAX,
.msg = NULL,
.md = NULL
}
};
static void FreeData(uint8_t *msg, uint8_t *md, uint8_t *expectMd)
{
BSL_SAL_Free(msg);
BSL_SAL_Free(md);
BSL_SAL_Free(expectMd);
}
const CMVP_HASH_VECTOR *FindVectorById(CRYPT_MD_AlgId id)
{
const CMVP_HASH_VECTOR *pHashVec = NULL;
uint32_t num = sizeof(HASH_VECTOR) / sizeof(HASH_VECTOR[0]);
for (uint32_t i = 0; i < num; i++) {
if (HASH_VECTOR[i].id == id) {
pHashVec = &HASH_VECTOR[i];
return pHashVec;
}
}
return NULL;
}
static bool CRYPT_CMVP_SelftestMdInternal(void *libCtx, const char *attrName, CRYPT_MD_AlgId id)
{
bool ret = false;
uint8_t *msg = NULL;
uint8_t *md = NULL;
uint8_t *expectMd = NULL;
uint32_t msgLen, mdLen, expectMdLen;
CRYPT_EAL_MdCTX *ctx = NULL;
const CMVP_HASH_VECTOR *hashVec = FindVectorById(id);
if (hashVec == NULL || hashVec->msg == NULL) {
return false;
}
msg = CMVP_StringsToBins(hashVec->msg, &msgLen);
GOTO_ERR_IF_TRUE(msg == NULL, CRYPT_CMVP_COMMON_ERR);
expectMd = CMVP_StringsToBins(hashVec->md, &expectMdLen);
GOTO_ERR_IF_TRUE(expectMd == NULL, CRYPT_CMVP_COMMON_ERR);
ctx = CRYPT_EAL_ProviderMdNewCtx(libCtx, id, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
if (id == CRYPT_MD_SHAKE128 || id == CRYPT_MD_SHAKE256) {
mdLen = expectMdLen;
} else {
mdLen = CRYPT_EAL_MdGetDigestSize(id);
}
md = BSL_SAL_Malloc(mdLen);
GOTO_ERR_IF_TRUE(md == NULL, CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_TRUE(CRYPT_EAL_MdInit(ctx) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_MdUpdate(ctx, msg, msgLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_MdFinal(ctx, md, &mdLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(mdLen != expectMdLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(expectMd, md, mdLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
FreeData(msg, md, expectMd);
CRYPT_EAL_MdFreeCtx(ctx);
return ret;
}
bool CRYPT_CMVP_SelftestMd(CRYPT_MD_AlgId id)
{
return CRYPT_CMVP_SelftestMdInternal(NULL, NULL, id);
}
bool CRYPT_CMVP_SelftestProviderMd(void *libCtx, const char *attrName, CRYPT_MD_AlgId id)
{
return CRYPT_CMVP_SelftestMdInternal(libCtx, attrName, id);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_md.c | C | unknown | 7,164 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_rand.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_util_rand.h"
#include "crypt_algid.h"
#include "securec.h"
#include "bsl_sal.h"
#define BITS_OF_BYTE 8
typedef struct {
const char *rnd;
const char *sk;
const char *pk;
const char *msg;
const char *sig;
int32_t algId;
int32_t type;
} CMVP_MldsaVector;
static const CMVP_MldsaVector MLDSA_VECTOR[] = {
{
// https://github.com/usnistgov/ACVP-Server/tree/master/gen-val/json-files/ML-DSA-sigGen-FIPS204
.rnd = "1D073BE3C59909102F6C26537E61E56CDB37FE1167E092DC3B73067E1B43B2A2",
.sk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
.pk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
.msg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
.sig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
.algId = CRYPT_PKEY_ML_DSA,
.type = CRYPT_MLDSA_TYPE_MLDSA_44,
}
};
static const char *MLDSA_SEED_VECTOR = NULL;
static int32_t GetPkey(void *libCtx, const char *attrName, const CMVP_MldsaVector *vector, CRYPT_EAL_PkeyCtx **pkeyPrv,
CRYPT_EAL_PkeyCtx **pkeyPub)
{
int32_t ret = CRYPT_CMVP_ERR_ALGO_SELFTEST;
CRYPT_EAL_PkeyPrv prvKey = { 0 };
CRYPT_EAL_PkeyPub pubKey = { 0 };
*pkeyPrv = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, vector->algId, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPrv == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
*pkeyPub = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, vector->algId, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPub == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = CRYPT_EAL_PkeySetParaById(*pkeyPrv, vector->type);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
ret = CRYPT_EAL_PkeySetParaById(*pkeyPub, vector->type);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
int32_t val = 0;
ret = CRYPT_EAL_PkeyCtrl(*pkeyPrv, CRYPT_CTRL_SET_MLDSA_ENCODE_FLAG, &val, sizeof(val));
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
ret = CRYPT_EAL_PkeyCtrl(*pkeyPub, CRYPT_CTRL_SET_MLDSA_ENCODE_FLAG, &val, sizeof(val));
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
prvKey.id = vector->algId;
prvKey.key.mldsaPrv.data = CMVP_StringsToBins(vector->sk, &(prvKey.key.mldsaPrv.len));
ret = CRYPT_EAL_PkeySetPrv(*pkeyPrv, &prvKey);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
pubKey.id = vector->algId;
pubKey.key.mldsaPub.data = CMVP_StringsToBins(vector->pk, &(pubKey.key.mldsaPub.len));
ret = CRYPT_EAL_PkeySetPub(*pkeyPub, &pubKey);
ERR:
BSL_SAL_Free(prvKey.key.mldsaPrv.data);
BSL_SAL_Free(pubKey.key.mldsaPub.data);
return ret;
}
static int32_t TestVectorRandom(uint8_t *r, uint32_t rLen)
{
uint8_t *rand = NULL;
uint32_t randLen;
rand = CMVP_StringsToBins(MLDSA_SEED_VECTOR, &randLen);
if (rand == NULL) {
return CRYPT_MEM_ALLOC_FAIL;
}
if (randLen < rLen) {
BSL_SAL_Free(rand);
return CRYPT_CMVP_ERR_ALGO_SELFTEST;
}
for (uint32_t i = 0; i < randLen; i++) {
r[i] = rand[i];
}
BSL_SAL_Free(rand);
return 0;
}
static bool TestMldsaSignVerify(void *libCtx, const char *attrName, const CMVP_MldsaVector *vector)
{
bool ret = false;
uint8_t *sign = NULL;
uint8_t *signVec = NULL;
uint32_t signLen;
uint32_t signVecLen = 0;
uint8_t *msg = NULL;
uint32_t msgLen;
CRYPT_EAL_PkeyCtx *pkeyPrv = NULL;
CRYPT_EAL_PkeyCtx *pkeyPub = NULL;
CRYPT_EAL_RandFunc func = CRYPT_RandRegistGet();
CRYPT_EAL_RandFuncEx funcEx = CRYPT_RandRegistExGet();
CRYPT_RandRegistEx(NULL);
GOTO_ERR_IF_TRUE(
GetPkey(libCtx, attrName, vector, &pkeyPrv, &pkeyPub) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
signLen = CRYPT_EAL_PkeyGetSignLen(pkeyPrv);
sign = BSL_SAL_Malloc(signLen);
GOTO_ERR_IF_TRUE(sign == NULL, CRYPT_MEM_ALLOC_FAIL);
msg = CMVP_StringsToBins(vector->msg, &msgLen);
GOTO_ERR_IF_TRUE(msg == NULL, CRYPT_CMVP_COMMON_ERR);
signVec = CMVP_StringsToBins(vector->sig, &signVecLen);
GOTO_ERR_IF_TRUE(signVec == NULL, CRYPT_CMVP_COMMON_ERR);
// regist rand function
MLDSA_SEED_VECTOR = vector->rnd;
CRYPT_RandRegist(TestVectorRandom);
// sign
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySign(pkeyPrv, CRYPT_MD_MAX, msg, msgLen, sign, &signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
// compare the signature
GOTO_ERR_IF_TRUE(signLen != signVecLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(signVec, sign, signLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
// verify
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyVerify(pkeyPub, CRYPT_MD_MAX, msg, msgLen, sign, signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(sign);
BSL_SAL_Free(signVec);
BSL_SAL_Free(msg);
CRYPT_EAL_PkeyFreeCtx(pkeyPrv);
CRYPT_EAL_PkeyFreeCtx(pkeyPub);
CRYPT_RandRegist(func);
CRYPT_RandRegistEx(funcEx);
return ret;
}
bool CRYPT_CMVP_SelftestMldsaSignVerify(void)
{
bool ret = TestMldsaSignVerify(NULL, NULL, &MLDSA_VECTOR[0]);
return ret;
}
bool CRYPT_CMVP_SelftestProviderMldsaSignVerify(void *libCtx, const char *attrName)
{
return TestMldsaSignVerify(libCtx, attrName, &MLDSA_VECTOR[0]);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */ | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_mldsa.c | C | unknown | 24,761 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_rand.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_util_rand.h"
#include "securec.h"
#include "bsl_sal.h"
#define BITS_OF_BYTE 8
typedef struct {
const char *ek;
const char *dk;
const char *c;
const char *k;
const char *m;
int32_t algId;
int32_t type;
} CMVP_MlkemVector;
static const CMVP_MlkemVector MLKEM_VECTOR[] = {
{
// https://github.com/usnistgov/ACVP-Server/tree/master/gen-val/json-files/ML-KEM-encapDecap-FIPS203
.ek = "EDDBA9CB830474EC0111408243A97335494DDDFA8D5C6A344B0C9ED1061A7D4A840891C24E140BE6D7BDEE01571A1312D4000591F2224B850105878FD3966F537AC348D042B95785B8171F18647619072780C131BDAA462D34A039014012BBB2197A4328F89CC5B750CAD9495BE607D5017DFA105D87C830432795B42C5E89D8B536C087592829ED934822768A1824696A278952627CA2EA73CDA4A306F972B8521B6A7B28DD0AC44E6A8C46BA7291D48574F8356065AFBB073DF9B84B520673F6644D3959BAD576497E0BC846F560CE697C35493A995597F66315639A7B20B84105EAA48F3B4593A0BF12D64AD4CB043B6435D44A2F5E136F21621B88704DF8855C4F1689761A239DFA6874455D48251EB087865AC3825C275A1018B112F01E82D8698F684C8EE127D9D25FB92B180677A36930793DAB0306AAC8BC80A79885B0737C6B319600BB859966AB9F082490E31B669008CD055921CB2360667180611485E5D70E774401739B16F54601D4A600608119E4B3112AAC92D1C094E40318D4259044D16D3AD62B35170B54D16F0F850C593B2062CC3A769B4D28B6A776F981D4BC835612349292B748E30098D29C668A80F68718BF40B7E785CE41C094A7326F3E6992D99B80E64350C5395823B1315160582EC10B01A4337C52C355E98B857B2DF0006A0E8AB49F5BA23B8C7E329C20F91386852A8948751C0F301465D713E7857A7BD8B6076C059BE378F74BB257750F544A31874B79ABEA78F8647E77001506919AA467019E924B7BE53705A5C9411A8B513C8C51300849136E77919CF83CBA9EA1CD6004AA7178C8E7D062E5E13544E060B34984F61C2EB6B56580C45F67DA8982A97BD5BBA9D98462161A55357079C15A2A33992D4B66093DB03676D0C385DCC6DD3C18EC8138738AA0FD6058C9F721C5E3131D7828C9675048949D0CE32E92A3363EC0527F54C89B5140590822D9C96CB1BAA43A8CACCC085EA6FB602B871128AB2C8A2A1644623A1D7175CF4A23F4B497B7BB4D0B652EA4272D7A99A9A5F4C54EAA6482D0BFB4E46EE482B892895C78DCBAE4414543E0BF8AC4C82889BC6DDC385624AC7805CCC644BB430588AA19723AEE5999EF2AE2565C3BB3",
.dk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
.c = "387F23816CA3AAE900520559080374E6BFF44117D50D78EC4CB4A5C08A955DBBDFCBDE0803301BA3E40A9C33CAAE6DFA71EED311D9ECB84B497D3259B614DA30C71803288904D0E1B9EA8FB5750878602148E6FCE794B91E2778B07D87706E620B727162290CA7CE27DDEC5110770614175CE61A837CE46DA95D6AE7FBD9D4709636807EB67CC5992A643EABA2C253050C7B63CA6CA83617BCAF453AC3E24B9C3617038AA3A2FDC52A32EE7B2EC2B67E5F442BFB8D5429F079096FA7D5B9FBD81B096A75F2C9FAAD8E97DDC003EB88F55F482775BA7BD661BFCFC27D3A7C1071C5A7B020E80F6950BF315A040F4CF025A74B42DC008F4C084690F43E8502BFB740538BF3DF05336DDD6E33A3A4679A33C8A724125A8EC897A593741CA9C934CEEC2F20C82CCF439011C5066937377183C8CC96046985B92F6D014E0223EA542A8BA0A789478EB4B4F04AA98F7E6A4D4AC8852E8670B5A4097F7584FA136A159DAF5005D9FEF08868BFBFBE15D320AEAFFB3DE18C8F39A22A876D750AAD4F85546A88B0D0B498535B590B191894F43763BD13379BBD2CDEF4C98A571103E9409B2227315AB892990984FD6C9F375164959E3035B16C650CE71AFB62F7E3BFC624FACC973B104B44F6A2BCEEE1AACF0C3D8CE9ADDCEB26E3E786C116B70A3CF2C63524F472A2F15DBAB3FF8FDE34F015DD8DCFCBB17793A552E805AD5541ADFC6890B5E3A4DDBBC1CDB9B36D12DC49CA22CBB91F5BB599EF86DC4B5820B8E3D965839DFAA9392D29A878315BEA9A6885994C0D07843A4DC2FB87D0C8507CB17C549C3E60564D263221635F831C9F1F6539F07248E5BA8571541CF69151630161C0DBA57DA3A3C6296FEB02C19E2080F57C657CA74656B88B708450DA5DED44594B12614054D643FEB674E18FD3B863DE526EFB6D2426A58AE363658E8318578029DA3388D5A3C81E53E22F2802CBFD52760AF128EDAE7D1FC3379642FD8B9A791B289D7ECFC546158FBDCFBE1643B03B6874F3BA918849D93E5C0172E684C303D8D58CC5DE703A35FDB5796B81CD415B35DAEB60FCC043827401542FE35AD72375",
.k = "9A4E2BCC0E5E40528B4C2879D8BE4BF7AA266C16762480054B475814789EABCA",
.m = "381C547CE06B687A7A17C1A99D11A7A4C35B82685AF51CE452099C60136FD84A",
.algId = CRYPT_PKEY_ML_KEM,
.type = CRYPT_KEM_TYPE_MLKEM_512,
}
};
static const char *MLKEM_SEED_VECTOR = NULL;
static int32_t GetPkey(void *libCtx, const char *attrName, const CMVP_MlkemVector *vector, CRYPT_EAL_PkeyCtx **pkeyPrv,
CRYPT_EAL_PkeyCtx **pkeyPub)
{
int32_t ret = CRYPT_CMVP_ERR_ALGO_SELFTEST;
CRYPT_EAL_PkeyPrv prvKey = { 0 };
CRYPT_EAL_PkeyPub pubKey = { 0 };
*pkeyPrv = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, vector->algId, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPrv == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
*pkeyPub = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, vector->algId, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPub == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = CRYPT_EAL_PkeySetParaById(*pkeyPrv, vector->type);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
ret = CRYPT_EAL_PkeySetParaById(*pkeyPub, vector->type);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
prvKey.id = vector->algId;
prvKey.key.mldsaPrv.data = CMVP_StringsToBins(vector->dk, &(prvKey.key.kemDk.len));
ret = CRYPT_EAL_PkeySetPrv(*pkeyPrv, &prvKey);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
pubKey.id = vector->algId;
pubKey.key.mldsaPub.data = CMVP_StringsToBins(vector->ek, &(pubKey.key.kemEk.len));
ret = CRYPT_EAL_PkeySetPub(*pkeyPub, &pubKey);
ERR:
BSL_SAL_Free(prvKey.key.kemDk.data);
BSL_SAL_Free(pubKey.key.kemEk.data);
return ret;
}
static int32_t TestVectorRandom(uint8_t *r, uint32_t rLen)
{
uint8_t *rand = NULL;
uint32_t randLen;
rand = CMVP_StringsToBins(MLKEM_SEED_VECTOR, &randLen);
if (rand == NULL) {
return CRYPT_MEM_ALLOC_FAIL;
}
if (randLen < rLen) {
BSL_SAL_Free(rand);
return CRYPT_CMVP_ERR_ALGO_SELFTEST;
}
for (uint32_t i = 0; i < randLen; i++) {
r[i] = rand[i];
}
BSL_SAL_Free(rand);
return 0;
}
static bool TestMlkemEncapsDecaps(void *libCtx, const char *attrName, const CMVP_MlkemVector *vector)
{
bool ret = false;
uint8_t *cipher = NULL;
uint8_t *cipherVec = NULL;
uint32_t cipherLen = 0;
uint32_t cipherVecLen = 0;
CRYPT_EAL_PkeyCtx *pkeyPrv = NULL;
CRYPT_EAL_PkeyCtx *pkeyPub = NULL;
uint8_t sharedKey[32] = { 0 };
uint32_t sharedLen = sizeof(sharedKey);
uint8_t *sharedKeyVec = NULL;
uint32_t sharedKeyVecLen = 0;
CRYPT_EAL_RandFunc func = CRYPT_RandRegistGet();
CRYPT_EAL_RandFuncEx funcEx = CRYPT_RandRegistExGet();
CRYPT_RandRegistEx(NULL);
GOTO_ERR_IF_TRUE(
GetPkey(libCtx, attrName, vector, &pkeyPrv, &pkeyPub) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyCtrl(pkeyPrv, CRYPT_CTRL_GET_CIPHERTEXT_LEN, &cipherLen, sizeof(cipherLen)) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
cipher = BSL_SAL_Malloc(cipherLen);
GOTO_ERR_IF_TRUE(cipher == NULL, CRYPT_MEM_ALLOC_FAIL);
cipherVec = CMVP_StringsToBins(vector->c, &cipherVecLen);
GOTO_ERR_IF_TRUE(cipherVec == NULL, CRYPT_CMVP_COMMON_ERR);
sharedKeyVec = CMVP_StringsToBins(vector->k, &sharedKeyVecLen);
GOTO_ERR_IF_TRUE(sharedKeyVec == NULL, CRYPT_CMVP_COMMON_ERR);
// regist rand function
MLKEM_SEED_VECTOR = vector->m;
CRYPT_RandRegist(TestVectorRandom);
// encaps
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyEncaps(pkeyPub, cipher, &cipherLen, sharedKey, &sharedLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(cipherLen != cipherVecLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(cipher, cipherVec, cipherLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(sharedLen != sharedKeyVecLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(sharedKey, sharedKeyVec, sharedLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
// decaps
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyDecaps(pkeyPrv, cipherVec, cipherVecLen, sharedKey, &sharedLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(sharedLen != sharedKeyVecLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(sharedKey, sharedKeyVec, sharedLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(cipher);
BSL_SAL_Free(cipherVec);
BSL_SAL_Free(sharedKeyVec);
CRYPT_EAL_PkeyFreeCtx(pkeyPrv);
CRYPT_EAL_PkeyFreeCtx(pkeyPub);
CRYPT_RandRegist(func);
CRYPT_RandRegistEx(funcEx);
return ret;
}
bool CRYPT_CMVP_SelftestMlkemEncapsDecaps(void)
{
bool ret = TestMlkemEncapsDecaps(NULL, NULL, &MLKEM_VECTOR[0]);
return ret;
}
bool CRYPT_CMVP_SelftestProviderMlkemEncapsDecaps(void *libCtx, const char *attrName)
{
return TestMlkemEncapsDecaps(libCtx, attrName, &MLKEM_VECTOR[0]);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */ | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_mlkem.c | C | unknown | 12,690 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_kdf.h"
#include "bsl_err_internal.h"
#include "crypt_params_key.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
typedef struct {
const char *pw;
const char *salt;
uint32_t iter;
const char *key;
CRYPT_MAC_AlgId id;
} CMVP_PBKDF2_VECTOR;
// https://www.ietf.org/rfc/rfc6070.txt
static const CMVP_PBKDF2_VECTOR PBKDF2_VECTOR[] = {
{
.pw = "passwordPASSWORDpassword",
.salt = "saltSALTsaltSALTsaltSALTsaltSALTsalt",
.iter = 4096,
.key = "3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038",
.id = CRYPT_MAC_HMAC_SHA1
},
{
.pw = "passwordPASSWORDpassword",
.salt = "saltSALTsaltSALTsaltSALTsaltSALTsalt",
.iter = 1024,
.key = "1e0d8ab1b32bb96dff58ff89ab171e643a425fd87f26261b56f9d38c992f2593a713f9c1772f8bf2",
.id = CRYPT_MAC_HMAC_SM3
},
};
static const CMVP_PBKDF2_VECTOR *FindVectorById(CRYPT_MAC_AlgId id)
{
const CMVP_PBKDF2_VECTOR *pPbkdf2Vec = NULL;
uint32_t num = sizeof(PBKDF2_VECTOR) / sizeof(PBKDF2_VECTOR[0]);
for (uint32_t i = 0; i < num; i++) {
if (PBKDF2_VECTOR[i].id == id) {
pPbkdf2Vec = &PBKDF2_VECTOR[i];
return pPbkdf2Vec;
}
}
return NULL;
}
static bool CRYPT_CMVP_SelftestPbkdf2Internal(void *libCtx, const char *attrName, CRYPT_MAC_AlgId id)
{
(void)id;
bool ret = false;
const char *pw = NULL;
const char *salt = NULL;
uint8_t *expOut = NULL;
uint8_t *out = NULL;
uint32_t expOutLen, pwLen, saltLen, iter;
CRYPT_EAL_KdfCTX *ctx = NULL;
const CMVP_PBKDF2_VECTOR *pbkdf2Vec = FindVectorById(id);
if (pbkdf2Vec == NULL || pbkdf2Vec->pw == NULL) {
return false;
}
iter = pbkdf2Vec->iter;
pw = pbkdf2Vec->pw;
pwLen = (uint32_t)strlen(pbkdf2Vec->pw);
salt = pbkdf2Vec->salt;
saltLen = (uint32_t)strlen(pbkdf2Vec->salt);
expOut = CMVP_StringsToBins(pbkdf2Vec->key, &expOutLen);
GOTO_ERR_IF_TRUE(expOut == NULL, CRYPT_CMVP_COMMON_ERR);
out = BSL_SAL_Malloc(expOutLen);
GOTO_ERR_IF_TRUE(out == NULL, CRYPT_MEM_ALLOC_FAIL);
ctx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_PBKDF2, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
BSL_Param param[5] = {
{CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32, &id, sizeof(id), 0},
{CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS, (void *)(uintptr_t)pw, pwLen, 0},
{CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS, (void *)(uintptr_t)salt, saltLen, 0},
{CRYPT_PARAM_KDF_ITER, BSL_PARAM_TYPE_UINT32, &iter, sizeof(uint32_t), 0},
BSL_PARAM_END
};
GOTO_ERR_IF_TRUE(CRYPT_EAL_KdfSetParam(ctx, param) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_KdfDerive(ctx, out, expOutLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(out, expOut, expOutLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(expOut);
BSL_SAL_Free(out);
CRYPT_EAL_KdfFreeCtx(ctx);
return ret;
}
bool CRYPT_CMVP_SelftestPbkdf2(CRYPT_MAC_AlgId id)
{
return CRYPT_CMVP_SelftestPbkdf2Internal(NULL, NULL, id);
}
bool CRYPT_CMVP_SelftestProviderPbkdf2(void *libCtx, const char *attrName, CRYPT_MAC_AlgId id)
{
return CRYPT_CMVP_SelftestPbkdf2Internal(libCtx, attrName, id);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_pbkdf2.c | C | unknown | 4,260 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "crypt_utils.h"
#include "crypt_dsa.h"
#include "crypt_ecdsa.h"
#include "crypt_curve25519.h"
#include "crypt_rsa.h"
#include "crypt_sm2.h"
#include "crypt_mldsa.h"
#include "crypt_mlkem.h"
#include "crypt_eal_implprovider.h"
#include "crypt_slh_dsa.h"
#ifdef HITLS_CRYPTO_MLKEM
static bool CMVP_MlkemPct(void *ctx)
{
bool ret = false;
uint32_t cipherLen = 0;
uint8_t *ciphertext = NULL;
uint8_t sharedKey[32] = {0};
uint32_t sharedLen = sizeof(sharedKey);
uint8_t sharedKey2[32] = {0};
uint32_t sharedLen2 = sizeof(sharedKey2);
GOTO_ERR_IF_TRUE(CRYPT_ML_KEM_Ctrl(ctx, CRYPT_CTRL_GET_CIPHERTEXT_LEN, &cipherLen,
sizeof(cipherLen)) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ciphertext = BSL_SAL_Malloc(cipherLen);
GOTO_ERR_IF_TRUE(ciphertext == NULL, CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_TRUE(CRYPT_ML_KEM_Encaps(ctx, ciphertext, &cipherLen, sharedKey, &sharedLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_ML_KEM_Decaps(ctx, ciphertext, cipherLen, sharedKey2, &sharedLen2) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(sharedLen != sharedLen2 || memcmp(sharedKey, sharedKey2, sharedLen) != 0,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(ciphertext);
return ret;
}
#endif
typedef struct {
int32_t id;
CRYPT_EAL_ImplPkeySign sign;
CRYPT_EAL_ImplPkeyVerify verify;
CRYPT_EAL_ImplPkeyMgmtCtrl ctrl;
} PkeyMethodMap;
static const PkeyMethodMap pkey_map[] = {
#ifdef HITLS_CRYPTO_DSA
{CRYPT_PKEY_DSA, (CRYPT_EAL_ImplPkeySign)CRYPT_DSA_Sign,
(CRYPT_EAL_ImplPkeyVerify)CRYPT_DSA_Verify, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_DSA_Ctrl},
#endif
#ifdef HITLS_CRYPTO_ED25519
{CRYPT_PKEY_ED25519, (CRYPT_EAL_ImplPkeySign)CRYPT_CURVE25519_Sign,
(CRYPT_EAL_ImplPkeyVerify)CRYPT_CURVE25519_Verify, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_CURVE25519_Ctrl},
#endif
#ifdef HITLS_CRYPTO_RSA
{CRYPT_PKEY_RSA, (CRYPT_EAL_ImplPkeySign)CRYPT_RSA_Sign,
(CRYPT_EAL_ImplPkeyVerify)CRYPT_RSA_Verify, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_RSA_Ctrl},
#endif
#ifdef HITLS_CRYPTO_ECDSA
{CRYPT_PKEY_ECDSA, (CRYPT_EAL_ImplPkeySign)CRYPT_ECDSA_Sign,
(CRYPT_EAL_ImplPkeyVerify)CRYPT_ECDSA_Verify, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_ECDSA_Ctrl},
#endif
#ifdef HITLS_CRYPTO_SM2
{CRYPT_PKEY_SM2, (CRYPT_EAL_ImplPkeySign)CRYPT_SM2_Sign,
(CRYPT_EAL_ImplPkeyVerify)CRYPT_SM2_Verify, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_SM2_Ctrl},
#endif
#ifdef HITLS_CRYPTO_SLH_DSA
{CRYPT_PKEY_SLH_DSA, (CRYPT_EAL_ImplPkeySign)CRYPT_SLH_DSA_Sign,
(CRYPT_EAL_ImplPkeyVerify)CRYPT_SLH_DSA_Verify, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_SLH_DSA_Ctrl},
#endif
#ifdef HITLS_CRYPTO_MLDSA
{CRYPT_PKEY_ML_DSA, (CRYPT_EAL_ImplPkeySign)CRYPT_ML_DSA_Sign,
(CRYPT_EAL_ImplPkeyVerify)CRYPT_ML_DSA_Verify, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_ML_DSA_Ctrl},
#endif
{CRYPT_PKEY_MAX, NULL, NULL, NULL}
};
static bool CMVP_SignVerifyPct(void *ctx, int32_t algId)
{
bool ret = false;
uint8_t *sign = NULL;
uint32_t signLen = 0;
const uint8_t msg[] = {0x01, 0x02, 0x03, 0x04};
uint32_t mdId = CRYPT_MD_SHA512;
const PkeyMethodMap *map = NULL;
for (uint32_t i = 0; i < sizeof(pkey_map) / sizeof(pkey_map[0]); i++) {
if (algId == pkey_map[i].id) {
map = &pkey_map[i];
break;
}
}
GOTO_ERR_IF_TRUE(map == NULL, CRYPT_EAL_ERR_ALGID);
GOTO_ERR_IF_TRUE(map->ctrl(ctx, CRYPT_CTRL_GET_SIGNLEN, &signLen, sizeof(signLen)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
sign = BSL_SAL_Malloc(signLen);
GOTO_ERR_IF_TRUE(sign == NULL, CRYPT_MEM_ALLOC_FAIL);
if (algId == CRYPT_PKEY_RSA) {
GOTO_ERR_IF_TRUE(map->ctrl(ctx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &mdId, sizeof(mdId)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
GOTO_ERR_IF_TRUE(map->sign(ctx, algId == CRYPT_PKEY_SM2 ? CRYPT_MD_SM3 : CRYPT_MD_SHA512, msg, sizeof(msg),
sign, &signLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(map->verify(ctx, algId == CRYPT_PKEY_SM2 ? CRYPT_MD_SM3 : CRYPT_MD_SHA512, msg, sizeof(msg),
sign, signLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(sign);
return ret;
}
bool CRYPT_CMVP_SelftestPkeyPct(void *ctx, int32_t algId)
{
if (algId == CRYPT_PKEY_DH || algId == CRYPT_PKEY_ECDH || algId == CRYPT_PKEY_X25519) {
return true;
}
#ifdef HITLS_CRYPTO_MLKEM
if (algId == CRYPT_PKEY_ML_KEM) {
return CMVP_MlkemPct(ctx);
}
#endif
return CMVP_SignVerifyPct(ctx, algId);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_pct.c | C | unknown | 5,574 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "bsl_err_internal.h"
#include "crypt_params_key.h"
#include "crypt_utils.h"
#include "crypt_eal_rand.h"
#include "crypt_util_rand.h"
#include "securec.h"
#include "bsl_sal.h"
#define PKCSV15_PAD 0
#define PSS_PAD 1
#define OAEP_PAD 2
#define MAX_CIPHER_TEXT_LEN 512
typedef struct {
const char *n;
const char *e;
const char *d;
const char *salt;
const char *msg;
const char *sign;
CRYPT_MD_AlgId mdId;
} CMVP_RSA_VECTOR;
// 与CRYPT_EAL_PkeyPadId顺序一致
static const CMVP_RSA_VECTOR RSA_VECTOR[] = {
// RSA-2048bits-SHA224 PKCS#1 Ver 1.5
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Digital-Signatures#rsa2vs
{
.n = "e0b14b99cd61cd3db9c2076668841324fa3174f33ce66ffd514394d34178d29a49493276b6777233"
"e7d46a3e68bc7ca7e899e901d54f6dee0749c3e48ddf68685867ee2ae66df88eb563f6db137a9f6b"
"175a112e0eda8368e88e45efe1ce14bc6016d52639627066af1872c72f60b9161c1d237eeb34b0f8"
"41b3f0896f9fe0e16b0f74352d101292cc464a7e7861bbeb86f6df6151cb265417c66c565ed8974b"
"d8fc984d5ddfd4eb91a3d5234ce1b5467f3ade375f802ec07293f1236efa3068bc91b158551c875c"
"5dc0a9d6fa321bf9421f08deac910e35c1c28549ee8eed8330cf70595ff70b94b49907e27698a9d9"
"11f7ac0706afcb1a4a39feb38b0a8049",
.e = "00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000010001",
.d = "1dbca92e4245c2d57bfba76210cc06029b502753b7c821a32b799fbd33c98b49db10226b1eac0143"
"c8574ef652833b96374d034ef84daa5559c693f3f028d49716b82e87a3f682f25424563bd9409dcf"
"9d08110500f73f74076f28e75e0199b1f29fa2f70b9a31190dec54e872a740e7a1b1e38c3d11bca8"
"267deb842cef4262237ac875725068f32563b478aca8d6a99f34cb8876b97145b2e8529ec8adea83"
"ead4ec63e3ff2d17a2ffefb05c902ca7a92168378c89f75c928fc4f0707e43487a4f47df70cae87e"
"24272c136d3e98cf59066d41a3d038857d073d8b4d2c27b8f0ea6bfa50d263091a4a18c63f446bc9"
"a61e8c4a688347b2435ec8e72eddaea7",
.salt = NULL,
.msg = "79bcffbfd6bcf638934b38e47a1b821dc97cafe1da757f820313989ebc01ca52ff5997abf5baf35d"
"ce9b48b8f0debdd755a8b81b2e71a1d8cd57ea4dc1b84cda43ff536dd1be1c3e18fe5ebc17d3a7c6"
"8233e81f6407341c0983c5a01bb3404a0b5739edb2f1fa41391c80d8361fc75317c248d5c461bfb8"
"803e317f101b2e0c",
.sign = "5cbc1d2c696e7c5c0a538db35a793959008564c43d9aa8ed20816b66ef77124eca7584631308d0fd"
"7383be62eaf799b5e67e8874cc9d88d507e1bd4fb9fd7517adebe5d583b075040ce3db2affcf77ee"
"0162be2e575413f455841cb6ea4a30595daee45e3042b0b9d8f9ee700df3f1898219777c21ef3695"
"af95628ae64260dd2cb7ee6270fb06f52ea1aea72e1a26a26f2e7cee560ae0cb8be323113c3f19c9"
"7cb5a3e61b998a68432aa2d1f8c8c00ac92b0f35344710ae1d6d79f379fbb3dba41b46b9c814eb3a"
"25ca64a3ff86af613d163f941a897676652e7c3f6769fd964b862dc58cc2e652d0a404e94853fb83"
"937c862c1df2df9fd297f058bf660d15",
.mdId = CRYPT_MD_SHA224
},
// RSA-2048bits-SHA224 PKCS#1 RSASSA-PSS
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Digital-Signatures#rsa2vs
{
.n = "d95b71c9dfee453ba1b1a7de2c1f0b0a67579ee91d1d3ad97e481829b86edac750c48e12a8cdb026"
"c82f273dafc222009f0db3b08b2db10a69c4b2dddaaeceac1b0c862682eef294e579f55aab871bc0"
"a7eeabc923c9e80dddc22ec0a27002aee6a5ba66397f412bbaf5fb4eaf66a1a0f82eaf6827198caf"
"49b347258b1283e8cbb10da2837f6ecc3490c728fe927f44455a6f194f3776bf79151d9ad7e2daf7"
"70b37d12627cc0c5fb62484f46258d9ce2c11b26256d09cb412f8d8f8f1fe91bb94ac27de6d26a83"
"a8439e51b35dbee46b3b8ff991d667bb53eeee85ff1652c8981f141d47c8205791cef5b32d718ddc"
"082ed0dd542826416b2271064ef437a9",
.e = "00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000010001",
.d = "2f21b01be94dde7f5ec18a3817f3274ebb37f9c26cc8c0d1169c05794e7fe33ae31dabfd09d38845"
"f094a0fab458f14c9730be6d22d0e699ee7373a1bde0b7fa03e784536782eee1309d708197be355b"
"624ed3bb4ae2664a5372def67082bf6233ab6e2eea7ad8a3e5e79ef5e1fcec415e6fa923798f05bd"
"a0ca9a3bdedb45f4d781ef1a4f5075cd9bb399635da3e9a6880ed021a750bc9806af81fbffcd4ace"
"af804ec76808ae186715c772caa961a862991c67ca8bffef6b34087b44db5b59abce09317747fc75"
"252f1705260b13dd62ccbc745091f3c1b64f59031d340c7362a0e1066ab0554d466f209a3cf51bc6"
"4b3c70c3ce52f413d81b228fa31d9efd",
.salt = "6f2841166a64471d4f0b8ed0dbb7db32161da13b",
.msg = "e2b81456c355c3f80a363a85cbf245e85a5ff2435e5548d627b5362242aaca4e4a2fa4c900d2a931"
"9eb7fc7469df2a3586aaa4710e9b7362655c27a3c70210962391b1032dc37201af05951a1fc36baa"
"77e5c888419ab4e8f1546380781468ea16e7254a70b08630e229efc016257210d61846d11ed87432"
"76a5d4017e683813",
.sign = "cd1fe0acb89969ae139c178bfef1cc982993521b3a020ec847c89c0cc6c869d970f43f018d495b9e"
"991457e7501a344c33c376fd2efcf05ad6eb2bd0b3c0e7cc3c88a4124398ca16585490a0817a3614"
"9cc82cdc01b20e9026261215dd06f9db4e13613c6a569c2187a0e00bc63c281149433ac7f061bd21"
"8e79f8eca9dd9c93ebc3cc013bf27aa0bf286e124593e76d3c7012f97ae1d0c4bf5823cf17fe76d5"
"05a54cef174add58ae616f47de825049e9916bf2ab7de4d443745763b0c314cfae3a6e57ad475cc5"
"fae47cddcad7b526c2154a15f9ee8eab02f4c36f7a41d7a19b23c5996b627270ceb2c0dbed1a6b6d"
"d2ff94868e073cb7b1a1fa3429e487ae",
.mdId = CRYPT_MD_SHA224
},
};
typedef struct {
const char *n;
const char *e;
const char *d;
const char *seed;
const char *msg;
const char *cipher;
CRYPT_MD_AlgId mdId;
} CMVP_RSA_ENC_DEC_VECTOR;
// Test vectors sourced from the pyca/cryptography project.
static const CMVP_RSA_ENC_DEC_VECTOR RSA_ENC_DEC_VECTOR = {
.n = "ae45ed5601cec6b8cc05f803935c674ddbe0d75c4c09fd7951fc6b0caec313a8"
"df39970c518bffba5ed68f3f0d7f22a4029d413f1ae07e4ebe9e4177ce23e7f5"
"404b569e4ee1bdcf3c1fb03ef113802d4f855eb9b5134b5a7c8085adcae6fa2f"
"a1417ec3763be171b0c62b760ede23c12ad92b980884c641f5a8fac26bdad4a0"
"3381a22fe1b754885094c82506d4019a535a286afeb271bb9ba592de18dcf600"
"c2aeeae56e02f7cf79fc14cf3bdc7cd84febbbf950ca90304b2219a7aa063aef"
"a2c3c1980e560cd64afe779585b6107657b957857efde6010988ab7de417fc88"
"d8f384c4e6e72c3f943e0c31c0c4a5cc36f879d8a3ac9d7d59860eaada6b83bb",
.e = "010001",
.d = "056b04216fe5f354ac77250a4b6b0c8525a85c59b0bd80c56450a22d5f438e59"
"6a333aa875e291dd43f48cb88b9d5fc0d499f9fcd1c397f9afc070cd9e398c8d"
"19e61db7c7410a6b2675dfbf5d345b804d201add502d5ce2dfcb091ce9997bbe"
"be57306f383e4d588103f036f7e85d1934d152a323e4a8db451d6f4a5b1b0f10"
"2cc150e02feee2b88dea4ad4c1baccb24d84072d14e1d24a6771f7408ee30564"
"fb86d4393a34bcf0b788501d193303f13a2284b001f0f649eaf79328d4ac5c43"
"0ab4414920a9460ed1b7bc40ec653e876d09abc509ae45b525190116a0c26101"
"848298509c1c3bf3a483e7274054e15e97075036e989f60932807b5257751e79",
.msg = "8bba6bf82a6c0f86d5f1756e97956870b08953b06b4eb205bc1694ee",
.seed = "47e1ab7119fee56c95ee5eaad86f40d0aa63bd33",
.cipher = "53ea5dc08cd260fb3b858567287fa91552c30b2febfba213f0ae87702d068d19"
"bab07fe574523dfb42139d68c3c5afeee0bfe4cb7969cbf382b804d6e6139614"
"4e2d0e60741f8993c3014b58b9b1957a8babcd23af854f4c356fb1662aa72bfc"
"c7e586559dc4280d160c126785a723ebeebeff71f11594440aaef87d10793a87"
"74a239d4a04c87fe1467b9daf85208ec6c7255794a96cc29142f9a8bd418e3c1"
"fd67344b0cd0829df3b2bec60253196293c6b34d3f75d32f213dd45c6273d505"
"adf4cced1057cb758fc26aeefa441255ed4e64c199ee075e7f16646182fdb464"
"739b68ab5daff0e63e9552016824f054bf4d3c8c90a97bb6b6553284eb429fcc",
.mdId = CRYPT_MD_SHA1,
};
static bool GetPrvKey(const char *n, const char *d, CRYPT_EAL_PkeyPrv *prv)
{
(void)memset_s(&prv->key.rsaPrv, sizeof(prv->key.rsaPrv), 0, sizeof(prv->key.rsaPrv));
prv->key.rsaPrv.n = CMVP_StringsToBins(n, &(prv->key.rsaPrv.nLen));
GOTO_ERR_IF_TRUE(prv->key.rsaPrv.n == NULL, CRYPT_CMVP_COMMON_ERR);
prv->key.rsaPrv.d = CMVP_StringsToBins(d, &(prv->key.rsaPrv.dLen));
GOTO_ERR_IF_TRUE(prv->key.rsaPrv.d == NULL, CRYPT_CMVP_COMMON_ERR);
prv->id = CRYPT_PKEY_RSA;
return true;
ERR:
return false;
}
static bool GetPubKey(const char *n, const char *e, CRYPT_EAL_PkeyPub *pub)
{
pub->key.rsaPub.n = CMVP_StringsToBins(n, &(pub->key.rsaPub.nLen));
GOTO_ERR_IF_TRUE(pub->key.rsaPub.n == NULL, CRYPT_CMVP_COMMON_ERR);
pub->key.rsaPub.e = CMVP_StringsToBins(e, &(pub->key.rsaPub.eLen));
GOTO_ERR_IF_TRUE(pub->key.rsaPub.e == NULL, CRYPT_CMVP_COMMON_ERR);
pub->id = CRYPT_PKEY_RSA;
return true;
ERR:
return false;
}
static bool SetPkcsv15Pad(CRYPT_EAL_PkeyCtx *pkey, uint32_t *hashId)
{
*hashId = RSA_VECTOR[PKCSV15_PAD].mdId;
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, hashId, sizeof(uint32_t)) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
return true;
ERR:
return false;
}
static bool SetPssPad(CRYPT_EAL_PkeyCtx *pkey, uint32_t saltLen)
{
uint32_t mdId = RSA_VECTOR[PSS_PAD].mdId;
uint32_t mgfId = RSA_VECTOR[PSS_PAD].mdId;
BSL_Param pss[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, (void *)(uintptr_t)&mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, (void *)(uintptr_t)&mgfId, sizeof(mgfId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, (void *)(uintptr_t)&saltLen, sizeof(saltLen), 0},
BSL_PARAM_END
};
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PSS, pss, 0) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
return true;
ERR:
return false;
}
static bool RsaSelftestSign(void *libCtx, const char *attrName, int32_t id)
{
bool ret = false;
uint8_t *salt = NULL;
uint32_t pkcsv15;
CRYPT_EAL_PkeyPrv prv = { 0 };
CRYPT_EAL_PkeyCtx *pkey = NULL;
uint8_t *msg = NULL;
uint8_t *expectSign = NULL;
uint8_t *sign = NULL;
uint32_t msgLen, expectSignLen, signLen, saltLen;
msg = CMVP_StringsToBins(RSA_VECTOR[id].msg, &msgLen);
GOTO_ERR_IF_TRUE(msg == NULL, CRYPT_CMVP_COMMON_ERR);
expectSign = CMVP_StringsToBins(RSA_VECTOR[id].sign, &expectSignLen);
GOTO_ERR_IF_TRUE(expectSign == NULL, CRYPT_CMVP_COMMON_ERR);
pkey = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_RSA, 0, attrName);
GOTO_ERR_IF_TRUE(pkey == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(GetPrvKey(RSA_VECTOR[id].n, RSA_VECTOR[id].d, &prv) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(pkey, &prv) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
signLen = CRYPT_EAL_PkeyGetSignLen(pkey);
sign = BSL_SAL_Malloc(sizeof(uint32_t) * signLen);
GOTO_ERR_IF_TRUE(sign == NULL, CRYPT_MEM_ALLOC_FAIL);
if (id == PKCSV15_PAD) {
GOTO_ERR_IF_TRUE(!SetPkcsv15Pad(pkey, &pkcsv15), CRYPT_CMVP_ERR_ALGO_SELFTEST);
} else {
salt = CMVP_StringsToBins(RSA_VECTOR[PSS_PAD].salt, &(saltLen));
GOTO_ERR_IF_TRUE(salt == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(!SetPssPad(pkey, saltLen), CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_SALT, salt, saltLen) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySign(pkey, RSA_VECTOR[id].mdId, msg, msgLen, sign, &signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(signLen != expectSignLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(expectSign, sign, signLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(salt);
BSL_SAL_Free(msg);
BSL_SAL_Free(sign);
BSL_SAL_Free(expectSign);
BSL_SAL_Free(prv.key.rsaPrv.n);
BSL_SAL_Free(prv.key.rsaPrv.d);
CRYPT_EAL_PkeyFreeCtx(pkey);
return ret;
}
static bool RsaSelftestVerify(void *libCtx, const char *attrName, int32_t id)
{
bool ret = false;
uint8_t *salt = NULL;
uint32_t mdId;
CRYPT_EAL_PkeyPub pub = { 0 };
uint8_t *msg = NULL;
uint8_t *sign = NULL;
uint32_t signLen, msgLen, saltLen;
CRYPT_EAL_PkeyCtx *pkey = NULL;
msg = CMVP_StringsToBins(RSA_VECTOR[id].msg, &msgLen);
GOTO_ERR_IF_TRUE(msg == NULL, CRYPT_CMVP_COMMON_ERR);
sign = CMVP_StringsToBins(RSA_VECTOR[id].sign, &signLen);
GOTO_ERR_IF_TRUE(sign == NULL, CRYPT_CMVP_COMMON_ERR);
pkey = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_RSA, 0, attrName);
GOTO_ERR_IF_TRUE(pkey == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(GetPubKey(RSA_VECTOR[id].n, RSA_VECTOR[id].e, &pub) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(pkey, &pub) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
if (id == PKCSV15_PAD) {
GOTO_ERR_IF_TRUE(!SetPkcsv15Pad(pkey, &mdId), CRYPT_CMVP_ERR_ALGO_SELFTEST);
} else {
salt = CMVP_StringsToBins(RSA_VECTOR[PSS_PAD].salt, &(saltLen));
GOTO_ERR_IF_TRUE(salt == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(!SetPssPad(pkey, saltLen), CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyVerify(pkey, RSA_VECTOR[id].mdId, msg, msgLen, sign, signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(salt);
BSL_SAL_Free(msg);
BSL_SAL_Free(sign);
BSL_SAL_Free(pub.key.rsaPub.n);
BSL_SAL_Free(pub.key.rsaPub.e);
CRYPT_EAL_PkeyFreeCtx(pkey);
return ret;
}
static int32_t SetRandomVector(const char *vector, uint8_t *r, uint32_t rLen)
{
uint8_t *rand = NULL;
uint32_t randLen;
rand = CMVP_StringsToBins(vector, &randLen);
if (rand == NULL) {
return CRYPT_MEM_ALLOC_FAIL;
}
if (randLen < rLen) {
BSL_SAL_FREE(rand);
return CRYPT_CMVP_ERR_ALGO_SELFTEST;
}
(void)memcpy_s(r, rLen, rand, rLen);
BSL_SAL_FREE(rand);
return CRYPT_SUCCESS;
}
static int32_t TestVectorRandom(uint8_t *r, uint32_t rLen)
{
return SetRandomVector(RSA_ENC_DEC_VECTOR.seed, r, rLen);
}
static bool RsaSelftestEncrypt(void *libCtx, const char *attrName, const uint8_t *plain, const uint32_t plainLen,
const uint8_t *cipher, const uint32_t cipherLen)
{
bool ret = false;
CRYPT_EAL_PkeyCtx *pubCtx = NULL;
CRYPT_EAL_PkeyPub pub = { 0 };
uint8_t cipherText[MAX_CIPHER_TEXT_LEN] = {0};
uint32_t cipherTextLen = sizeof(cipherText);
int32_t err = CRYPT_CMVP_ERR_ALGO_SELFTEST;
uint32_t mdId = RSA_ENC_DEC_VECTOR.mdId;
BSL_Param oaep[3] = {{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
BSL_PARAM_END
};
CRYPT_EAL_RandFunc func = CRYPT_RandRegistGet();
CRYPT_EAL_RandFuncEx funcEx = CRYPT_RandRegistExGet();
CRYPT_RandRegistEx(NULL);
CRYPT_RandRegist(TestVectorRandom);
// encrypt
pubCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_RSA, 0, attrName);
GOTO_ERR_IF_TRUE(pubCtx == NULL, err);
GOTO_ERR_IF_TRUE(GetPubKey(RSA_ENC_DEC_VECTOR.n, RSA_ENC_DEC_VECTOR.e, &pub) != true, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(pubCtx, &pub) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyCtrl(pubCtx, CRYPT_CTRL_SET_RSA_RSAES_OAEP, oaep, 0) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyEncrypt(pubCtx, plain, plainLen, cipherText, &cipherTextLen) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(cipherTextLen != cipherLen, err);
GOTO_ERR_IF_TRUE(memcmp(cipher, cipherText, cipherTextLen) != 0, err);
ret = true;
ERR:
CRYPT_RandRegist(func);
CRYPT_RandRegistEx(funcEx);
CRYPT_EAL_PkeyFreeCtx(pubCtx);
BSL_SAL_Free(pub.key.rsaPub.n);
BSL_SAL_Free(pub.key.rsaPub.e);
return ret;
}
static bool RsaSelftestDecrypt(void *libCtx, const char *attrName, const uint8_t *cipher, const uint32_t cipherLen,
const uint8_t *plain, const uint32_t plainLen)
{
bool ret = false;
CRYPT_EAL_PkeyCtx *prvCtx = NULL;
CRYPT_EAL_PkeyPrv prv = { 0 };
uint8_t plainText[MAX_CIPHER_TEXT_LEN] = {0};
uint32_t plainTextLen = sizeof(plainText);
int32_t err = CRYPT_CMVP_ERR_ALGO_SELFTEST;
uint32_t mdId = RSA_ENC_DEC_VECTOR.mdId;
BSL_Param oaep[3] = {{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
BSL_PARAM_END
};
// decrypt
prvCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_RSA, 0, attrName);
GOTO_ERR_IF_TRUE(prvCtx == NULL, err);
GOTO_ERR_IF_TRUE(GetPrvKey(RSA_ENC_DEC_VECTOR.n, RSA_ENC_DEC_VECTOR.d, &prv) != true, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(prvCtx, &prv) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyCtrl(prvCtx, CRYPT_CTRL_SET_RSA_RSAES_OAEP, oaep, 0) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(
CRYPT_EAL_PkeyDecrypt(prvCtx, cipher, cipherLen, plainText, &plainTextLen) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(plainTextLen != plainLen, err);
GOTO_ERR_IF_TRUE(memcmp(plain, plainText, plainTextLen) != 0, err);
ret = true;
ERR:
CRYPT_EAL_PkeyFreeCtx(prvCtx);
BSL_SAL_Free(prv.key.rsaPrv.n);
BSL_SAL_Free(prv.key.rsaPrv.d);
return ret;
}
static bool RsaSelftestEncryptDecrypt(void *libCtx, const char *attrName)
{
bool ret = false;
uint8_t *plain = NULL;
uint32_t plainLen;
uint8_t *cipher = NULL;
uint32_t cipherLen;
plain = CMVP_StringsToBins(RSA_ENC_DEC_VECTOR.msg, &plainLen);
GOTO_ERR_IF_TRUE(plain == NULL, CRYPT_CMVP_COMMON_ERR);
cipher = CMVP_StringsToBins(RSA_ENC_DEC_VECTOR.cipher, &cipherLen);
GOTO_ERR_IF_TRUE(cipher == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(
RsaSelftestEncrypt(libCtx, attrName, plain, plainLen, cipher, cipherLen) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(
RsaSelftestDecrypt(libCtx, attrName, cipher, cipherLen, plain, plainLen) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(plain);
BSL_SAL_Free(cipher);
return ret;
}
bool CRYPT_CMVP_SelftestProviderRsa(void *libCtx, const char *attrName)
{
GOTO_ERR_IF_TRUE(RsaSelftestSign(libCtx, attrName, PKCSV15_PAD) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(RsaSelftestVerify(libCtx, attrName, PKCSV15_PAD) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(RsaSelftestSign(libCtx, attrName, PSS_PAD) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(RsaSelftestVerify(libCtx, attrName, PSS_PAD) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(RsaSelftestEncryptDecrypt(libCtx, attrName) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
return true;
ERR:
return false;
}
bool CRYPT_CMVP_SelftestRsa(void)
{
GOTO_ERR_IF_TRUE(RsaSelftestSign(NULL, NULL, PKCSV15_PAD) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(RsaSelftestVerify(NULL, NULL, PKCSV15_PAD) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(RsaSelftestSign(NULL, NULL, PSS_PAD) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(RsaSelftestVerify(NULL, NULL, PSS_PAD) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(RsaSelftestEncryptDecrypt(NULL, NULL) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
return true;
ERR:
return false;
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_rsa.c | C | unknown | 21,532 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_kdf.h"
#include "crypt_params_key.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
typedef struct {
const char *pw;
const char *salt;
uint32_t n;
uint32_t r;
uint32_t p;
const char *key;
} CMVP_SCRYPT_VECTOR;
// https://datatracker.ietf.org/doc/html/rfc7914#page-13
static const CMVP_SCRYPT_VECTOR SCRYPT_VECTOR = {
.pw = "70617373776f7264",
.salt = "4e61436c",
.n = 1024,
.r = 8,
.p = 16,
.key = "fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e77376634b3731622eaf30d92e22a388"
"6ff109279d9830dac727afb94a83ee6d8360cbdfa2cc0640"
};
static bool CRYPT_CMVP_SelftestScryptInternal(void *libCtx, const char *attrName)
{
bool ret = false;
uint8_t *pw = NULL;
uint8_t *salt = NULL;
uint8_t *key = NULL;
uint8_t *expkey = NULL;
uint32_t pwLen, saltLen, expkeyLen;
uint32_t n = SCRYPT_VECTOR.n;
uint32_t r = SCRYPT_VECTOR.r;
uint32_t p = SCRYPT_VECTOR.p;
CRYPT_EAL_KdfCTX *ctx = NULL;
pw = CMVP_StringsToBins(SCRYPT_VECTOR.pw, &pwLen);
GOTO_ERR_IF_TRUE(pw == NULL, CRYPT_CMVP_COMMON_ERR);
salt = CMVP_StringsToBins(SCRYPT_VECTOR.salt, &saltLen);
GOTO_ERR_IF_TRUE(salt == NULL, CRYPT_CMVP_COMMON_ERR);
expkey = CMVP_StringsToBins(SCRYPT_VECTOR.key, &expkeyLen);
GOTO_ERR_IF_TRUE(expkey == NULL, CRYPT_CMVP_COMMON_ERR);
key = BSL_SAL_Malloc(expkeyLen);
GOTO_ERR_IF_TRUE(key == NULL, CRYPT_MEM_ALLOC_FAIL);
ctx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_SCRYPT, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
BSL_Param param[6] = {
{CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS, pw, pwLen, 0},
{CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS, salt, saltLen, 0},
{CRYPT_PARAM_KDF_N, BSL_PARAM_TYPE_UINT32, &n, sizeof(uint32_t), 0},
{CRYPT_PARAM_KDF_R, BSL_PARAM_TYPE_UINT32, &r, sizeof(uint32_t), 0},
{CRYPT_PARAM_KDF_P, BSL_PARAM_TYPE_UINT32, &p, sizeof(uint32_t), 0},
BSL_PARAM_END
};
GOTO_ERR_IF_TRUE(CRYPT_EAL_KdfSetParam(ctx, param) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_KdfDerive(ctx, key, expkeyLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(key, expkey, expkeyLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(pw);
BSL_SAL_Free(salt);
BSL_SAL_Free(expkey);
BSL_SAL_Free(key);
CRYPT_EAL_KdfFreeCtx(ctx);
return ret;
}
bool CRYPT_CMVP_SelftestScrypt(void)
{
return CRYPT_CMVP_SelftestScryptInternal(NULL, NULL);
}
bool CRYPT_CMVP_SelftestProviderScrypt(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestScryptInternal(libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_scrypt.c | C | unknown | 3,597 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_algid.h"
#include "crypt_eal_pkey.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "securec.h"
#include "bsl_sal.h"
#define BITS_OF_BYTE 8
typedef struct {
const char *rnd;
const char *sk;
const char *pk;
const char *context;
const char *msg;
const char *sig;
int32_t preHashId;
int32_t algId;
int32_t type;
} CMVP_SlhdsaSignVector;
static const CMVP_SlhdsaSignVector SLHDSA_VECTOR[] = {
{
// https://github.com/usnistgov/ACVP-Server/tree/master/gen-val/json-files/SLH-DSA-sigGen-FIPS205
.rnd = "FD3FE9ADC298FAD0BF5A08D804C690B1",
.sk = "F9FFBDE3D5FB47C2669823076777A941B810BE27FEF66DD4353B4A21DC972842EA5EE0F3E9B301B5CC32814C8AC6CDBD8BE5D429B0104F2F0A929099F687A74C",
.pk = "EA5EE0F3E9B301B5CC32814C8AC6CDBD8BE5D429B0104F2F0A929099F687A74C",
.context = "F29200E32E0DCCC92F029503DF3C878E340569C54169A31F7704A16EEBDF5667D0A5DB865F486F67052B1765B772D461C9F4B75B2D6056CD185F2C9D74D1F446674D75B49D5082EC6097269837BC7FA3A2163FE026BEB4455A79D7E135D0FF2BC44E213715767808D4DD1AE2A6B147F041616D74FDB89589848B2B155957CA7B79CC497EACC1050F8A3C98BB4839D1858F",
.msg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
.sig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
.algId = CRYPT_PKEY_SLH_DSA,
.preHashId = CRYPT_MD_SHA256,
.type = CRYPT_SLH_DSA_SHA2_128F,
}
};
static int32_t GetPkey(void *libCtx, const char *attrName, const CMVP_SlhdsaSignVector *vector,
CRYPT_EAL_PkeyCtx **pkeyPrv, CRYPT_EAL_PkeyCtx **pkeyPub)
{
int32_t ret = CRYPT_CMVP_ERR_ALGO_SELFTEST;
CRYPT_EAL_PkeyPrv prvKey = { 0 };
uint8_t *rand = NULL;
uint8_t *vectorKey = NULL;
uint8_t *context = NULL;
*pkeyPrv = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, vector->algId, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPrv == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
*pkeyPub = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, vector->algId, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPub == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = CRYPT_EAL_PkeySetParaById(*pkeyPrv, vector->type);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
ret = CRYPT_EAL_PkeySetParaById(*pkeyPub, vector->type);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
uint32_t keyLen = 0;
ret = CRYPT_EAL_PkeyCtrl(*pkeyPrv, CRYPT_CTRL_GET_SLH_DSA_KEY_LEN, (void *)&keyLen, sizeof(keyLen));
uint32_t randLen = 0;
rand = CMVP_StringsToBins(vector->rnd, &randLen);
ret = CRYPT_EAL_PkeyCtrl(*pkeyPrv, CRYPT_CTRL_SET_SLH_DSA_ADDRAND, (void *)rand, randLen);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
uint32_t vectorKeyLen = 0;
vectorKey = CMVP_StringsToBins(vector->sk, &vectorKeyLen);
prvKey.id = CRYPT_PKEY_SLH_DSA;
prvKey.key.slhDsaPrv.seed = vectorKey;
prvKey.key.slhDsaPrv.prf = vectorKey + keyLen;
prvKey.key.slhDsaPrv.pub.seed = vectorKey + keyLen * 2; // 2: pub.seed offset
prvKey.key.slhDsaPrv.pub.root = vectorKey + keyLen * 3; // 3: pub.root offset
prvKey.key.slhDsaPrv.pub.len = keyLen;
ret = CRYPT_EAL_PkeySetPrv(*pkeyPrv, &prvKey);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
uint32_t contextLen = 0;
context = CMVP_StringsToBins(vector->context, &contextLen);
ret = CRYPT_EAL_PkeyCtrl(*pkeyPrv, CRYPT_CTRL_SET_CTX_INFO, context, contextLen);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
ret = CRYPT_EAL_PkeyCtrl(*pkeyPub, CRYPT_CTRL_SET_SLH_DSA_ADDRAND, (void *)rand, randLen);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
ret = CRYPT_EAL_PkeySetPrv(*pkeyPub, &prvKey); // The prvKey contains the public key, public key is used here.
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
ret = CRYPT_EAL_PkeyCtrl(*pkeyPub, CRYPT_CTRL_SET_CTX_INFO, context, contextLen);
ERR:
BSL_SAL_Free(rand);
BSL_SAL_Free(vectorKey);
BSL_SAL_Free(context);
return ret;
}
static bool TestSlhdsaSignVerify(void *libCtx, const char *attrName, const CMVP_SlhdsaSignVector *vector)
{
bool ret = false;
uint8_t *sign = NULL;
uint8_t *signVec = NULL;
uint32_t signLen;
uint32_t signVecLen = 0;
uint8_t *msg = NULL;
uint32_t msgLen;
CRYPT_EAL_PkeyCtx *pkeyPrv = NULL;
CRYPT_EAL_PkeyCtx *pkeyPub = NULL;
GOTO_ERR_IF_TRUE(
GetPkey(libCtx, attrName, vector, &pkeyPrv, &pkeyPub) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
msg = CMVP_StringsToBins(vector->msg, &msgLen);
GOTO_ERR_IF_TRUE(msg == NULL, CRYPT_CMVP_COMMON_ERR);
signVec = CMVP_StringsToBins(vector->sig, &signVecLen);
GOTO_ERR_IF_TRUE(signVec == NULL, CRYPT_CMVP_COMMON_ERR);
signLen = signVecLen;
sign = BSL_SAL_Malloc(signLen);
GOTO_ERR_IF_TRUE(sign == NULL, CRYPT_MEM_ALLOC_FAIL);
// sign
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySign(pkeyPrv, vector->preHashId, msg, msgLen, sign, &signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
// compare the signature
GOTO_ERR_IF_TRUE(signLen != signVecLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(signVec, sign, signLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
// verify
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyVerify(pkeyPub, vector->preHashId, msg, msgLen, sign, signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(sign);
BSL_SAL_Free(signVec);
BSL_SAL_Free(msg);
CRYPT_EAL_PkeyFreeCtx(pkeyPrv);
CRYPT_EAL_PkeyFreeCtx(pkeyPub);
return ret;
}
bool CRYPT_CMVP_SelftestSlhdsaSignVerify(void)
{
bool ret = TestSlhdsaSignVerify(NULL, NULL, &SLHDSA_VECTOR[0]);
return ret;
}
bool CRYPT_CMVP_SelftestProviderSlhdsaSignVerify(void *libCtx, const char *attrName)
{
return TestSlhdsaSignVerify(libCtx, attrName, &SLHDSA_VECTOR[0]);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */ | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_slhdsa.c | C | unknown | 57,044 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "securec.h"
#include "crypt_bn.h"
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "crypt_bn.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
#include "crypt_eal_rand.h"
#include "crypt_encode_internal.h"
#include "crypt_util_rand.h"
#define BITS_OF_BYTE 8
#define MAX_PLAIN_TEXT_LEN 19
#define CIPHER_TEXT_EXTRA_LEN 108
#define SM3_MD_SIZE 32
#define SM2_POINT_SINGLE_COORDINATE_LEN 32
#define SM2_POINT_COORDINATE_LEN 65
const char *consistestdata = "01020304050607080910";
typedef struct {
const char *d;
const char *qX;
const char *qY;
} CMVP_SM2_KEYS;
static const CMVP_SM2_KEYS SM2_TEST_KEYS = {
.d = "3945208f7b2144b13f36e38ac6d39f95889393692860b51a42fb81ef4df7c5b8",
.qX = "09f9df311e5421a150dd7d161e4bc5c672179fad1833fc076bb08ff356f35020",
.qY = "ccea490ce26775a52dc6ea718cc1aa600aed05fbf35e084a6632f6072da9ad13",
};
typedef struct {
const char *plain;
const char *cipher;
const char *k;
int32_t curveId;
CRYPT_MD_AlgId mdId;
} CMVP_SM2CryptVector;
static const CMVP_SM2CryptVector SM2_CRYPT_TEST_VECTOR = {
.plain = "656e6372797074696f6e207374616e64617264",
.k = "59276e27d506861a16680f3ad9c02dccef3cc1fa3cdbe4ce6d54b80deac1bc21",
.cipher = "0404ebfc718e8d1798620432268e77feb6415e2ede0e073c0f4f640ecd2e149a73e858f9d81e5430a57b36daab8f950a3c64e6ee6a63094d99283aff767e124df059983c18f809e262923c53aec295d30383b54e39d609d160afcb1908d0bd876621886ca989ca9c7d58087307ca93092d651efa",
};
typedef struct {
const char *msg;
const char *k;
const char *signR;
const char *signS;
const char *userid;
int32_t curveId;
CRYPT_MD_AlgId mdId;
} CMVP_SM2SignVector;
static const CMVP_SM2SignVector SM2DSA_VECTOR = {
.msg = "6d65737361676520646967657374",
.k = "59276e27d506861a16680f3ad9c02dccef3cc1fa3cdbe4ce6d54b80deac1bc21",
.signR = "f5a03b0648d2c4630eeac513e1bb81a15944da3827d5b74143ac7eaceee720b3",
.signS = "b1b6aa29df212fd8763182bc0d421ca1bb9038fd1f7f42d4840b69c485bbc1aa",
.userid = "31323334353637383132333435363738",
.curveId = CRYPT_ECC_SM2,
.mdId = CRYPT_MD_SM3
};
typedef struct {
const char *self_d;
const char *self_x;
const char *self_y;
const char *peer_d;
const char *peer_x;
const char *peer_y;
const char *r;
const char *R;
const char *sharekey;
const char *userid1;
const char *userid2;
int32_t server;
} CMVP_SM2ExchangeVector;
static const CMVP_SM2ExchangeVector SM2Exchange_VECTOR = {
.self_d = "81eb26e941bb5af16df116495f90695272ae2cd63d6c4ae1678418be48230029",
.self_x = "160e12897df4edb61dd812feb96748fbd3ccf4ffe26aa6f6db9540af49c94232",
.self_y = "4a7dad08bb9a459531694beb20aa489d6649975e1bfcf8c4741b78b4b223007f",
.peer_d = "785129917d45a9ea5437a59356b82338eaadda6ceb199088f14ae10defa229b5",
.peer_x = "6ae848c57c53c7b1b5fa99eb2286af078ba64c64591b8b566f7357d576f16dfb",
.peer_y = "ee489d771621a27b36c5c7992062e9cd09a9264386f3fbea54dff69305621c4d",
.r = "d4de15474db74d06491c440d305e012400990f3e390c7e87153c12db2ea60bb3",
.R = "04acc27688a6f7b706098bc91ff3ad1bff7dc2802cdb14ccccdb0a90471f9bd7072fedac0494b2ffc4d6853876c79b8f301c6573ad0aa50f39fc87181e1a1b46fe",
.sharekey = "6c89347354de2484c60b4ab1fde4c6e5",
.userid1 = "31323334353637383132333435363738",
.userid2 = "31323334353637383132333435363738",
};
static int32_t SetRandomVector(const char *vector, uint8_t *r, uint32_t rLen)
{
uint8_t *rand = NULL;
uint32_t randLen;
rand = CMVP_StringsToBins(vector, &randLen);
if (rand == NULL) {
return CRYPT_MEM_ALLOC_FAIL;
}
if (randLen < rLen) {
BSL_SAL_FREE(rand);
return CRYPT_CMVP_ERR_ALGO_SELFTEST;
}
(void)memcpy_s(r, rLen, rand, rLen);
BSL_SAL_FREE(rand);
return CRYPT_SUCCESS;
}
static int32_t TestVectorRandom(uint8_t *r, uint32_t rLen)
{
return SetRandomVector(SM2DSA_VECTOR.k, r, rLen);
}
static bool SetPrvPkey(CRYPT_EAL_PkeyCtx **pkeyPrv, const char qd[])
{
bool ret = false;
uint8_t *d = NULL;
uint32_t dLen;
CRYPT_EAL_PkeyPrv prv = {0};
prv.id = CRYPT_PKEY_SM2;
d = CMVP_StringsToBins(qd, &dLen);
GOTO_ERR_IF_TRUE(d == NULL, CRYPT_CMVP_COMMON_ERR);
prv.key.eccPrv.len = dLen;
prv.key.eccPrv.data = BSL_SAL_Malloc(prv.key.eccPrv.len);
GOTO_ERR_IF_TRUE(prv.key.eccPrv.data == NULL, CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_TRUE(memcpy_s(prv.key.eccPrv.data, prv.key.eccPrv.len, d, dLen) != EOK, CRYPT_SECUREC_FAIL);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(*pkeyPrv, &prv) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_FREE(prv.key.eccPrv.data);
BSL_SAL_FREE(d);
return ret;
}
static bool SetPubPkey(CRYPT_EAL_PkeyCtx **pkeyPub, const char qX[], const char qY[])
{
bool ret = false;
CRYPT_EAL_PkeyPub pub = {0};
uint8_t *x = NULL;
uint8_t *y = NULL;
uint32_t xLen, yLen;
pub.id = CRYPT_PKEY_SM2;
x = CMVP_StringsToBins(qX, &xLen);
GOTO_ERR_IF_TRUE(x == NULL, CRYPT_CMVP_COMMON_ERR);
y = CMVP_StringsToBins(qY, &yLen);
GOTO_ERR_IF_TRUE(y == NULL, CRYPT_CMVP_COMMON_ERR);
pub.key.eccPub.len = xLen + yLen + 1;
pub.key.eccPub.data = BSL_SAL_Malloc(pub.key.eccPub.len);
GOTO_ERR_IF_TRUE(pub.key.eccPub.data == NULL, CRYPT_MEM_ALLOC_FAIL);
pub.key.eccPub.data[0] = 0x04;
GOTO_ERR_IF_TRUE(memcpy_s(pub.key.eccPub.data + 1, pub.key.eccPub.len, x, xLen) != EOK, CRYPT_SECUREC_FAIL);
GOTO_ERR_IF_TRUE(memcpy_s(pub.key.eccPub.data + 1 + xLen, pub.key.eccPub.len, y, yLen) != EOK, CRYPT_SECUREC_FAIL);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(*pkeyPub, &pub) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_FREE(pub.key.eccPub.data);
BSL_SAL_FREE(x);
BSL_SAL_FREE(y);
return ret;
}
bool CRYPT_CMVP_SelftestSM2Crypt(void *libCtx, const char *attrName)
{
bool ret = false;
CRYPT_EAL_PkeyCtx *pubCtx = NULL;
CRYPT_EAL_PkeyCtx *prvCtx = NULL;
uint8_t *plain = NULL;
uint32_t plainLen;
uint8_t *cipher = NULL;
uint32_t cipherLen;
uint8_t cipherText[MAX_PLAIN_TEXT_LEN + CIPHER_TEXT_EXTRA_LEN] = {0};
uint32_t cipherTextLen = sizeof(cipherText);
uint8_t decodeText[MAX_PLAIN_TEXT_LEN + CIPHER_TEXT_EXTRA_LEN] = {0};
uint32_t decodeoutLen = sizeof(decodeText);
uint8_t plainText[MAX_PLAIN_TEXT_LEN] = {0};
uint32_t plainTextLen = sizeof(plainText);
uint8_t encodeText[MAX_PLAIN_TEXT_LEN + CIPHER_TEXT_EXTRA_LEN] = {0};
uint32_t encodeTextLen = sizeof(encodeText);
CRYPT_EAL_RandFunc func = CRYPT_RandRegistGet();
CRYPT_EAL_RandFuncEx funcEx = CRYPT_RandRegistExGet();
CRYPT_RandRegistEx(NULL);
pubCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_SM2, 0, attrName);
GOTO_ERR_IF_TRUE(pubCtx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
prvCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_SM2, 0, attrName);
GOTO_ERR_IF_TRUE(prvCtx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
SetPrvPkey(&prvCtx, SM2_TEST_KEYS.d);
SetPubPkey(&pubCtx, SM2_TEST_KEYS.qX, SM2_TEST_KEYS.qY);
plain = CMVP_StringsToBins(SM2_CRYPT_TEST_VECTOR.plain, &plainLen);
GOTO_ERR_IF_TRUE(plain == NULL, CRYPT_CMVP_COMMON_ERR);
cipher = CMVP_StringsToBins(SM2_CRYPT_TEST_VECTOR.cipher, &cipherLen);
GOTO_ERR_IF_TRUE(cipher == NULL, CRYPT_CMVP_COMMON_ERR);
CRYPT_RandRegist(TestVectorRandom);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyEncrypt(pubCtx, plain, plainLen, cipherText, &cipherTextLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
CRYPT_SM2_EncryptData data = {
.x = decodeText + 1,
.xLen = SM2_POINT_SINGLE_COORDINATE_LEN,
.y = decodeText + SM2_POINT_SINGLE_COORDINATE_LEN + 1,
.yLen = SM2_POINT_SINGLE_COORDINATE_LEN,
.hash = decodeText + SM2_POINT_COORDINATE_LEN,
.hashLen = SM3_MD_SIZE,
.cipher = decodeText + SM2_POINT_COORDINATE_LEN + SM3_MD_SIZE,
.cipherLen = decodeoutLen - SM2_POINT_COORDINATE_LEN - SM3_MD_SIZE
};
GOTO_ERR_IF_TRUE(CRYPT_EAL_DecodeSm2EncryptData(cipherText, cipherTextLen, &data) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
decodeText[0] = 0x04;
decodeoutLen = SM2_POINT_SINGLE_COORDINATE_LEN + SM2_POINT_SINGLE_COORDINATE_LEN + SM3_MD_SIZE + data.cipherLen;
GOTO_ERR_IF_TRUE(decodeoutLen + 1 != cipherLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(decodeText, cipher, cipherLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_EncodeSm2EncryptData(&data, encodeText, &encodeTextLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(
CRYPT_EAL_PkeyDecrypt(prvCtx, encodeText, encodeTextLen, plainText, &plainTextLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(plainTextLen != plainLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(plainText, plain, plainLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_FREE(plain);
BSL_SAL_FREE(cipher);
CRYPT_RandRegist(func);
CRYPT_RandRegistEx(funcEx);
CRYPT_EAL_PkeyFreeCtx(pubCtx);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
return ret;
}
static int32_t SignEncode(const char *signR, const char *signS, uint8_t *vectorSign, uint32_t *vectorSignLen)
{
int ret = CRYPT_CMVP_ERR_ALGO_SELFTEST;
BN_BigNum *bnR = NULL;
BN_BigNum *bnS = NULL;
uint8_t *r = NULL;
uint8_t *s = NULL;
uint32_t rLen, sLen;
r = CMVP_StringsToBins(signR, &rLen);
GOTO_ERR_IF_TRUE(r == NULL, CRYPT_CMVP_COMMON_ERR);
s = CMVP_StringsToBins(signS, &sLen);
GOTO_ERR_IF_TRUE(s == NULL, CRYPT_CMVP_COMMON_ERR);
bnR = BN_Create(rLen * BITS_OF_BYTE);
bnS = BN_Create(sLen * BITS_OF_BYTE);
GOTO_ERR_IF_TRUE(BN_Bin2Bn(bnR, r, rLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(BN_Bin2Bn(bnS, s, sLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = CRYPT_EAL_EncodeSign(bnR, bnS, vectorSign, vectorSignLen);
ERR:
BSL_SAL_FREE(r);
BSL_SAL_FREE(s);
BN_Destroy(bnR);
BN_Destroy(bnS);
return ret;
}
static bool SetUserId(CRYPT_EAL_PkeyCtx *pkey, const char id[])
{
bool ret = false;
uint8_t *userId = NULL;
uint32_t userIdLen;
userId = CMVP_StringsToBins(id, &(userIdLen));
GOTO_ERR_IF_TRUE(userId == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_SM2_USER_ID, userId, userIdLen) != CRYPT_SUCCESS,
CRYPT_CMVP_COMMON_ERR);
ret = true;
ERR:
BSL_SAL_FREE(userId);
return ret;
}
bool CRYPT_CMVP_SelftestSM2Sign(void *libCtx, const char *attrName)
{
bool ret = false;
uint8_t *sign = NULL;
uint8_t *signVec = NULL;
uint32_t signLen;
uint32_t signVecLen = 0;
uint8_t *msg = NULL;
uint32_t msgLen;
CRYPT_EAL_PkeyCtx *pkeyPrv = NULL;
CRYPT_EAL_PkeyCtx *pkeyPub = NULL;
CRYPT_EAL_RandFunc func = CRYPT_RandRegistGet();
CRYPT_EAL_RandFuncEx funcEx = CRYPT_RandRegistExGet();
CRYPT_RandRegistEx(NULL);
msg = CMVP_StringsToBins(SM2DSA_VECTOR.msg, &msgLen);
GOTO_ERR_IF_TRUE(msg == NULL, CRYPT_CMVP_COMMON_ERR);
pkeyPrv = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_SM2, 0, attrName);
GOTO_ERR_IF_TRUE(pkeyPrv == NULL, CRYPT_CMVP_COMMON_ERR);
pkeyPub = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_SM2, 0, attrName);
GOTO_ERR_IF_TRUE(pkeyPub == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(SetUserId(pkeyPub, SM2DSA_VECTOR.userid) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(SetUserId(pkeyPrv, SM2DSA_VECTOR.userid) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(SetPrvPkey(&pkeyPrv, SM2_TEST_KEYS.d) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(SetPubPkey(&pkeyPub, SM2_TEST_KEYS.qX, SM2_TEST_KEYS.qY) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
signLen = CRYPT_EAL_PkeyGetSignLen(pkeyPrv);
sign = BSL_SAL_Malloc(signLen);
GOTO_ERR_IF_TRUE(sign == NULL, CRYPT_MEM_ALLOC_FAIL);
// regist rand function
CRYPT_RandRegist(TestVectorRandom);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySign(pkeyPrv, SM2DSA_VECTOR.mdId, msg, msgLen, sign, &signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
// compare the signature
signVecLen = CRYPT_EAL_PkeyGetSignLen(pkeyPrv);
signVec = (uint8_t *)BSL_SAL_Malloc(signVecLen);
GOTO_ERR_IF_TRUE(signVec == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(SignEncode(SM2DSA_VECTOR.signR, SM2DSA_VECTOR.signS, signVec, &signVecLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(signLen != signVecLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(signVec, sign, signLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(
CRYPT_EAL_PkeyVerify(pkeyPub, SM2DSA_VECTOR.mdId, msg, msgLen, signVec, signVecLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_FREE(sign);
BSL_SAL_FREE(signVec);
BSL_SAL_FREE(msg);
CRYPT_EAL_PkeyFreeCtx(pkeyPrv);
CRYPT_EAL_PkeyFreeCtx(pkeyPub);
CRYPT_RandRegist(func);
CRYPT_RandRegistEx(funcEx);
return ret;
}
static int32_t TestExchangeVectorRandom(uint8_t *r, uint32_t rLen)
{
return SetRandomVector(SM2Exchange_VECTOR.r, r, rLen);
}
bool CRYPT_CMVP_SelftestSM2Exchange(void *libCtx, const char *attrName)
{
bool ret = false;
uint8_t *R = NULL;
uint8_t *out = NULL;
uint8_t *sharekey = NULL;
uint8_t localR[65];
int32_t server = 1;
CRYPT_EAL_PkeyCtx *selfCtx = NULL;
CRYPT_EAL_PkeyCtx *peerCtx = NULL;
CRYPT_EAL_RandFunc func = CRYPT_RandRegistGet();
CRYPT_EAL_RandFuncEx funcEx = CRYPT_RandRegistExGet();
CRYPT_RandRegistEx(NULL);
selfCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_SM2, 0, attrName);
GOTO_ERR_IF_TRUE(selfCtx == NULL, CRYPT_CMVP_COMMON_ERR);
peerCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_SM2, 0, attrName);
GOTO_ERR_IF_TRUE(peerCtx == NULL, CRYPT_CMVP_COMMON_ERR);
uint32_t RLen;
R = CMVP_StringsToBins(SM2Exchange_VECTOR.R, &RLen);
GOTO_ERR_IF_TRUE(R == NULL, CRYPT_CMVP_COMMON_ERR);
uint32_t sharekeyLen;
sharekey = CMVP_StringsToBins(SM2Exchange_VECTOR.sharekey, &sharekeyLen);
GOTO_ERR_IF_TRUE(sharekey == NULL, CRYPT_CMVP_COMMON_ERR);
uint32_t outLen = sharekeyLen;
out = BSL_SAL_Malloc(outLen);
GOTO_ERR_IF_TRUE(out == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(SetUserId(selfCtx, SM2Exchange_VECTOR.userid1) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyCtrl(selfCtx, CRYPT_CTRL_SET_SM2_SERVER, &server, sizeof(int32_t)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
CRYPT_RandRegist(TestExchangeVectorRandom);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyCtrl(selfCtx, CRYPT_CTRL_GENE_SM2_R, localR, sizeof(localR)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(SetUserId(peerCtx, SM2Exchange_VECTOR.userid2) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyCtrl(peerCtx, CRYPT_CTRL_SET_SM2_R, R, RLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(SetPrvPkey(&selfCtx, SM2Exchange_VECTOR.self_d) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(SetPrvPkey(&peerCtx, SM2Exchange_VECTOR.peer_d) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(SetPubPkey(&selfCtx, SM2Exchange_VECTOR.self_x, SM2Exchange_VECTOR.self_y) != true,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(SetPubPkey(&peerCtx, SM2Exchange_VECTOR.peer_x, SM2Exchange_VECTOR.peer_y) != true,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyComputeShareKey(selfCtx, peerCtx, out, &outLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(outLen != sharekeyLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(out, sharekey, sharekeyLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_FREE(sharekey);
BSL_SAL_FREE(out);
BSL_SAL_FREE(R);
CRYPT_EAL_PkeyFreeCtx(peerCtx);
CRYPT_EAL_PkeyFreeCtx(selfCtx);
CRYPT_RandRegist(func);
CRYPT_RandRegistEx(funcEx);
return ret;
}
static bool SM2_Consistency_Sign(void)
{
bool ret = false;
CRYPT_EAL_PkeyCtx *pkey = NULL;
uint8_t *sign = NULL;
uint32_t signLen;
uint8_t *data = NULL;
uint32_t dataLen;
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SM2);
GOTO_ERR_IF_TRUE(pkey == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(SetUserId(pkey, SM2DSA_VECTOR.userid) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
signLen = CRYPT_EAL_PkeyGetSignLen(pkey);
sign = BSL_SAL_Malloc(signLen);
GOTO_ERR_IF_TRUE(sign == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyGen(pkey) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
data = CMVP_StringsToBins(consistestdata, &dataLen);
GOTO_ERR_IF_TRUE(data == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SM3, data, dataLen, sign, &signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SM3, data, dataLen, sign, signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_FREE(sign);
BSL_SAL_FREE(data);
CRYPT_EAL_PkeyFreeCtx(pkey);
return ret;
}
static bool SM2_Consistency_Crypt(void)
{
bool ret = false;
uint8_t *plain = NULL;
uint32_t plainLen;
uint8_t cipherText[MAX_PLAIN_TEXT_LEN + CIPHER_TEXT_EXTRA_LEN] = {0};
uint32_t cipherTextLen = sizeof(cipherText);
uint8_t decodeText[MAX_PLAIN_TEXT_LEN + CIPHER_TEXT_EXTRA_LEN] = {0};
uint32_t decodeTextLen = sizeof(decodeText);
uint8_t plainText[MAX_PLAIN_TEXT_LEN] = {0};
uint32_t plainTextLen = sizeof(plainText);
uint8_t encodeText[MAX_PLAIN_TEXT_LEN + CIPHER_TEXT_EXTRA_LEN] = {0};
uint32_t encodeTextLen = sizeof(encodeText);
CRYPT_EAL_PkeyCtx *pkey = NULL;
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SM2);
GOTO_ERR_IF_TRUE(pkey == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyGen(pkey) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
plain = CMVP_StringsToBins(SM2_CRYPT_TEST_VECTOR.plain, &plainLen);
GOTO_ERR_IF_TRUE(plain == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, plain, plainLen, cipherText, &cipherTextLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
CRYPT_SM2_EncryptData data = {
.x = decodeText+ 1,
.xLen = SM2_POINT_SINGLE_COORDINATE_LEN,
.y = decodeText + SM2_POINT_SINGLE_COORDINATE_LEN + 1,
.yLen = SM2_POINT_SINGLE_COORDINATE_LEN,
.hash = decodeText + SM2_POINT_COORDINATE_LEN,
.hashLen = SM3_MD_SIZE,
.cipher = decodeText + SM2_POINT_COORDINATE_LEN + SM3_MD_SIZE,
.cipherLen = decodeTextLen - SM2_POINT_COORDINATE_LEN - SM3_MD_SIZE
};
GOTO_ERR_IF_TRUE(CRYPT_EAL_DecodeSm2EncryptData(cipherText, cipherTextLen, &data) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
decodeText[0] = 0x04;
GOTO_ERR_IF_TRUE(memcmp(decodeText, plain, plainLen) == 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_EncodeSm2EncryptData(&data, encodeText, &encodeTextLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, encodeText, encodeTextLen, plainText, &plainTextLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(plainTextLen != plainLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(plainText, plain, plainLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_FREE(plain);
CRYPT_EAL_PkeyFreeCtx(pkey);
return ret;
}
bool CRYPT_CMVP_SelftestSM2Consistency(void)
{
return SM2_Consistency_Sign() && SM2_Consistency_Crypt();
}
bool CRYPT_CMVP_SelftestSM2(void)
{
return CRYPT_CMVP_SelftestSM2Sign(NULL, NULL) && CRYPT_CMVP_SelftestSM2Crypt(NULL, NULL) &&
CRYPT_CMVP_SelftestSM2Exchange(NULL, NULL) && CRYPT_CMVP_SelftestSM2Consistency();
}
bool CRYPT_CMVP_SelftestProviderSM2(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestSM2Sign(libCtx, attrName) && CRYPT_CMVP_SelftestSM2Crypt(libCtx, attrName) &&
CRYPT_CMVP_SelftestSM2Exchange(libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_sm2.c | C | unknown | 21,294 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
typedef struct {
const char *alicePri;
const char *alicePub;
const char *bobPri;
const char *bobPub;
const char *share1;
} CMVP_X25519_VECTOR;
// https://datatracker.ietf.org/doc/html/rfc7748.html#page-14
static const CMVP_X25519_VECTOR X25519_VECTOR = {
.alicePri = "77076d0a7318a57d3c16c17251b26645df4c2f87ebc0992ab177fba51db92c2a",
.alicePub = "8520f0098930a754748b7ddcb43ef75a0dbf3a0d26381af4eba4a98eaa9b4e6a",
.bobPri = "5dab087e624a8a4b79e17f8b83800ee66f3bb1292618b6fd1c2f8b27ff88e0eb",
.bobPub = "de9edb7d7b7dc1b4d35b61c2ece435373f8343c85b78674dadfc7e146f882b4f",
.share1 = "4a5d9d5ba4ce2de1728e3bf480350f25e07e21c947d19e3376f09b3c1e161742"
};
static bool GetData(CRYPT_Data *expShare, CRYPT_Data *share1, CRYPT_Data *share2)
{
expShare->data = CMVP_StringsToBins(X25519_VECTOR.share1, &(expShare->len));
GOTO_ERR_IF_TRUE(expShare->data == NULL, CRYPT_CMVP_COMMON_ERR);
share1->len = expShare->len;
share1->data = BSL_SAL_Malloc(share1->len);
GOTO_ERR_IF_TRUE(share1->data == NULL, CRYPT_MEM_ALLOC_FAIL);
share2->len = expShare->len;
share2->data = BSL_SAL_Malloc(share2->len);
GOTO_ERR_IF_TRUE(share2->data == NULL, CRYPT_MEM_ALLOC_FAIL);
return true;
ERR:
return false;
}
static bool GetKey(CRYPT_EAL_PkeyPrv *alicePri, CRYPT_EAL_PkeyPub *alicePub, CRYPT_EAL_PkeyPrv *bobPri,
CRYPT_EAL_PkeyPub *bobPub)
{
alicePri->id = CRYPT_PKEY_X25519;
alicePri->key.curve25519Prv.data = CMVP_StringsToBins(X25519_VECTOR.alicePri, &(alicePri->key.curve25519Prv.len));
GOTO_ERR_IF_TRUE(alicePri->key.curve25519Prv.data == NULL, CRYPT_CMVP_COMMON_ERR);
alicePub->id = CRYPT_PKEY_X25519;
alicePub->key.curve25519Pub.data = CMVP_StringsToBins(X25519_VECTOR.alicePub, &(alicePub->key.curve25519Pub.len));
GOTO_ERR_IF_TRUE(alicePub->key.curve25519Pub.data == NULL, CRYPT_CMVP_COMMON_ERR);
bobPri->id = CRYPT_PKEY_X25519;
bobPri->key.curve25519Prv.data = CMVP_StringsToBins(X25519_VECTOR.bobPri, &(bobPri->key.curve25519Prv.len));
GOTO_ERR_IF_TRUE(bobPri->key.curve25519Prv.data == NULL, CRYPT_CMVP_COMMON_ERR);
bobPub->id = CRYPT_PKEY_X25519;
bobPub->key.curve25519Pub.data = CMVP_StringsToBins(X25519_VECTOR.bobPub, &(bobPub->key.curve25519Pub.len));
GOTO_ERR_IF_TRUE(bobPub->key.curve25519Pub.data == NULL, CRYPT_CMVP_COMMON_ERR);
return true;
ERR:
return false;
}
static bool CRYPT_CMVP_SelftestX25519Internal(void *libCtx, const char *attrName)
{
bool ret = false;
CRYPT_Data expShare = { NULL, 0 };
CRYPT_Data share1 = { NULL, 0 };
CRYPT_Data share2 = { NULL, 0 };
CRYPT_EAL_PkeyCtx *alice = NULL;
CRYPT_EAL_PkeyCtx *bob = NULL;
CRYPT_EAL_PkeyPrv alicePri = {0};
alicePri.key.curve25519Prv.data = NULL;
CRYPT_EAL_PkeyPub alicePub;
alicePub.key.curve25519Pub.data = NULL;
CRYPT_EAL_PkeyPrv bobPri = {0};
bobPri.key.curve25519Prv.data = NULL;
CRYPT_EAL_PkeyPub bobPub;
bobPub.key.curve25519Pub.data = NULL;
alice = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_X25519, 0, attrName);
GOTO_ERR_IF_TRUE(alice == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
bob = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_X25519, 0, attrName);
GOTO_ERR_IF_TRUE(bob == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(GetKey(&alicePri, &alicePub, &bobPri, &bobPub) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(GetData(&expShare, &share1, &share2) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(alice, &alicePri) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(bob, &bobPub) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyComputeShareKey(alice, bob, share1.data, &(share1.len)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(share1.len != expShare.len, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(share1.data, expShare.data, expShare.len) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(bob, &bobPri) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(alice, &alicePub) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyComputeShareKey(bob, alice, share2.data, &(share2.len)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(share2.len != expShare.len, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(share2.data, expShare.data, expShare.len) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(alicePri.key.curve25519Prv.data);
BSL_SAL_Free(alicePub.key.curve25519Pub.data);
BSL_SAL_Free(bobPri.key.curve25519Prv.data);
BSL_SAL_Free(bobPub.key.curve25519Pub.data);
BSL_SAL_Free(expShare.data);
BSL_SAL_Free(share1.data);
BSL_SAL_Free(share2.data);
CRYPT_EAL_PkeyFreeCtx(alice);
CRYPT_EAL_PkeyFreeCtx(bob);
return ret;
}
bool CRYPT_CMVP_SelftestX25519(void)
{
return CRYPT_CMVP_SelftestX25519Internal(NULL, NULL);
}
bool CRYPT_CMVP_SelftestProviderX25519(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestX25519Internal(libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_x25519.c | C | unknown | 6,185 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CRYPT_CMVP_H
#define CRYPT_CMVP_H
#include "hitls_build.h"
#include <stdint.h>
#include "bsl_params.h"
#include "crypt_types.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_rand.h"
#include "crypt_eal_md.h"
#include "crypt_eal_mac.h"
#include "crypt_eal_cipher.h"
#include "crypt_eal_kdf.h"
#include "crypt_cmvp.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
typedef void* (*CmvpProvNewCtx)(void *provCtx);
typedef const char* (*CmvpGetVersion)(void *ctx);
typedef int32_t (*CmvpSelftest)(void *ctx, const BSL_Param *param);
typedef void (*CmvpFreeCtx)(void *ctx);
typedef struct {
CmvpProvNewCtx provNewCtx;
CmvpGetVersion getVersion;
CmvpSelftest selftest;
CmvpFreeCtx freeCtx;
} EAL_CmvpSelftestMethod;
struct EAL_SelftestCtx {
bool isProvider;
EAL_CmvpSelftestMethod *method;
void *data;
uint32_t state;
int32_t id;
};
typedef struct {
CRYPT_MAC_AlgId macId; /**< MAC algorithm ID */
uint32_t saltLen; /**< Salt length in bytes */
uint32_t iter;
uint32_t dkeyLen; /**< Derived key length in bytes */
} CRYPT_EAL_Pbkdf2Param;
typedef struct {
CRYPT_MAC_AlgId macId; /**< MAC algorithm ID */
uint32_t keyLen; /**< Derived key length in bytes */
} CRYPT_EAL_HkdfParam;
typedef struct {
CRYPT_EAL_Pbkdf2Param *pbkdf2;
CRYPT_EAL_HkdfParam *hkdf;
} CRYPT_EAL_KdfC2Data;
typedef struct {
const CRYPT_EAL_PkeyPara *para;
const CRYPT_EAL_PkeyPub *pub;
const CRYPT_EAL_PkeyPrv *prv;
CRYPT_MD_AlgId mdId; /**< MD algorithm ID */
CRYPT_PKEY_ParaId paraId; /**< PKEY parameter ID */
CRYPT_EVENT_TYPE oper;
const CRYPT_RSA_PkcsV15Para *pkcsv15;
BSL_Param *pss;
BSL_Param *oaep;
} CRYPT_EAL_PkeyC2Data;
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* CRYPT_CMVP_H */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/cmvp_utils/crypt_cmvp.h | C | unknown | 2,346 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_FIPS
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/fips_prov/cmvp_fips.c | C | unknown | 631 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CMVP_FIPS_H
#define CMVP_FIPS_H
#endif | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/fips_prov/cmvp_fips.h | C | unknown | 591 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "cmvp_iso19790.h"
#include "cmvp_common.h"
#include "crypt_errno.h"
#include "crypt_cmvp_selftest.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "cmvp_integrity_hmac.h"
#include "crypt_params_key.h"
#include "securec.h"
#include "bsl_sal.h"
void CMVP_Iso19790EventProcess(CRYPT_EVENT_TYPE oper, CRYPT_ALGO_TYPE type, int32_t id, int32_t err)
{
if (oper == CRYPT_EVENT_RANDGEN) {
CMVP_WriteSyslog("openHiTLS", err == CRYPT_SUCCESS ? LOG_INFO : LOG_ERR,
"Excute - entropy collection, result: 0x%x", err);
return;
}
if (oper == CRYPT_EVENT_INTEGRITY_TEST) {
if (err == CRYPT_SUCCESS) {
CMVP_WriteSyslog("openHiTLS", LOG_INFO, "Integrity test begin.");
} else {
CMVP_WriteSyslog("openHiTLS", LOG_ERR, "Integrity test failed, errcode: 0x%x", err);
}
return;
}
// ISO/IEC 19790:2012 AS09.33
// The module shall provide an output status indication when zeroing is complete
if (oper == CRYPT_EVENT_ZERO && err == CRYPT_SUCCESS) {
CMVP_WriteSyslog("openHiTLS", LOG_INFO, "SSP already zeroisation - algorithm type: %d, id: %d", type, id);
}
/*
ISO/IEC 19790:2012 AS06.26
The following events of the cryptographic module should be recorded by the OS audit mechanism:
● Attempted to provide invalid input for the cryptographic officer function;
*/
if (err != CRYPT_SUCCESS) {
CMVP_WriteSyslog("openHiTLS", LOG_ERR, "Occur error - algorithm type: %d, id: %d, operate: %d, errcode: 0x%x",
type, id, oper, err);
}
/*
ISO/IEC 19790:2012 AS06.26
The following events of the cryptographic module should be recorded by the OS audit mechanism:
● Modify, access, delete, and add encrypted data and SSPs；
● Use security-related encryption features
ISO/IEC 19790:2012 AS02.24
When a service uses approved encryption algorithms, security functions or processes,
and specified services or processes in an approved manner,
the service shall provide corresponding status indications.
*/
CMVP_WriteSyslog("openHiTLS", LOG_INFO, "Excute - algorithm type: %d, id: %d, operate: %d", type, id, oper);
}
typedef struct {
uint32_t algId;
uint32_t mdId;
bool signValid;
bool verifyValid;
} ASYM_MD_MAP;
static const ASYM_MD_MAP ASYM_MD_LIST[] = {
{ CRYPT_PKEY_DSA, CRYPT_MD_SHA1, false, true },
{ CRYPT_PKEY_DSA, CRYPT_MD_SHA224, true, true },
{ CRYPT_PKEY_DSA, CRYPT_MD_SHA256, true, true },
{ CRYPT_PKEY_DSA, CRYPT_MD_SHA384, true, true },
{ CRYPT_PKEY_DSA, CRYPT_MD_SHA512, true, true },
{ CRYPT_PKEY_ECDSA, CRYPT_MD_SHA1, false, true },
{ CRYPT_PKEY_ECDSA, CRYPT_MD_SHA224, true, true },
{ CRYPT_PKEY_ECDSA, CRYPT_MD_SHA256, true, true },
{ CRYPT_PKEY_ECDSA, CRYPT_MD_SHA384, true, true },
{ CRYPT_PKEY_ECDSA, CRYPT_MD_SHA512, true, true },
{ CRYPT_PKEY_ECDSA, CRYPT_MD_SHA3_224, true, true },
{ CRYPT_PKEY_ECDSA, CRYPT_MD_SHA3_256, true, true },
{ CRYPT_PKEY_ECDSA, CRYPT_MD_SHA3_384, true, true },
{ CRYPT_PKEY_ECDSA, CRYPT_MD_SHA3_512, true, true },
{ CRYPT_PKEY_RSA, CRYPT_MD_SHA1, false, true },
{ CRYPT_PKEY_RSA, CRYPT_MD_SHA224, true, true },
{ CRYPT_PKEY_RSA, CRYPT_MD_SHA256, true, true },
{ CRYPT_PKEY_RSA, CRYPT_MD_SHA384, true, true },
{ CRYPT_PKEY_RSA, CRYPT_MD_SHA512, true, true },
{ CRYPT_PKEY_SM2, CRYPT_MD_SM3, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_SHA224, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_SHA256, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_SHA384, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_SHA512, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_SHA3_224, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_SHA3_256, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_SHA3_384, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_SHA3_512, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_SHAKE128, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_SHAKE256, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_MAX, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_SHA224, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_SHA256, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_SHA384, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_SHA512, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_SHA3_224, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_SHA3_256, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_SHA3_384, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_SHA3_512, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_SHAKE128, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_SHAKE256, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_MAX, true, true },
};
static bool GetVaildFlag(uint32_t algId, uint32_t mdId, bool isSign)
{
if (algId == CRYPT_PKEY_ED25519) {
return true;
}
for (uint32_t i = 0; i < sizeof(ASYM_MD_LIST) / sizeof(ASYM_MD_LIST[0]); i++) {
if (isSign == true && algId == ASYM_MD_LIST[i].algId && mdId == ASYM_MD_LIST[i].mdId) {
return ASYM_MD_LIST[i].signValid;
} else if (isSign == false && algId == ASYM_MD_LIST[i].algId && mdId == ASYM_MD_LIST[i].mdId) {
return ASYM_MD_LIST[i].verifyValid;
}
}
return false;
}
// Check whether the RSA parameter is approved.
static bool RsaParamCheck(const CRYPT_EAL_PkeyC2Data *data)
{
if (data->para != NULL) {
CRYPT_RsaPara para = data->para->para.rsaPara;
// The length of the RSA key must be at least 2048 bits.
GOTO_ERR_IF_TRUE(para.bits < 2048, CRYPT_CMVP_ERR_PARAM_CHECK);
return true;
}
if (data->pub != NULL) {
CRYPT_RsaPub pub = data->pub->key.rsaPub;
// The length of the RSA key must be at least 2048 bits. 8 bits are 1 byte.
GOTO_ERR_IF_TRUE(pub.nLen < (2048 / 8), CRYPT_CMVP_ERR_PARAM_CHECK);
return true;
}
if (data->prv != NULL) {
CRYPT_RsaPrv prv = data->prv->key.rsaPrv;
// The length of the RSA key must be at least 2048 bits. 8 bits are 1 byte.
GOTO_ERR_IF_TRUE(prv.nLen < (2048 / 8), CRYPT_CMVP_ERR_PARAM_CHECK);
return true;
}
if (data->pkcsv15 != NULL) {
GOTO_ERR_IF_TRUE(
(GetVaildFlag(CRYPT_PKEY_RSA, data->pkcsv15->mdId, false) == false), CRYPT_CMVP_ERR_PARAM_CHECK);
return true;
}
if (data->pss != NULL) {
BSL_Param *mdParam = BSL_PARAM_FindParam(data->pss, CRYPT_PARAM_RSA_MD_ID);
GOTO_ERR_IF_TRUE(mdParam == NULL, CRYPT_CMVP_ERR_PARAM_CHECK);
BSL_Param *mgfParam = BSL_PARAM_FindParam(data->pss, CRYPT_PARAM_RSA_MGF1_ID);
GOTO_ERR_IF_TRUE(mgfParam == NULL, CRYPT_CMVP_ERR_PARAM_CHECK);
GOTO_ERR_IF_TRUE((GetVaildFlag(CRYPT_PKEY_RSA, *(uint32_t *)(mdParam->value), false) == false),
CRYPT_CMVP_ERR_PARAM_CHECK);
GOTO_ERR_IF_TRUE((GetVaildFlag(CRYPT_PKEY_RSA, *(uint32_t *)(mgfParam->value), false) == false),
CRYPT_CMVP_ERR_PARAM_CHECK);
return true;
}
if (data->oaep != NULL) {
BSL_Param *mdParam = BSL_PARAM_FindParam(data->oaep, CRYPT_PARAM_RSA_MD_ID);
GOTO_ERR_IF_TRUE(mdParam == NULL, CRYPT_CMVP_ERR_PARAM_CHECK);
BSL_Param *mgfParam = BSL_PARAM_FindParam(data->oaep, CRYPT_PARAM_RSA_MGF1_ID);
GOTO_ERR_IF_TRUE(mgfParam == NULL, CRYPT_CMVP_ERR_PARAM_CHECK);
GOTO_ERR_IF_TRUE((GetVaildFlag(CRYPT_PKEY_RSA, *(uint32_t *)(mdParam->value), false) == false),
CRYPT_CMVP_ERR_PARAM_CHECK);
GOTO_ERR_IF_TRUE((GetVaildFlag(CRYPT_PKEY_RSA, *(uint32_t *)(mgfParam->value), false) == false),
CRYPT_CMVP_ERR_PARAM_CHECK);
return true;
}
return true;
ERR:
return false;
}
// Check whether the DSA parameter is approved
static bool DsaParamCheck(const CRYPT_EAL_PkeyC2Data *data)
{
if (data->para == NULL) {
return true;
}
uint32_t pLen = data->para->para.dsaPara.pLen;
uint32_t qLen = data->para->para.dsaPara.qLen;
// https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar2.pdf Chapter 3
// (L, N) = (2048, 224)，(2048, 256), 8 bits: 1 byte
if ((pLen != 2048 / 8 || qLen != 224 / 8) && (pLen != 2048 / 8 || qLen != 256 / 8) &&
// (L, N) = (3072, 256), 8 bits: 1 byte
(pLen != 3072 / 8 || qLen != 256 / 8)) {
return false;
}
return true;
}
// Check whether the dh parameter is approved
static bool DhParamCheck(const CRYPT_EAL_PkeyC2Data *data)
{
static const uint32_t list[] = {
CRYPT_DH_RFC2409_768,
CRYPT_DH_RFC2409_1024,
CRYPT_DH_RFC3526_1536,
};
if (data->para != NULL) {
uint32_t pLen = data->para->para.dhPara.pLen;
uint32_t qLen = data->para->para.dhPara.qLen;
// https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar2.pdf Chapter 5
// (len(p), len(q)) = (2048, 224)
// The length of p must be at least 2048 bits, and the length of q must be at least 224 bits.
GOTO_ERR_IF_TRUE(((pLen != 2048 / 8 || qLen != 224 / 8) &&
// (len(p), len(q)) = (2048, 256)
(pLen != 2048 / 8 || qLen != 256 / 8)), CRYPT_CMVP_ERR_PARAM_CHECK);
}
if (data->paraId != CRYPT_PKEY_PARAID_MAX) {
// The length of p must be at least 2048 bits, and the length of q must be at least 224 bits.
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
GOTO_ERR_IF_TRUE((data->paraId == list[i]), CRYPT_CMVP_ERR_PARAM_CHECK);
}
}
return true;
ERR:
return false;
}
static bool EcdhParamCheck(const CRYPT_EAL_PkeyC2Data *data)
{
// https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar2.pdf Chapters 3 and 5
// Requires curve specified using SP 800-56A
static const uint32_t list[] = {
CRYPT_ECC_NISTP224,
CRYPT_ECC_NISTP256,
CRYPT_ECC_NISTP384,
CRYPT_ECC_NISTP521,
CRYPT_ECC_SM2,
CRYPT_PKEY_PARAID_MAX,
};
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
if (data->paraId == list[i]) {
return true;
}
}
return false;
}
static bool EcdsaParamCheck(const CRYPT_EAL_PkeyC2Data *data)
{
// https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar2.pdf Chapters 3 and 5
// Requires curve specified using SP 800-56A
static const uint32_t list[] = {
CRYPT_ECC_NISTP224,
CRYPT_ECC_NISTP256,
CRYPT_ECC_NISTP384,
CRYPT_ECC_NISTP521,
CRYPT_ECC_BRAINPOOLP256R1,
CRYPT_ECC_BRAINPOOLP384R1,
CRYPT_ECC_BRAINPOOLP512R1,
CRYPT_PKEY_PARAID_MAX,
};
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
if (data->paraId == list[i]) {
return true;
}
}
return false;
}
static bool ISO19790_AsymParamCheck(CRYPT_PKEY_AlgId id, const CRYPT_EAL_PkeyC2Data *data)
{
// If the value is NULL, the interface does not need to check the algorithm parameters
// and directly returns a success message.
if (data == NULL) {
return true;
}
switch (id) {
case CRYPT_PKEY_DSA:
GOTO_ERR_IF_TRUE(DsaParamCheck(data) != true, CRYPT_CMVP_ERR_PARAM_CHECK);
break;
case CRYPT_PKEY_RSA:
GOTO_ERR_IF_TRUE(RsaParamCheck(data) != true, CRYPT_CMVP_ERR_PARAM_CHECK);
break;
case CRYPT_PKEY_DH:
GOTO_ERR_IF_TRUE(DhParamCheck(data) != true, CRYPT_CMVP_ERR_PARAM_CHECK);
break;
case CRYPT_PKEY_ECDH:
GOTO_ERR_IF_TRUE(EcdhParamCheck(data) != true, CRYPT_CMVP_ERR_PARAM_CHECK);
break;
case CRYPT_PKEY_ECDSA:
GOTO_ERR_IF_TRUE(EcdsaParamCheck(data) != true, CRYPT_CMVP_ERR_PARAM_CHECK);
break;
default:
break;
}
if (data->oper == CRYPT_EVENT_SIGN) {
GOTO_ERR_IF_TRUE((GetVaildFlag(id, data->mdId, true) == false), CRYPT_CMVP_ERR_PARAM_CHECK);
return true;
}
if (data->oper == CRYPT_EVENT_VERIFY) {
GOTO_ERR_IF_TRUE((GetVaildFlag(id, data->mdId, false) == false), CRYPT_CMVP_ERR_PARAM_CHECK);
return true;
}
return true;
ERR:
return false;
}
static bool ISO19790_MacParamCheck(CRYPT_MAC_AlgId id, uint32_t keyLen)
{
(void)id;
// https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar2.pdf Chapter 10
// Key lengths ≥ 112 bits, 8 bits: 1 byte
if (keyLen >= (112 / 8)) {
return true;
}
return false;
}
static bool ISO19790_KdfTls12ParamCheck(CRYPT_MAC_AlgId id, uint32_t keyLen)
{
static const uint32_t list[] = {
CRYPT_MAC_HMAC_SHA256,
CRYPT_MAC_HMAC_SHA384,
CRYPT_MAC_HMAC_SHA512,
};
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
// https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar2.pdf Chapter 8
// Key lengths ≥ 112 bits, 8 bits: 1 byte
if (id == list[i] && (keyLen >= (112 / 8))) {
return true;
}
}
return false;
}
static bool ISO19790_HkdfParamCheck(CRYPT_MAC_AlgId id, uint32_t keyLen)
{
static const uint32_t list[] = {
CRYPT_MAC_HMAC_SHA1,
CRYPT_MAC_HMAC_SHA224,
CRYPT_MAC_HMAC_SHA256,
CRYPT_MAC_HMAC_SHA384,
CRYPT_MAC_HMAC_SHA512
};
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
// https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar2.pdf Chapter 8
// Key lengths ≥ 112 bits, 8 bits: 1 byte
if (id == list[i] && (keyLen >= (112 / 8))) {
return true;
}
}
return false;
}
static bool ISO19790_PbkdfParamCheck(const CRYPT_EAL_Pbkdf2Param *param)
{
static const uint32_t list[] = {
CRYPT_MAC_HMAC_SHA1,
CRYPT_MAC_HMAC_SHA224,
CRYPT_MAC_HMAC_SHA256,
CRYPT_MAC_HMAC_SHA384,
CRYPT_MAC_HMAC_SHA512,
CRYPT_MAC_HMAC_SM3,
CRYPT_MAC_HMAC_SHA3_224,
CRYPT_MAC_HMAC_SHA3_256,
CRYPT_MAC_HMAC_SHA3_384,
CRYPT_MAC_HMAC_SHA3_512
};
bool ret = false;
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
if (param->macId == list[i]) {
ret = true;
break;
}
}
if (!ret) {
BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
return false;
}
if (param->saltLen < 16) { // FIPS SP800-132 section 5,The salt value must contain at least 16 bytes.
BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
return false;
}
if (param->iter < 1000) { // FIPS SP800-132 section 5,The number of iterations must be at least 1000.
BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
return false;
}
if (param->dkeyLen < 14) { // FIPS SP800-132 section 5,The length of the derived key must be at least 14 bytes.
BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
return false;
}
return true;
}
static bool ISO19790_CipherKat(void *libCtx, const char *attrName)
{
static const uint32_t list[] = {
CRYPT_CIPHER_AES128_ECB, CRYPT_CIPHER_AES192_ECB, CRYPT_CIPHER_AES256_ECB,
CRYPT_CIPHER_AES128_CBC, CRYPT_CIPHER_AES192_CBC, CRYPT_CIPHER_AES256_CBC,
CRYPT_CIPHER_AES128_CTR, CRYPT_CIPHER_AES192_CTR, CRYPT_CIPHER_AES256_CTR,
CRYPT_CIPHER_AES128_CCM, CRYPT_CIPHER_AES192_CCM, CRYPT_CIPHER_AES256_CCM,
CRYPT_CIPHER_AES128_GCM, CRYPT_CIPHER_AES192_GCM, CRYPT_CIPHER_AES256_GCM,
CRYPT_CIPHER_AES128_XTS, CRYPT_CIPHER_AES256_XTS,
CRYPT_CIPHER_AES128_OFB, CRYPT_CIPHER_AES192_OFB, CRYPT_CIPHER_AES256_OFB,
CRYPT_CIPHER_AES128_CFB, CRYPT_CIPHER_AES192_CFB, CRYPT_CIPHER_AES256_CFB,
CRYPT_CIPHER_CHACHA20_POLY1305,
CRYPT_CIPHER_SM4_XTS, CRYPT_CIPHER_SM4_CBC, CRYPT_CIPHER_SM4_ECB,
CRYPT_CIPHER_SM4_CTR, CRYPT_CIPHER_SM4_GCM, CRYPT_CIPHER_SM4_CFB,
CRYPT_CIPHER_SM4_OFB,
};
bool ret = false;
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
if (list[i] == CRYPT_CIPHER_CHACHA20_POLY1305) {
ret = CRYPT_CMVP_SelftestProviderChacha20poly1305(libCtx, attrName);
} else {
ret = CRYPT_CMVP_SelftestProviderCipher(libCtx, attrName, list[i]);
}
if (!ret) {
return false;
}
}
return true;
}
static bool ISO19790_MdKat(void *libCtx, const char *attrName)
{
static const uint32_t list[] = {
CRYPT_MD_SHA1,
CRYPT_MD_SHA224, CRYPT_MD_SHA256, CRYPT_MD_SHA384, CRYPT_MD_SHA512,
CRYPT_MD_SHA3_224, CRYPT_MD_SHA3_256, CRYPT_MD_SHA3_384, CRYPT_MD_SHA3_512,
CRYPT_MD_SHAKE128, CRYPT_MD_SHAKE256, CRYPT_MD_SM3,
};
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
if (!CRYPT_CMVP_SelftestProviderMd(libCtx, attrName, list[i])) {
return false;
}
}
return true;
}
static bool ISO19790_MacKat(void *libCtx, const char *attrName)
{
static const uint32_t list[] = {
CRYPT_MAC_CMAC_AES128, CRYPT_MAC_CMAC_AES192, CRYPT_MAC_CMAC_AES256,
CRYPT_MAC_GMAC_AES128, CRYPT_MAC_GMAC_AES192, CRYPT_MAC_GMAC_AES256,
CRYPT_MAC_HMAC_SHA1, CRYPT_MAC_HMAC_SHA224, CRYPT_MAC_HMAC_SHA256, CRYPT_MAC_HMAC_SHA384, CRYPT_MAC_HMAC_SHA512,
CRYPT_MAC_HMAC_SM3,
CRYPT_MAC_CMAC_SM4,
};
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
if (!CRYPT_CMVP_SelftestProviderMac(libCtx, attrName, list[i])) {
return false;
}
}
return true;
}
static bool ISO19790_DrbgKat(void *libCtx, const char *attrName)
{
static const uint32_t list[] = {
CRYPT_RAND_AES128_CTR, CRYPT_RAND_AES192_CTR, CRYPT_RAND_AES256_CTR,
CRYPT_RAND_AES128_CTR_DF, CRYPT_RAND_AES192_CTR_DF, CRYPT_RAND_AES256_CTR_DF,
CRYPT_RAND_HMAC_SHA1,
CRYPT_RAND_HMAC_SHA224, CRYPT_RAND_HMAC_SHA256, CRYPT_RAND_HMAC_SHA384, CRYPT_RAND_HMAC_SHA512,
CRYPT_RAND_SHA1, CRYPT_RAND_SHA224, CRYPT_RAND_SHA256, CRYPT_RAND_SHA384, CRYPT_RAND_SHA512,
CRYPT_RAND_SM4_CTR_DF,
CRYPT_RAND_SM3,
};
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
if (!CRYPT_CMVP_SelftestProviderDrbg(libCtx, attrName, list[i])) {
return false;
}
}
return true;
}
static bool ISO19790_KdfKat(void *libCtx, const char *attrName)
{
if (!CRYPT_CMVP_SelftestProviderKdfTls12(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderHkdf(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderScrypt(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderPbkdf2(libCtx, attrName, CRYPT_MAC_HMAC_SHA1)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderPbkdf2(libCtx, attrName, CRYPT_MAC_HMAC_SM3)) {
return false;
}
return true;
}
static bool ISO19790_PkeyKat(void *libCtx, const char *attrName)
{
if (!CRYPT_CMVP_SelftestProviderDsa(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderEcdsa(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderRsa(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderEd25519(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderSM2(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderEcdh(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderDh(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderX25519(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderMlkemEncapsDecaps(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderMldsaSignVerify(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderSlhdsaSignVerify(libCtx, attrName)) {
return false;
}
return true;
}
bool CMVP_Iso19790PkeyPct(CRYPT_Iso_Pkey_Ctx *ctx)
{
return CRYPT_CMVP_SelftestPkeyPct(ctx->ctx, ctx->algId);
}
bool CMVP_Iso19790PkeyC2(CRYPT_PKEY_AlgId id, const CRYPT_EAL_PkeyC2Data *data)
{
return ISO19790_AsymParamCheck(id, data);
}
bool CMVP_Iso19790MacC2(CRYPT_MAC_AlgId id, uint32_t keyLen)
{
return ISO19790_MacParamCheck(id, keyLen);
}
bool CMVP_Iso19790KdfC2(CRYPT_KDF_AlgId id, const CRYPT_EAL_KdfC2Data *data)
{
switch (id) {
case CRYPT_KDF_SCRYPT:
return false;
case CRYPT_KDF_PBKDF2:
return ISO19790_PbkdfParamCheck(data->pbkdf2);
case CRYPT_KDF_KDFTLS12:
return ISO19790_KdfTls12ParamCheck(data->hkdf->macId, data->hkdf->keyLen);
case CRYPT_KDF_HKDF:
return ISO19790_HkdfParamCheck(data->hkdf->macId, data->hkdf->keyLen);
default:
return false;
}
}
int32_t CMVP_Iso19790Kat(void *libCtx, const char *attrName)
{
bool ret = false;
ret = ISO19790_CipherKat(libCtx, attrName);
RETURN_RET_IF(ret == false, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = ISO19790_MdKat(libCtx, attrName);
RETURN_RET_IF(ret == false, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = ISO19790_MacKat(libCtx, attrName);
RETURN_RET_IF(ret == false, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = ISO19790_DrbgKat(libCtx, attrName);
RETURN_RET_IF(ret == false, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = ISO19790_KdfKat(libCtx, attrName);
RETURN_RET_IF(ret == false, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = ISO19790_PkeyKat(libCtx, attrName);
RETURN_RET_IF(ret == false, CRYPT_CMVP_ERR_ALGO_SELFTEST);
return CRYPT_SUCCESS;
}
int32_t CMVP_Iso19790CheckIntegrity(void *libCtx, const char *attrName)
{
return CMVP_CheckIntegrity(libCtx, attrName, CRYPT_MAC_HMAC_SHA256);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/iso_prov/cmvp_iso19790.c | C | unknown | 22,558 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CMVP_ISO19790_H
#define CMVP_ISO19790_H
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include <stdint.h>
#include <stdbool.h>
#include "crypt_cmvp.h"
#include "crypt_algid.h"
#include "crypt_iso_provderimpl.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
void CMVP_Iso19790EventProcess(CRYPT_EVENT_TYPE oper, CRYPT_ALGO_TYPE type, int32_t id, int32_t err);
bool CMVP_Iso19790PkeyC2(CRYPT_PKEY_AlgId id, const CRYPT_EAL_PkeyC2Data *data);
bool CMVP_Iso19790MacC2(CRYPT_MAC_AlgId id, uint32_t keyLen);
bool CMVP_Iso19790KdfC2(CRYPT_KDF_AlgId id, const CRYPT_EAL_KdfC2Data *data);
int32_t CMVP_Iso19790Kat(void *libCtx, const char *attrName);
int32_t CMVP_Iso19790CheckIntegrity(void *libCtx, const char *attrName);
bool CMVP_Iso19790PkeyPct(CRYPT_Iso_Pkey_Ctx *ctx);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */
#endif /* CMVP_ISO19790_H */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/iso_prov/cmvp_iso19790.h | C | unknown | 1,470 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "crypt_eal_implprovider.h"
#include "crypt_modes_cbc.h"
#include "crypt_modes_ccm.h"
#include "crypt_modes_chacha20poly1305.h"
#include "crypt_modes_ctr.h"
#include "crypt_modes_ecb.h"
#include "crypt_modes_gcm.h"
#include "crypt_modes_ofb.h"
#include "crypt_modes_cfb.h"
#include "crypt_modes_xts.h"
#include "crypt_local_types.h"
#include "crypt_errno.h"
#include "bsl_err_internal.h"
#include "crypt_ealinit.h"
#include "crypt_iso_selftest.h"
#include "crypt_iso_provider.h"
typedef struct {
int32_t algId;
void *ctx;
void *provCtx;
} IsoCipherCtx;
static int32_t CRYPT_ASMCAP_CipherCheck(int32_t algId)
{
#ifdef HITLS_CRYPTO_ASM_CHECK
if (CRYPT_ASMCAP_Cipher(algId) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
}
#else
(void)algId;
#endif
return CRYPT_SUCCESS;
}
#define CIPHER_NewCtx_FUNC(name) \
static void *MODES_##name##_NewCtxWrapper(CRYPT_EAL_IsoProvCtx *provCtx, int32_t algId) \
{ \
if (CRYPT_ASMCAP_CipherCheck(algId) != CRYPT_SUCCESS) { \
return NULL; \
} \
if (provCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return NULL; \
} \
void *cipherCtx = MODES_##name##_NewCtx(algId); \
if (cipherCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
return NULL; \
} \
IsoCipherCtx *ctx = BSL_SAL_Calloc(1, sizeof(IsoCipherCtx)); \
if (ctx == NULL) { \
MODES_##name##_FreeCtx(cipherCtx); \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
return NULL; \
} \
ctx->algId = algId; \
ctx->ctx = cipherCtx; \
ctx->provCtx = provCtx; \
return ctx; \
} \
\
static int32_t MODES_##name##_CtrlWrapper(IsoCipherCtx *ctx, int32_t cmd, void *val, uint32_t valLen) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return MODES_##name##_Ctrl(ctx->ctx, cmd, val, valLen); \
} \
\
static void MODES_##name##_FreeCtxWrapper(IsoCipherCtx *ctx) \
{ \
if (ctx == NULL) { \
return; \
} \
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_ZERO, CRYPT_ALGO_CIPHER, ctx->algId); \
if (ctx->ctx != NULL) { \
MODES_##name##_FreeCtx(ctx->ctx); \
} \
BSL_SAL_Free(ctx); \
}
#define CIPHER_INIT_FUNC(initFunc, updateFunc, finalFunc, deinitFunc) \
static int32_t initFunc##Wrapper(IsoCipherCtx *ctx, const uint8_t *key, uint32_t keyLen, \
const uint8_t *iv, uint32_t ivLen, void *param, bool enc) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t event = enc ? CRYPT_EVENT_ENC : CRYPT_EVENT_DEC; \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, event, CRYPT_ALGO_CIPHER, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_SETSSP, CRYPT_ALGO_CIPHER, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return (initFunc)(ctx->ctx, key, keyLen, iv, ivLen, param, enc); \
} \
\
static int32_t updateFunc##Wrapper(IsoCipherCtx *ctx, const uint8_t *in, uint32_t inLen, \
uint8_t *out, uint32_t *outLen) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return (updateFunc)(ctx->ctx, in, inLen, out, outLen); \
} \
\
static int32_t finalFunc##Wrapper(IsoCipherCtx *ctx, uint8_t *out, uint32_t *outLen) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return (finalFunc)(ctx->ctx, out, outLen); \
} \
\
static int32_t deinitFunc##Wrapper(IsoCipherCtx *ctx) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_ZERO, CRYPT_ALGO_CIPHER, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return (deinitFunc)(ctx->ctx); \
} \
CIPHER_NewCtx_FUNC(CBC)
CIPHER_NewCtx_FUNC(CCM)
CIPHER_NewCtx_FUNC(CFB)
CIPHER_NewCtx_FUNC(CTR)
CIPHER_NewCtx_FUNC(ECB)
CIPHER_NewCtx_FUNC(GCM)
CIPHER_NewCtx_FUNC(OFB)
CIPHER_NewCtx_FUNC(XTS)
CIPHER_NewCtx_FUNC(CHACHA20POLY1305)
CIPHER_INIT_FUNC(MODES_CBC_InitCtxEx, MODES_CBC_UpdateEx, MODES_CBC_FinalEx, MODES_CBC_DeInitCtx)
CIPHER_INIT_FUNC(MODES_CCM_InitCtx, MODES_CCM_UpdateEx, MODES_CCM_Final, MODES_CCM_DeInitCtx)
CIPHER_INIT_FUNC(MODES_CFB_InitCtxEx, MODES_CFB_UpdateEx, MODES_CFB_Final, MODES_CFB_DeInitCtx)
CIPHER_INIT_FUNC(MODES_CTR_InitCtxEx, MODES_CTR_UpdateEx, MODES_CTR_Final, MODES_CTR_DeInitCtx)
CIPHER_INIT_FUNC(MODES_ECB_InitCtxEx, MODES_ECB_UpdateEx, MODES_ECB_Final, MODES_ECB_DeinitCtx)
CIPHER_INIT_FUNC(MODES_GCM_InitCtxEx, MODES_GCM_UpdateEx, MODES_GCM_Final, MODES_GCM_DeInitCtx)
CIPHER_INIT_FUNC(MODES_OFB_InitCtxEx, MODES_OFB_UpdateEx, MODES_OFB_Final, MODES_OFB_DeInitCtx)
CIPHER_INIT_FUNC(MODES_XTS_InitCtxEx, MODES_XTS_UpdateEx, MODES_XTS_Final, MODES_XTS_DeInitCtx)
CIPHER_INIT_FUNC(MODES_CHACHA20POLY1305_InitCtx, MODES_CHACHA20POLY1305_Update, MODES_CHACHA20POLY1305_Final,
MODES_CHACHA20POLY1305_DeInitCtx)
const CRYPT_EAL_Func g_isoCbc[] = {
#ifdef HITLS_CRYPTO_CBC
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)MODES_CBC_NewCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_CBC_InitCtxExWrapper},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_CBC_UpdateExWrapper},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_CBC_FinalExWrapper},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CBC_DeInitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CBC_CtrlWrapper},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CBC_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoCcm[] = {
#ifdef HITLS_CRYPTO_CCM
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)MODES_CCM_NewCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_CCM_InitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_CCM_UpdateExWrapper},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_CCM_FinalWrapper},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CCM_DeInitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CCM_CtrlWrapper},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CCM_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoCfb[] = {
#ifdef HITLS_CRYPTO_CFB
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)MODES_CFB_NewCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_CFB_InitCtxExWrapper},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_CFB_UpdateExWrapper},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_CFB_FinalWrapper},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CFB_DeInitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CFB_CtrlWrapper},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CFB_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoChaCha[] = {
#if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)MODES_CHACHA20POLY1305_NewCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_CHACHA20POLY1305_InitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_CHACHA20POLY1305_UpdateWrapper},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_CHACHA20POLY1305_FinalWrapper},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CHACHA20POLY1305_DeInitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CHACHA20POLY1305_CtrlWrapper},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CHACHA20POLY1305_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoCtr[] = {
#ifdef HITLS_CRYPTO_CTR
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)MODES_CTR_NewCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_CTR_InitCtxExWrapper},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_CTR_UpdateExWrapper},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_CTR_FinalWrapper},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CTR_DeInitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CTR_CtrlWrapper},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CTR_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoEcb[] = {
#ifdef HITLS_CRYPTO_ECB
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)MODES_ECB_NewCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_ECB_InitCtxExWrapper},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_ECB_UpdateExWrapper},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_ECB_FinalWrapper},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_ECB_DeinitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_ECB_CtrlWrapper},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_ECB_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoGcm[] = {
#ifdef HITLS_CRYPTO_GCM
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)MODES_GCM_NewCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_GCM_InitCtxExWrapper},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_GCM_UpdateExWrapper},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_GCM_FinalWrapper},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_GCM_DeInitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_GCM_CtrlWrapper},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_GCM_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoOfb[] = {
#ifdef HITLS_CRYPTO_OFB
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)MODES_OFB_NewCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_OFB_InitCtxExWrapper},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_OFB_UpdateExWrapper},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_OFB_FinalWrapper},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_OFB_DeInitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_OFB_CtrlWrapper},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_OFB_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoXts[] = {
#ifdef HITLS_CRYPTO_XTS
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)MODES_XTS_NewCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_XTS_InitCtxExWrapper},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_XTS_UpdateExWrapper},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_XTS_FinalWrapper},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_XTS_DeInitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_XTS_CtrlWrapper},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_XTS_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */ | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/iso_prov/crypt_iso_cipher.c | C | unknown | 20,295 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "crypt_eal_implprovider.h"
#include "bsl_err_internal.h"
#include "crypt_errno.h"
#include "crypt_params_key.h"
#include "crypt_cmvp_selftest.h"
#include "crypt_iso_selftest.h"
#include "crypt_iso_provider.h"
#define ISO_19790_PROVIDER_VERSION "openHiTLS ISO 19790 Provider Version : V0.3.0"
typedef struct {
void *ctx;
void *provCtx;
void *libCtx;
} IsoSelftestCtx;
static IsoSelftestCtx *CRYPT_Selftest_NewCtx(CRYPT_EAL_IsoProvCtx *provCtx)
{
if (provCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return NULL;
}
IsoSelftestCtx *ctx = (IsoSelftestCtx *)BSL_SAL_Calloc(1, sizeof(IsoSelftestCtx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
ctx->provCtx = provCtx;
ctx->libCtx = provCtx->libCtx;
return ctx;
}
static const char *CRYPT_Selftest_GetVersion(IsoSelftestCtx *ctx)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return NULL;
}
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_GET_VERSION, 0, 0);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return NULL;
}
return ISO_19790_PROVIDER_VERSION;
}
static int32_t CRYPT_Selftest_Selftest(IsoSelftestCtx *ctx, const BSL_Param *param)
{
int32_t type = 0;
uint32_t len = sizeof(type);
if (ctx == NULL || param == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
const BSL_Param *temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_CMVP_SELFTEST_TYPE);
if (temp == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
int32_t ret = BSL_PARAM_GetValue(temp, CRYPT_PARAM_CMVP_SELFTEST_TYPE, BSL_PARAM_TYPE_INT32, &type, &len);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
int32_t event = 0;
switch (type) {
case CRYPT_CMVP_INTEGRITY_TEST:
event = CRYPT_EVENT_INTEGRITY_TEST;
break;
case CRYPT_CMVP_KAT_TEST:
event = CRYPT_EVENT_KAT_TEST;
break;
default:
BSL_ERR_PUSH_ERROR(CRYPT_NOT_SUPPORT);
return CRYPT_NOT_SUPPORT;
}
BSL_Param tmpParams[3] = {{0}, {0}, BSL_PARAM_END};
(void)BSL_PARAM_InitValue(&tmpParams[0], CRYPT_PARAM_EVENT, BSL_PARAM_TYPE_INT32, &event, sizeof(event));
(void)BSL_PARAM_InitValue(&tmpParams[1], CRYPT_PARAM_LIB_CTX, BSL_PARAM_TYPE_CTX_PTR, ctx->libCtx, 0);
return CRYPT_Iso_EventOperation(ctx->provCtx, tmpParams);
}
static void CRYPT_Selftest_FreeCtx(IsoSelftestCtx *ctx)
{
if (ctx == NULL) {
return;
}
BSL_SAL_Free(ctx);
}
const CRYPT_EAL_Func g_isoSelftest[] = {
{CRYPT_EAL_IMPLSELFTEST_NEWCTX, (CRYPT_EAL_ImplSelftestNewCtx)CRYPT_Selftest_NewCtx},
{CRYPT_EAL_IMPLSELFTEST_GETVERSION, (CRYPT_EAL_ImplSelftestGetVersion)CRYPT_Selftest_GetVersion},
{CRYPT_EAL_IMPLSELFTEST_SELFTEST, (CRYPT_EAL_ImplSelftestSelftest)CRYPT_Selftest_Selftest},
{CRYPT_EAL_IMPLSELFTEST_FREECTX, (CRYPT_EAL_ImplSelftestFreeCtx)CRYPT_Selftest_FreeCtx},
CRYPT_EAL_FUNC_END
};
#endif // HITLS_CRYPTO_CMVP_ISO19790
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/iso_prov/crypt_iso_cmvp.c | C | unknown | 3,801 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "crypt_eal_implprovider.h"
#include "crypt_pbkdf2.h"
#include "crypt_kdf_tls12.h"
#include "crypt_hkdf.h"
#include "crypt_scrypt.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "bsl_err_internal.h"
#include "crypt_cmvp.h"
#include "cmvp_iso19790.h"
#include "crypt_iso_selftest.h"
#include "crypt_iso_provider.h"
typedef struct {
int32_t algId;
void *ctx;
void *provCtx;
} IsoKdfCtx;
/* Constants for parameter validation */
#define KDF_DEF_MAC_ALGID CRYPT_MAC_HMAC_SHA256
#define KDF_DEF_SALT_LEN 16
#define KDF_DEF_PBKDF2_ITER 1024
#define KDF_DEF_KEY_LEN 16
static int32_t GetMacId(const BSL_Param *param, CRYPT_MAC_AlgId *macId)
{
int32_t id;
uint32_t len = sizeof(id);
const BSL_Param *temp = NULL;
if ((temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_KDF_MAC_ID)) == NULL) {
return CRYPT_SUCCESS;
}
int32_t ret = BSL_PARAM_GetValue(temp, CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32, &id, &len);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
*macId = (CRYPT_MAC_AlgId)id;
return CRYPT_SUCCESS;
}
static int32_t GetPbkdf2Params(const BSL_Param *param, CRYPT_EAL_Pbkdf2Param *pbkdf2Param)
{
uint32_t iter = 0;
uint32_t len = 0;
const BSL_Param *temp = NULL;
if ((temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_KDF_SALT)) != NULL) {
pbkdf2Param->saltLen = temp->valueLen;
}
if ((temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_KDF_ITER)) != NULL) {
len = sizeof(iter);
int32_t ret = BSL_PARAM_GetValue(temp, CRYPT_PARAM_KDF_ITER, BSL_PARAM_TYPE_UINT32, &iter, &len);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
pbkdf2Param->iter = iter;
}
return GetMacId(param, &pbkdf2Param->macId);
}
static int32_t GetHkdfAndTlskdfParam(const BSL_Param *param, CRYPT_EAL_HkdfParam *hkdf)
{
const BSL_Param *temp = NULL;
if ((temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_KDF_KEY)) != NULL) {
hkdf->keyLen = temp->valueLen;
}
return GetMacId(param, &hkdf->macId);
}
static int32_t CheckKdfParam(IsoKdfCtx *ctx, const BSL_Param *param)
{
int32_t ret = CRYPT_SUCCESS;
CRYPT_EAL_Pbkdf2Param pbkdf2 = {KDF_DEF_MAC_ALGID, KDF_DEF_SALT_LEN, KDF_DEF_PBKDF2_ITER, KDF_DEF_KEY_LEN};
CRYPT_EAL_HkdfParam hkdf = {KDF_DEF_MAC_ALGID, KDF_DEF_KEY_LEN};
CRYPT_EAL_KdfC2Data data = {&pbkdf2, &hkdf};
switch (ctx->algId) {
case CRYPT_KDF_HKDF:
case CRYPT_KDF_KDFTLS12:
ret = GetHkdfAndTlskdfParam(param, &hkdf);
break;
case CRYPT_KDF_PBKDF2:
ret = GetPbkdf2Params(param, &pbkdf2);
break;
default:
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
if (ret != CRYPT_SUCCESS) {
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_KDF, ctx->algId);
return ret;
}
if (!CMVP_Iso19790KdfC2(ctx->algId, &data)) {
BSL_ERR_PUSH_ERROR(CRYPT_CMVP_ERR_PARAM_CHECK);
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_KDF, ctx->algId);
return CRYPT_CMVP_ERR_PARAM_CHECK;
}
return ret;
}
/* Algorithm-specific parameter check functions */
static int32_t SSPLog(IsoKdfCtx *ctx, const BSL_Param *param, const int32_t *sspParam, uint32_t paramCount)
{
for (uint32_t i = 0; i < paramCount; i++) {
if (BSL_PARAM_FindConstParam(param, sspParam[i]) != NULL) {
return CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_SETSSP, CRYPT_ALGO_KDF, ctx->algId);
}
}
return CRYPT_SUCCESS;
}
#ifdef HITLS_CRYPTO_SCRYPT
static int32_t CheckSCRYPTParamAndLog(IsoKdfCtx *ctx, const BSL_Param *param)
{
int32_t sspParam[] = {CRYPT_PARAM_KDF_PASSWORD};
return SSPLog(ctx, param, sspParam, sizeof(sspParam)/sizeof(sspParam[0]));
}
#endif
#ifdef HITLS_CRYPTO_KDFTLS12
static int32_t CheckKDFTLS12ParamAndLog(IsoKdfCtx *ctx, const BSL_Param *param)
{
int32_t ret = CheckKdfParam(ctx, param);
if (ret != CRYPT_SUCCESS) {
return ret;
}
int32_t sspParam[] = {CRYPT_PARAM_KDF_KEY, CRYPT_PARAM_KDF_SEED};
return SSPLog(ctx, param, sspParam, sizeof(sspParam)/sizeof(sspParam[0]));
}
#endif
#ifdef HITLS_CRYPTO_HKDF
static int32_t CheckHKDFParamAndLog(IsoKdfCtx *ctx, const BSL_Param *param)
{
int32_t ret = CheckKdfParam(ctx, param);
if (ret != CRYPT_SUCCESS) {
return ret;
}
int32_t sspParam[] = {
CRYPT_PARAM_KDF_KEY, CRYPT_PARAM_KDF_PRK, CRYPT_PARAM_KDF_INFO
};
return SSPLog(ctx, param, sspParam, sizeof(sspParam)/sizeof(sspParam[0]));
}
#endif
static int32_t CheckPBKDF2ParamAndLog(IsoKdfCtx *ctx, const BSL_Param *param)
{
int32_t ret = CheckKdfParam(ctx, param);
if (ret != CRYPT_SUCCESS) {
return ret;
}
int32_t sspParam[] = {CRYPT_PARAM_KDF_PASSWORD};
return SSPLog(ctx, param, sspParam, sizeof(sspParam)/sizeof(sspParam[0]));
}
static int32_t CheckDeriveKeyLen(IsoKdfCtx *ctx, uint32_t len)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (ctx->algId != CRYPT_KDF_PBKDF2) {
return CRYPT_SUCCESS;
}
CRYPT_EAL_Pbkdf2Param pbkdf2Param = {KDF_DEF_MAC_ALGID, KDF_DEF_SALT_LEN, KDF_DEF_PBKDF2_ITER, len};
CRYPT_EAL_KdfC2Data data = {&pbkdf2Param, NULL};
if (!CMVP_Iso19790KdfC2(CRYPT_KDF_PBKDF2, &data)) {
BSL_ERR_PUSH_ERROR(CRYPT_CMVP_ERR_PARAM_CHECK);
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_KDF, ctx->algId);
return CRYPT_CMVP_ERR_PARAM_CHECK;
}
return CRYPT_SUCCESS;
}
#define KDF_METHOD_FUNC(name) \
static void *CRYPT_##name##_NewCtxExWrapper(CRYPT_EAL_IsoProvCtx *provCtx, int32_t algId) \
{ \
if (provCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return NULL; \
} \
void *kdfCtx = CRYPT_##name##_NewCtxEx(provCtx->libCtx); \
if (kdfCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
return NULL; \
} \
IsoKdfCtx *ctx = BSL_SAL_Calloc(1, sizeof(IsoKdfCtx)); \
if (ctx == NULL) { \
CRYPT_##name##_FreeCtx(kdfCtx); \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
return NULL; \
} \
ctx->algId = algId; \
ctx->ctx = kdfCtx; \
ctx->provCtx = provCtx; \
return ctx; \
} \
\
static int32_t CRYPT_##name##_SetParamWrapper(IsoKdfCtx *ctx, const BSL_Param *param) \
{ \
if (ctx == NULL || param == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = Check##name##ParamAndLog(ctx, param); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_SetParam(ctx->ctx, param); \
} \
\
static int32_t CRYPT_##name##_DeriveWrapper(IsoKdfCtx *ctx, uint8_t *out, uint32_t len) \
{ \
int32_t ret = CheckDeriveKeyLen(ctx, len); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_KDF, CRYPT_ALGO_KDF, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_Derive(ctx->ctx, out, len); \
} \
\
static int32_t CRYPT_##name##_DeinitWrapper(IsoKdfCtx *ctx) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_ZERO, CRYPT_ALGO_KDF, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_Deinit(ctx->ctx); \
} \
\
static void CRYPT_##name##_FreeCtxWrapper(IsoKdfCtx *ctx) \
{ \
if (ctx == NULL) { \
return; \
} \
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_ZERO, CRYPT_ALGO_KDF, ctx->algId); \
if (ctx->ctx != NULL) { \
CRYPT_##name##_FreeCtx(ctx->ctx); \
} \
BSL_SAL_Free(ctx); \
}
#ifdef HITLS_CRYPTO_SCRYPT
KDF_METHOD_FUNC(SCRYPT);
#endif
#ifdef HITLS_CRYPTO_PBKDF2
KDF_METHOD_FUNC(PBKDF2);
#endif
#ifdef HITLS_CRYPTO_KDFTLS12
KDF_METHOD_FUNC(KDFTLS12);
#endif
#ifdef HITLS_CRYPTO_HKDF
KDF_METHOD_FUNC(HKDF);
#endif
const CRYPT_EAL_Func g_isoKdfScrypt[] = {
#ifdef HITLS_CRYPTO_SCRYPT
{CRYPT_EAL_IMPLKDF_NEWCTX, (CRYPT_EAL_ImplKdfNewCtx)CRYPT_SCRYPT_NewCtxExWrapper},
{CRYPT_EAL_IMPLKDF_SETPARAM, (CRYPT_EAL_ImplKdfSetParam)CRYPT_SCRYPT_SetParamWrapper},
{CRYPT_EAL_IMPLKDF_DERIVE, (CRYPT_EAL_ImplKdfDerive)CRYPT_SCRYPT_DeriveWrapper},
{CRYPT_EAL_IMPLKDF_DEINITCTX, (CRYPT_EAL_ImplKdfDeInitCtx)CRYPT_SCRYPT_DeinitWrapper},
{CRYPT_EAL_IMPLKDF_FREECTX, (CRYPT_EAL_ImplKdfFreeCtx)CRYPT_SCRYPT_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKdfPBKdf2[] = {
#ifdef HITLS_CRYPTO_PBKDF2
{CRYPT_EAL_IMPLKDF_NEWCTX, (CRYPT_EAL_ImplKdfNewCtx)CRYPT_PBKDF2_NewCtxExWrapper},
{CRYPT_EAL_IMPLKDF_SETPARAM, (CRYPT_EAL_ImplKdfSetParam)CRYPT_PBKDF2_SetParamWrapper},
{CRYPT_EAL_IMPLKDF_DERIVE, (CRYPT_EAL_ImplKdfDerive)CRYPT_PBKDF2_DeriveWrapper},
{CRYPT_EAL_IMPLKDF_DEINITCTX, (CRYPT_EAL_ImplKdfDeInitCtx)CRYPT_PBKDF2_DeinitWrapper},
{CRYPT_EAL_IMPLKDF_FREECTX, (CRYPT_EAL_ImplKdfFreeCtx)CRYPT_PBKDF2_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKdfKdfTLS12[] = {
#ifdef HITLS_CRYPTO_KDFTLS12
{CRYPT_EAL_IMPLKDF_NEWCTX, (CRYPT_EAL_ImplKdfNewCtx)CRYPT_KDFTLS12_NewCtxExWrapper},
{CRYPT_EAL_IMPLKDF_SETPARAM, (CRYPT_EAL_ImplKdfSetParam)CRYPT_KDFTLS12_SetParamWrapper},
{CRYPT_EAL_IMPLKDF_DERIVE, (CRYPT_EAL_ImplKdfDerive)CRYPT_KDFTLS12_DeriveWrapper},
{CRYPT_EAL_IMPLKDF_DEINITCTX, (CRYPT_EAL_ImplKdfDeInitCtx)CRYPT_KDFTLS12_DeinitWrapper},
{CRYPT_EAL_IMPLKDF_FREECTX, (CRYPT_EAL_ImplKdfFreeCtx)CRYPT_KDFTLS12_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKdfHkdf[] = {
#ifdef HITLS_CRYPTO_HKDF
{CRYPT_EAL_IMPLKDF_NEWCTX, (CRYPT_EAL_ImplKdfNewCtx)CRYPT_HKDF_NewCtxExWrapper},
{CRYPT_EAL_IMPLKDF_SETPARAM, (CRYPT_EAL_ImplKdfSetParam)CRYPT_HKDF_SetParamWrapper},
{CRYPT_EAL_IMPLKDF_DERIVE, (CRYPT_EAL_ImplKdfDerive)CRYPT_HKDF_DeriveWrapper},
{CRYPT_EAL_IMPLKDF_DEINITCTX, (CRYPT_EAL_ImplKdfDeInitCtx)CRYPT_HKDF_DeinitWrapper},
{CRYPT_EAL_IMPLKDF_FREECTX, (CRYPT_EAL_ImplKdfFreeCtx)CRYPT_HKDF_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */ | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/iso_prov/crypt_iso_kdf.c | C | unknown | 17,063 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "crypt_eal_implprovider.h"
#ifdef HITLS_CRYPTO_MLKEM
#include "crypt_mlkem.h"
#endif
#include "bsl_err_internal.h"
#include "crypt_errno.h"
#include "crypt_iso_selftest.h"
#include "crypt_iso_provderimpl.h"
#ifdef HITLS_CRYPTO_MLKEM
static int32_t CRYPT_ML_KEM_EncapsWrapper(const CRYPT_Iso_Pkey_Ctx *ctx, uint8_t *cipher, uint32_t *cipherLen,
uint8_t *share, uint32_t *shareLen)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_ENCAPS, CRYPT_ALGO_PKEY, ctx->algId);
if (ret != CRYPT_SUCCESS) {
return ret;
}
return CRYPT_ML_KEM_Encaps(ctx->ctx, cipher, cipherLen, share, shareLen);
}
static int32_t CRYPT_ML_KEM_DecapsWrapper(const CRYPT_Iso_Pkey_Ctx *ctx, uint8_t *cipher, uint32_t cipherLen,
uint8_t *share, uint32_t *shareLen)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_DECAPS, CRYPT_ALGO_PKEY, ctx->algId);
if (ret != CRYPT_SUCCESS) {
return ret;
}
return CRYPT_ML_KEM_Decaps(ctx->ctx, cipher, cipherLen, share, shareLen);
}
#endif
const CRYPT_EAL_Func g_isoMlKem[] = {
#ifdef HITLS_CRYPTO_MLKEM
{CRYPT_EAL_IMPLPKEYKEM_ENCAPSULATE, (CRYPT_EAL_ImplPkeyKemEncapsulate)CRYPT_ML_KEM_EncapsWrapper},
{CRYPT_EAL_IMPLPKEYKEM_DECAPSULATE, (CRYPT_EAL_ImplPkeyKemDecapsulate)CRYPT_ML_KEM_DecapsWrapper},
#endif
CRYPT_EAL_FUNC_END
};
#endif // HITLS_CRYPTO_CMVP_ISO19790
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/iso_prov/crypt_iso_kem.c | C | unknown | 2,186 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "crypt_eal_implprovider.h"
#include "crypt_curve25519.h"
#include "crypt_dh.h"
#include "crypt_ecdh.h"
#include "crypt_sm2.h"
#include "bsl_err_internal.h"
#include "crypt_errno.h"
#include "crypt_iso_selftest.h"
#include "crypt_iso_provderimpl.h"
#define KEY_EXCH_FUNC(name) \
static int32_t name##Wrapper(const CRYPT_Iso_Pkey_Ctx *prvKey, const CRYPT_Iso_Pkey_Ctx *pubKey, \
uint8_t *sharedKey, uint32_t *shareKeyLen) \
{ \
if (prvKey == NULL || pubKey == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(prvKey->provCtx, CRYPT_EVENT_KEYAGGREMENT, CRYPT_ALGO_PKEY, prvKey->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return (name)(prvKey->ctx, pubKey->ctx, sharedKey, shareKeyLen); \
}
#ifdef HITLS_CRYPTO_X25519
KEY_EXCH_FUNC(CRYPT_CURVE25519_ComputeSharedKey)
#endif
#ifdef HITLS_CRYPTO_DH
KEY_EXCH_FUNC(CRYPT_DH_ComputeShareKey)
#endif
#ifdef HITLS_CRYPTO_ECDH
KEY_EXCH_FUNC(CRYPT_ECDH_ComputeShareKey)
#endif
#ifdef HITLS_CRYPTO_SM2_EXCH
KEY_EXCH_FUNC(CRYPT_SM2_KapComputeKey)
#endif
const CRYPT_EAL_Func g_isoExchX25519[] = {
#ifdef HITLS_CRYPTO_X25519
{CRYPT_EAL_IMPLPKEYEXCH_EXCH, (CRYPT_EAL_ImplPkeyExch)CRYPT_CURVE25519_ComputeSharedKeyWrapper},
#endif
CRYPT_EAL_FUNC_END
};
const CRYPT_EAL_Func g_isoExchDh[] = {
#ifdef HITLS_CRYPTO_DH
{CRYPT_EAL_IMPLPKEYEXCH_EXCH, (CRYPT_EAL_ImplPkeyExch)CRYPT_DH_ComputeShareKeyWrapper},
#endif
CRYPT_EAL_FUNC_END
};
const CRYPT_EAL_Func g_isoExchEcdh[] = {
#ifdef HITLS_CRYPTO_ECDH
{CRYPT_EAL_IMPLPKEYEXCH_EXCH, (CRYPT_EAL_ImplPkeyExch)CRYPT_ECDH_ComputeShareKeyWrapper},
#endif
CRYPT_EAL_FUNC_END
};
const CRYPT_EAL_Func g_isoExchSm2[] = {
#if defined(HITLS_CRYPTO_SM2_EXCH)
{CRYPT_EAL_IMPLPKEYEXCH_EXCH, (CRYPT_EAL_ImplPkeyExch)CRYPT_SM2_KapComputeKeyWrapper},
#endif
CRYPT_EAL_FUNC_END
};
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */ | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/iso_prov/crypt_iso_keyexch.c | C | unknown | 3,481 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "crypt_eal_implprovider.h"
#ifdef HITLS_CRYPTO_DSA
#include "crypt_dsa.h"
#endif
#ifdef HITLS_CRYPTO_CURVE25519
#include "crypt_curve25519.h"
#endif
#ifdef HITLS_CRYPTO_RSA
#include "crypt_rsa.h"
#endif
#ifdef HITLS_CRYPTO_DH
#include "crypt_dh.h"
#endif
#ifdef HITLS_CRYPTO_ECDSA
#include "crypt_ecdsa.h"
#endif
#ifdef HITLS_CRYPTO_ECDH
#include "crypt_ecdh.h"
#endif
#ifdef HITLS_CRYPTO_SM2
#include "crypt_sm2.h"
#endif
#ifdef HITLS_CRYPTO_SLH_DSA
#include "crypt_slh_dsa.h"
#endif
#ifdef HITLS_CRYPTO_MLKEM
#include "crypt_mlkem.h"
#endif
#ifdef HITLS_CRYPTO_MLDSA
#include "crypt_mldsa.h"
#endif
#include "crypt_errno.h"
#include "bsl_err_internal.h"
#include "crypt_ealinit.h"
#include "crypt_iso_provider.h"
#include "crypt_eal_pkey.h"
#include "crypt_cmvp.h"
#include "crypt_iso_selftest.h"
#include "crypt_iso_provderimpl.h"
#include "cmvp_iso19790.h"
#define PKEY_PCT_PARAM_COUNT 4
static int32_t ParaCheckAndLog(const CRYPT_Iso_Pkey_Ctx *ctx, const CRYPT_EAL_PkeyPara *para)
{
CRYPT_EAL_PkeyC2Data data = {para, NULL, NULL, CRYPT_MD_MAX, CRYPT_PKEY_PARAID_MAX, CRYPT_EVENT_MAX,
NULL, NULL, NULL};
if (!CMVP_Iso19790PkeyC2(ctx->algId, &data)) {
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_PKEY, ctx->algId);
return CRYPT_CMVP_ERR_PARAM_CHECK;
}
return CRYPT_SUCCESS;
}
static int32_t GetParamValue(const BSL_Param *params, int32_t paramId, uint8_t **value, uint32_t *valueLen)
{
const BSL_Param *param = BSL_PARAM_FindConstParam(params, paramId);
if (param == NULL || (param->value == NULL && param->valueLen != 0)) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
*value = param->value;
*valueLen = param->valueLen;
return CRYPT_SUCCESS;
}
static int32_t CheckDsaPara(const CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *params)
{
CRYPT_EAL_PkeyPara para = {0};
int32_t ret = GetParamValue(params, CRYPT_PARAM_DSA_P, ¶.para.dsaPara.p, ¶.para.dsaPara.pLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
ret = GetParamValue(params, CRYPT_PARAM_DSA_Q, ¶.para.dsaPara.q, ¶.para.dsaPara.qLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
ret = GetParamValue(params, CRYPT_PARAM_DSA_G, ¶.para.dsaPara.g, ¶.para.dsaPara.gLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
return ParaCheckAndLog(ctx, ¶);
}
static int32_t GetRsaBits(const BSL_Param *params, uint32_t *bits)
{
uint32_t bitsLen = sizeof(*bits);
const BSL_Param *temp = BSL_PARAM_FindConstParam(params, CRYPT_PARAM_RSA_BITS);
if (temp == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
int32_t ret = BSL_PARAM_GetValue(temp, CRYPT_PARAM_RSA_BITS, BSL_PARAM_TYPE_UINT32, bits, &bitsLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
return CRYPT_SUCCESS;
}
static int32_t CheckRsaPara(const CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *params)
{
uint32_t bits = 0;
int32_t ret = GetRsaBits(params, &bits);
if (ret != CRYPT_SUCCESS) {
return ret;
}
CRYPT_EAL_PkeyPara para = {0};
para.para.rsaPara.bits = bits;
return ParaCheckAndLog(ctx, ¶);
}
static int32_t CheckDhPara(const CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *params)
{
CRYPT_EAL_PkeyPara para = {0};
int32_t ret = GetParamValue(params, CRYPT_PARAM_DH_P, ¶.para.dhPara.p, ¶.para.dhPara.pLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
ret = GetParamValue(params, CRYPT_PARAM_DH_Q, ¶.para.dhPara.q, ¶.para.dhPara.qLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
return ParaCheckAndLog(ctx, ¶);
}
static int32_t CheckPkeyParam(const CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *params)
{
switch (ctx->algId) {
case CRYPT_PKEY_DH:
return CheckDhPara(ctx, params);
case CRYPT_PKEY_DSA:
return CheckDsaPara(ctx, params);
case CRYPT_PKEY_RSA:
return CheckRsaPara(ctx, params);
default:
return CRYPT_SUCCESS;
}
}
static int32_t CheckSetRsaPrvKey(CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *params)
{
CRYPT_EAL_PkeyPrv prv = {0};
int32_t ret = GetParamValue(params, CRYPT_PARAM_RSA_N, &prv.key.rsaPrv.n, &prv.key.rsaPrv.nLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
ret = GetParamValue(params, CRYPT_PARAM_RSA_D, &prv.key.rsaPrv.d, &prv.key.rsaPrv.dLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
CRYPT_EAL_PkeyC2Data data = {NULL, NULL, &prv, CRYPT_MD_MAX, CRYPT_PKEY_PARAID_MAX, CRYPT_EVENT_MAX,
NULL, NULL, NULL};
if (!CMVP_Iso19790PkeyC2(ctx->algId, &data)) {
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_PKEY, ctx->algId);
return CRYPT_CMVP_ERR_PARAM_CHECK;
}
return CRYPT_SUCCESS;
}
static int32_t CheckSetPrvKey(CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *params)
{
if (ctx->algId == CRYPT_PKEY_RSA) {
return CheckSetRsaPrvKey(ctx, params);
}
return CRYPT_SUCCESS;
}
static int32_t CheckSetRsaPubKey(CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *params)
{
CRYPT_EAL_PkeyPub pub = {0};
int32_t ret = GetParamValue(params, CRYPT_PARAM_RSA_N, &pub.key.rsaPub.n, &pub.key.rsaPub.nLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
CRYPT_EAL_PkeyC2Data data = {NULL, &pub, NULL, CRYPT_MD_MAX, CRYPT_PKEY_PARAID_MAX, CRYPT_EVENT_MAX,
NULL, NULL, NULL};
if (!CMVP_Iso19790PkeyC2(ctx->algId, &data)) {
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_PKEY, ctx->algId);
return CRYPT_CMVP_ERR_PARAM_CHECK;
}
return CRYPT_SUCCESS;
}
static int32_t CheckSetPubKey(CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *params)
{
if (ctx->algId == CRYPT_PKEY_RSA) {
return CheckSetRsaPubKey(ctx, params);
}
return CRYPT_SUCCESS;
}
static int32_t CheckParaId(CRYPT_Iso_Pkey_Ctx *ctx, int32_t opt, void *val, uint32_t len)
{
if (opt != CRYPT_CTRL_SET_PARA_BY_ID) {
return CRYPT_SUCCESS;
}
if (val == NULL || len != sizeof(CRYPT_PKEY_ParaId)) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
CRYPT_EAL_PkeyC2Data data = {NULL, NULL, NULL, CRYPT_MD_MAX, *(CRYPT_PKEY_ParaId *)val, CRYPT_EVENT_MAX,
NULL, NULL, NULL};
if (!CMVP_Iso19790PkeyC2(ctx->algId, &data)) {
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_PKEY, ctx->algId);
return CRYPT_CMVP_ERR_PARAM_CHECK;
}
return CRYPT_SUCCESS;
}
static int32_t CheckRsaPadding(CRYPT_Iso_Pkey_Ctx *ctx, int32_t opt, void *val, uint32_t len)
{
if (ctx->algId != CRYPT_PKEY_RSA) {
return CRYPT_SUCCESS;
}
int32_t ret = CRYPT_SUCCESS;
do {
if (opt == CRYPT_CTRL_SET_RSA_RSAES_PKCSV15 || opt == CRYPT_CTRL_SET_RSA_RSAES_PKCSV15_TLS ||
opt == CRYPT_CTRL_SET_NO_PADDING) {
ret = CRYPT_CMVP_ERR_PARAM_CHECK;
break;
}
if (opt == CRYPT_CTRL_SET_RSA_PADDING) {
if (val == NULL || len != sizeof(int32_t)) {
ret = CRYPT_NULL_INPUT;
break;
}
int32_t padType = *(int32_t *)val;
if (padType != CRYPT_EMSA_PKCSV15 && padType != CRYPT_EMSA_PSS && padType != CRYPT_RSAES_OAEP) {
ret = CRYPT_CMVP_ERR_PARAM_CHECK;
break;
}
}
} while (0);
if (ret != CRYPT_SUCCESS) {
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_PKEY, ctx->algId);
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
}
static int32_t CheckRsaMdId(CRYPT_Iso_Pkey_Ctx *ctx, int32_t opt, void *val, uint32_t len)
{
CRYPT_RSA_PkcsV15Para pkcsv15 = {0};
CRYPT_EAL_PkeyC2Data data = {NULL, NULL, NULL, CRYPT_MD_MAX, CRYPT_PKEY_PARAID_MAX, CRYPT_EVENT_MAX,
NULL, NULL, NULL};
switch (opt) {
case CRYPT_CTRL_SET_RSA_EMSA_PKCSV15:
if (val == NULL || len != sizeof(int32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
pkcsv15.mdId = *(int32_t *)val;
data.pkcsv15 = &pkcsv15;
break;
case CRYPT_CTRL_SET_RSA_EMSA_PSS:
data.pss = (BSL_Param *)val;
break;
case CRYPT_CTRL_SET_RSA_RSAES_OAEP:
data.oaep = (BSL_Param *)val;
break;
default:
return CRYPT_SUCCESS;
}
if (!CMVP_Iso19790PkeyC2(ctx->algId, &data)) {
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_PKEY, ctx->algId);
return CRYPT_CMVP_ERR_PARAM_CHECK;
}
return CRYPT_SUCCESS;
}
static int32_t PkeyCtrlCheck(CRYPT_Iso_Pkey_Ctx *ctx, int32_t opt, void *val, uint32_t len)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
int32_t ret = CheckParaId(ctx, opt, val, len);
if (ret != CRYPT_SUCCESS) {
return ret;
}
ret = CheckRsaPadding(ctx, opt, val, len);
if (ret != CRYPT_SUCCESS) {
return ret;
}
return CheckRsaMdId(ctx, opt, val, len);
}
static int32_t CRYPT_ASMCAP_PkeyCheck(int32_t algId)
{
#ifdef HITLS_CRYPTO_ASM_CHECK
if (CRYPT_ASMCAP_Pkey(algId) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
}
#else
(void)algId;
#endif
return CRYPT_SUCCESS;
}
#define PKEY_NEW_Ctx_FUNC(name) \
static void *CRYPT_##name##_NewCtxExWrapper(CRYPT_EAL_IsoProvCtx *provCtx, int32_t algId) \
{ \
if (CRYPT_ASMCAP_PkeyCheck(algId) != CRYPT_SUCCESS) { \
return NULL; \
} \
if (provCtx == NULL || provCtx->libCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return NULL; \
} \
CRYPT_Iso_Pkey_Ctx *ctx = (CRYPT_Iso_Pkey_Ctx *)BSL_SAL_Calloc(1, sizeof(CRYPT_Iso_Pkey_Ctx)); \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
return NULL; \
} \
void *pkeyCtx = CRYPT_##name##_NewCtxEx(provCtx->libCtx); \
if (pkeyCtx == NULL) { \
BSL_SAL_Free(ctx); \
return NULL; \
} \
ctx->algId = algId; \
ctx->ctx = pkeyCtx; \
ctx->provCtx = provCtx; \
return ctx; \
}
#define PKEY_SET_PARA_FUNC(name) \
static int32_t CRYPT_##name##_SetParaWrapper(CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *param) \
{ \
if (ctx == NULL || param == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CheckPkeyParam(ctx, param); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_SetParaEx(ctx->ctx, param); \
}
#define PKEY_GET_PARA_FUNC(name) \
static int32_t CRYPT_##name##_GetParaWrapper(const CRYPT_Iso_Pkey_Ctx *ctx, BSL_Param *param) \
{ \
if (ctx == NULL || param == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CheckPkeyParam(ctx, param); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_GetParaEx(ctx->ctx, param); \
}
#define PKEY_GEN_KEY_FUNC(name) \
static int32_t name##Wrapper(CRYPT_Iso_Pkey_Ctx *ctx) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_GEN, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
ret = (name)(ctx->ctx); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PCT_TEST, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
if (!CMVP_Iso19790PkeyPct(ctx)) { \
return CRYPT_CMVP_ERR_PAIRWISETEST; \
} \
return CRYPT_SUCCESS; \
}
#define PKEY_SET_KEY_FUNC(setPrvFunc, setPubFunc) \
static int32_t setPrvFunc##Wrapper(CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *para) \
{ \
if (ctx == NULL || para == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CheckSetPrvKey(ctx, para); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_SETSSP, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return (setPrvFunc)(ctx->ctx, para); \
} \
\
static int32_t setPubFunc##Wrapper(CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *para) \
{ \
if (ctx == NULL || para == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CheckSetPubKey(ctx, para); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_SETSSP, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return (setPubFunc)(ctx->ctx, para); \
}
#define PKEY_GET_KEY_FUNC(getPrvFunc, getPubFunc) \
static int32_t getPrvFunc##Wrapper(const CRYPT_Iso_Pkey_Ctx *ctx, BSL_Param *para) \
{ \
if (ctx == NULL || para == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_GETSSP, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return (getPrvFunc)(ctx->ctx, para); \
} \
\
static int32_t getPubFunc##Wrapper(const CRYPT_Iso_Pkey_Ctx *ctx, BSL_Param *para) \
{ \
if (ctx == NULL || para == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_GETSSP, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return (getPubFunc)(ctx->ctx, para); \
}
#define PKEY_DUP_CTX_FUNC(name) \
static CRYPT_Iso_Pkey_Ctx *CRYPT_##name##_DupCtxWrapper(CRYPT_Iso_Pkey_Ctx *ctx) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return NULL; \
} \
CRYPT_Iso_Pkey_Ctx *newCtx = (CRYPT_Iso_Pkey_Ctx *)BSL_SAL_Calloc(1, sizeof(CRYPT_Iso_Pkey_Ctx)); \
if (newCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
return NULL; \
} \
void *pkeyCtx = CRYPT_##name##_DupCtx(ctx->ctx); \
if (pkeyCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
BSL_SAL_Free(newCtx); \
return NULL; \
} \
newCtx->algId = ctx->algId; \
newCtx->ctx = pkeyCtx; \
newCtx->provCtx = ctx->provCtx; \
return newCtx; \
}
#define PKEY_CMP_FUNC(name) \
static int32_t CRYPT_##name##_CmpWrapper(const CRYPT_Iso_Pkey_Ctx *a, const CRYPT_Iso_Pkey_Ctx *b) \
{ \
if (a == NULL || b == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return CRYPT_##name##_Cmp(a->ctx, b->ctx); \
}
#define PKEY_CTRL_FUNC(name) \
static int32_t CRYPT_##name##_CtrlWrapper(CRYPT_Iso_Pkey_Ctx *ctx, int32_t opt, void *val, uint32_t len) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = PkeyCtrlCheck(ctx, opt, val, len); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_Ctrl(ctx->ctx, opt, val, len); \
}
#define PKEY_FREE_CTX_FUNC(name) \
static void CRYPT_##name##_FreeCtxWrapper(CRYPT_Iso_Pkey_Ctx *ctx) \
{ \
if (ctx == NULL) { \
return; \
} \
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_ZERO, CRYPT_ALGO_PKEY, ctx->algId); \
if (ctx->algId == CRYPT_PKEY_SLH_DSA || ctx->algId == CRYPT_PKEY_ML_DSA || \
ctx->algId == CRYPT_PKEY_ML_KEM) { \
CRYPT_##name##_Ctrl(ctx->ctx, CRYPT_CTRL_CLEAN_PUB_KEY, NULL, 0); \
} \
if (ctx->ctx != NULL) { \
CRYPT_##name##_FreeCtx(ctx->ctx); \
} \
BSL_SAL_Free(ctx); \
}
#define PKEY_IMPORT_EXPORT_FUNC(name) \
static int32_t CRYPT_##name##_ImportWrapper(CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *params) \
{ \
if (ctx == NULL || params == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_SETSSP, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_Import(ctx->ctx, params); \
} \
\
static int32_t CRYPT_##name##_ExportWrapper(const CRYPT_Iso_Pkey_Ctx *ctx, BSL_Param *params) \
{ \
if (ctx == NULL || params == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_GETSSP, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_Export(ctx->ctx, params); \
}
#define PKEY_CHECK_FUNC(name) \
static int32_t CRYPT_##name##_CheckWrapper(uint32_t checkType, const CRYPT_Iso_Pkey_Ctx *ctx1, \
const CRYPT_Iso_Pkey_Ctx *ctx2) \
{ \
return CRYPT_##name##_Check(checkType, ctx1 != NULL ? ctx1->ctx : NULL, \
ctx2 != NULL ? ctx2->ctx : NULL); \
}
PKEY_NEW_Ctx_FUNC(DSA)
PKEY_NEW_Ctx_FUNC(ED25519)
PKEY_NEW_Ctx_FUNC(X25519)
PKEY_NEW_Ctx_FUNC(RSA)
PKEY_NEW_Ctx_FUNC(DH)
PKEY_NEW_Ctx_FUNC(ECDSA)
PKEY_NEW_Ctx_FUNC(ECDH)
PKEY_NEW_Ctx_FUNC(SM2)
PKEY_NEW_Ctx_FUNC(SLH_DSA)
PKEY_NEW_Ctx_FUNC(ML_KEM)
PKEY_NEW_Ctx_FUNC(ML_DSA)
PKEY_SET_PARA_FUNC(DSA)
PKEY_SET_PARA_FUNC(RSA)
PKEY_SET_PARA_FUNC(DH)
PKEY_SET_PARA_FUNC(ECDSA)
PKEY_SET_PARA_FUNC(ECDH)
PKEY_GET_PARA_FUNC(DSA)
PKEY_GET_PARA_FUNC(DH)
PKEY_GET_PARA_FUNC(ECDSA)
PKEY_GET_PARA_FUNC(ECDH)
PKEY_GEN_KEY_FUNC(CRYPT_DSA_Gen)
PKEY_GEN_KEY_FUNC(CRYPT_ED25519_GenKey)
PKEY_GEN_KEY_FUNC(CRYPT_X25519_GenKey)
PKEY_GEN_KEY_FUNC(CRYPT_RSA_Gen)
PKEY_GEN_KEY_FUNC(CRYPT_DH_Gen)
PKEY_GEN_KEY_FUNC(CRYPT_ECDSA_Gen)
PKEY_GEN_KEY_FUNC(CRYPT_ECDH_Gen)
PKEY_GEN_KEY_FUNC(CRYPT_SM2_Gen)
PKEY_GEN_KEY_FUNC(CRYPT_SLH_DSA_Gen)
PKEY_GEN_KEY_FUNC(CRYPT_ML_KEM_GenKey)
PKEY_GEN_KEY_FUNC(CRYPT_ML_DSA_GenKey)
PKEY_SET_KEY_FUNC(CRYPT_DSA_SetPrvKeyEx, CRYPT_DSA_SetPubKeyEx)
PKEY_SET_KEY_FUNC(CRYPT_CURVE25519_SetPrvKeyEx, CRYPT_CURVE25519_SetPubKeyEx)
PKEY_SET_KEY_FUNC(CRYPT_RSA_SetPrvKeyEx, CRYPT_RSA_SetPubKeyEx)
PKEY_SET_KEY_FUNC(CRYPT_DH_SetPrvKeyEx, CRYPT_DH_SetPubKeyEx)
PKEY_SET_KEY_FUNC(CRYPT_ECDSA_SetPrvKeyEx, CRYPT_ECDSA_SetPubKeyEx)
PKEY_SET_KEY_FUNC(CRYPT_ECDH_SetPrvKeyEx, CRYPT_ECDH_SetPubKeyEx)
PKEY_SET_KEY_FUNC(CRYPT_SM2_SetPrvKeyEx, CRYPT_SM2_SetPubKeyEx)
PKEY_SET_KEY_FUNC(CRYPT_ML_KEM_SetDecapsKeyEx, CRYPT_ML_KEM_SetEncapsKeyEx)
PKEY_SET_KEY_FUNC(CRYPT_ML_DSA_SetPrvKeyEx, CRYPT_ML_DSA_SetPubKeyEx)
PKEY_SET_KEY_FUNC(CRYPT_SLH_DSA_SetPrvKeyEx, CRYPT_SLH_DSA_SetPubKeyEx)
PKEY_GET_KEY_FUNC(CRYPT_DSA_GetPrvKeyEx, CRYPT_DSA_GetPubKeyEx)
PKEY_GET_KEY_FUNC(CRYPT_CURVE25519_GetPrvKeyEx, CRYPT_CURVE25519_GetPubKeyEx)
PKEY_GET_KEY_FUNC(CRYPT_RSA_GetPrvKeyEx, CRYPT_RSA_GetPubKeyEx)
PKEY_GET_KEY_FUNC(CRYPT_DH_GetPrvKeyEx, CRYPT_DH_GetPubKeyEx)
PKEY_GET_KEY_FUNC(CRYPT_ECDSA_GetPrvKeyEx, CRYPT_ECDSA_GetPubKeyEx)
PKEY_GET_KEY_FUNC(CRYPT_ECDH_GetPrvKeyEx, CRYPT_ECDH_GetPubKeyEx)
PKEY_GET_KEY_FUNC(CRYPT_SM2_GetPrvKeyEx, CRYPT_SM2_GetPubKeyEx)
PKEY_GET_KEY_FUNC(CRYPT_ML_KEM_GetDecapsKeyEx, CRYPT_ML_KEM_GetEncapsKeyEx)
PKEY_GET_KEY_FUNC(CRYPT_ML_DSA_GetPrvKeyEx, CRYPT_ML_DSA_GetPubKeyEx)
PKEY_GET_KEY_FUNC(CRYPT_SLH_DSA_GetPrvKeyEx, CRYPT_SLH_DSA_GetPubKeyEx)
PKEY_DUP_CTX_FUNC(DSA)
PKEY_DUP_CTX_FUNC(CURVE25519)
PKEY_DUP_CTX_FUNC(RSA)
PKEY_DUP_CTX_FUNC(DH)
PKEY_DUP_CTX_FUNC(ECDSA)
PKEY_DUP_CTX_FUNC(ECDH)
PKEY_DUP_CTX_FUNC(SM2)
PKEY_DUP_CTX_FUNC(ML_KEM)
PKEY_DUP_CTX_FUNC(ML_DSA)
PKEY_CMP_FUNC(DSA)
PKEY_CMP_FUNC(CURVE25519)
PKEY_CMP_FUNC(RSA)
PKEY_CMP_FUNC(DH)
PKEY_CMP_FUNC(ECDSA)
PKEY_CMP_FUNC(ECDH)
PKEY_CMP_FUNC(SM2)
PKEY_CMP_FUNC(ML_KEM)
PKEY_CMP_FUNC(ML_DSA)
PKEY_CTRL_FUNC(DSA)
PKEY_CTRL_FUNC(CURVE25519)
PKEY_CTRL_FUNC(RSA)
PKEY_CTRL_FUNC(DH)
PKEY_CTRL_FUNC(ECDSA)
PKEY_CTRL_FUNC(ECDH)
PKEY_CTRL_FUNC(SM2)
PKEY_CTRL_FUNC(ML_KEM)
PKEY_CTRL_FUNC(ML_DSA)
PKEY_CTRL_FUNC(SLH_DSA)
PKEY_FREE_CTX_FUNC(DSA)
PKEY_FREE_CTX_FUNC(CURVE25519)
PKEY_FREE_CTX_FUNC(RSA)
PKEY_FREE_CTX_FUNC(DH)
PKEY_FREE_CTX_FUNC(ECDSA)
PKEY_FREE_CTX_FUNC(ECDH)
PKEY_FREE_CTX_FUNC(SM2)
PKEY_FREE_CTX_FUNC(ML_KEM)
PKEY_FREE_CTX_FUNC(ML_DSA)
PKEY_FREE_CTX_FUNC(SLH_DSA)
PKEY_IMPORT_EXPORT_FUNC(CURVE25519)
PKEY_IMPORT_EXPORT_FUNC(RSA)
PKEY_IMPORT_EXPORT_FUNC(ECDSA)
PKEY_IMPORT_EXPORT_FUNC(SM2)
PKEY_CHECK_FUNC(DSA)
PKEY_CHECK_FUNC(ED25519)
PKEY_CHECK_FUNC(X25519)
PKEY_CHECK_FUNC(RSA)
PKEY_CHECK_FUNC(DH)
PKEY_CHECK_FUNC(ECDSA)
PKEY_CHECK_FUNC(ECDH)
PKEY_CHECK_FUNC(SM2)
PKEY_CHECK_FUNC(ML_KEM)
PKEY_CHECK_FUNC(ML_DSA)
PKEY_CHECK_FUNC(SLH_DSA)
const CRYPT_EAL_Func g_isoKeyMgmtDsa[] = {
#ifdef HITLS_CRYPTO_DSA
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_DSA_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, (CRYPT_EAL_ImplPkeyMgmtSetParam)CRYPT_DSA_SetParaWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPARAM, (CRYPT_EAL_ImplPkeyMgmtGetParam)CRYPT_DSA_GetParaWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_DSA_GenWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_DSA_SetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_DSA_SetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_DSA_GetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_DSA_GetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)CRYPT_DSA_DupCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_DSA_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_COMPARE, (CRYPT_EAL_ImplPkeyMgmtCompare)CRYPT_DSA_CmpWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_DSA_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_DSA_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKeyMgmtEd25519[] = {
#ifdef HITLS_CRYPTO_ED25519
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_ED25519_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_ED25519_GenKeyWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_CURVE25519_SetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_CURVE25519_SetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_CURVE25519_GetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_CURVE25519_GetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)CRYPT_CURVE25519_DupCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_ED25519_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_COMPARE, (CRYPT_EAL_ImplPkeyMgmtCompare)CRYPT_CURVE25519_CmpWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_CURVE25519_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_CURVE25519_FreeCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_IMPORT, (CRYPT_EAL_ImplPkeyMgmtImport)CRYPT_CURVE25519_ImportWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_EXPORT, (CRYPT_EAL_ImplPkeyMgmtExport)CRYPT_CURVE25519_ExportWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKeyMgmtX25519[] = {
#ifdef HITLS_CRYPTO_X25519
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_X25519_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_X25519_GenKeyWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_CURVE25519_SetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_CURVE25519_SetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_CURVE25519_GetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_CURVE25519_GetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)CRYPT_CURVE25519_DupCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_X25519_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_COMPARE, (CRYPT_EAL_ImplPkeyMgmtCompare)CRYPT_CURVE25519_CmpWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_CURVE25519_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_CURVE25519_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKeyMgmtRsa[] = {
#ifdef HITLS_CRYPTO_RSA
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_RSA_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, (CRYPT_EAL_ImplPkeyMgmtSetParam)CRYPT_RSA_SetParaWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_RSA_GenWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_RSA_SetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_RSA_SetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_RSA_GetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_RSA_GetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)CRYPT_RSA_DupCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_RSA_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_COMPARE, (CRYPT_EAL_ImplPkeyMgmtCompare)CRYPT_RSA_CmpWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_RSA_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_RSA_FreeCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_IMPORT, (CRYPT_EAL_ImplPkeyMgmtImport)CRYPT_RSA_ImportWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_EXPORT, (CRYPT_EAL_ImplPkeyMgmtExport)CRYPT_RSA_ExportWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKeyMgmtDh[] = {
#ifdef HITLS_CRYPTO_DH
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_DH_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, (CRYPT_EAL_ImplPkeyMgmtSetParam)CRYPT_DH_SetParaWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPARAM, (CRYPT_EAL_ImplPkeyMgmtGetParam)CRYPT_DH_GetParaWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_DH_GenWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_DH_SetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_DH_SetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_DH_GetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_DH_GetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)CRYPT_DH_DupCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_DH_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_COMPARE, (CRYPT_EAL_ImplPkeyMgmtCompare)CRYPT_DH_CmpWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_DH_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_DH_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKeyMgmtEcdsa[] = {
#ifdef HITLS_CRYPTO_ECDSA
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_ECDSA_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, (CRYPT_EAL_ImplPkeyMgmtSetParam)CRYPT_ECDSA_SetParaWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPARAM, (CRYPT_EAL_ImplPkeyMgmtGetParam)CRYPT_ECDSA_GetParaWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_ECDSA_GenWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_ECDSA_SetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_ECDSA_SetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_ECDSA_GetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_ECDSA_GetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)CRYPT_ECDSA_DupCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_ECDSA_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_COMPARE, (CRYPT_EAL_ImplPkeyMgmtCompare)CRYPT_ECDSA_CmpWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_ECDSA_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_ECDSA_FreeCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_IMPORT, (CRYPT_EAL_ImplPkeyMgmtImport)CRYPT_ECDSA_ImportWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_EXPORT, (CRYPT_EAL_ImplPkeyMgmtExport)CRYPT_ECDSA_ExportWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKeyMgmtEcdh[] = {
#ifdef HITLS_CRYPTO_ECDH
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_ECDH_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, (CRYPT_EAL_ImplPkeyMgmtSetParam)CRYPT_ECDH_SetParaWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPARAM, (CRYPT_EAL_ImplPkeyMgmtGetParam)CRYPT_ECDH_GetParaWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_ECDH_GenWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_ECDH_SetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_ECDH_SetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_ECDH_GetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_ECDH_GetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)CRYPT_ECDH_DupCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_ECDH_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_COMPARE, (CRYPT_EAL_ImplPkeyMgmtCompare)CRYPT_ECDH_CmpWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_ECDH_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_ECDH_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKeyMgmtSm2[] = {
#ifdef HITLS_CRYPTO_SM2
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_SM2_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_SM2_GenWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_SM2_SetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_SM2_SetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_SM2_GetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_SM2_GetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)CRYPT_SM2_DupCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_SM2_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_COMPARE, (CRYPT_EAL_ImplPkeyMgmtCompare)CRYPT_SM2_CmpWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_SM2_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_SM2_FreeCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_IMPORT, (CRYPT_EAL_ImplPkeyMgmtImport)CRYPT_SM2_ImportWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_EXPORT, (CRYPT_EAL_ImplPkeyMgmtExport)CRYPT_SM2_ExportWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKeyMgmtMlKem[] = {
#ifdef HITLS_CRYPTO_MLKEM
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_ML_KEM_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_ML_KEM_GenKeyWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_ML_KEM_SetDecapsKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_ML_KEM_SetEncapsKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_ML_KEM_GetDecapsKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_ML_KEM_GetEncapsKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)CRYPT_ML_KEM_DupCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_ML_KEM_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_COMPARE, (CRYPT_EAL_ImplPkeyMgmtCompare)CRYPT_ML_KEM_CmpWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_ML_KEM_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_ML_KEM_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKeyMgmtMlDsa[] = {
#ifdef HITLS_CRYPTO_MLDSA
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_ML_DSA_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_ML_DSA_GenKeyWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_ML_DSA_SetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_ML_DSA_SetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_ML_DSA_GetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_ML_DSA_GetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)CRYPT_ML_DSA_DupCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_ML_DSA_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_COMPARE, (CRYPT_EAL_ImplPkeyMgmtCompare)CRYPT_ML_DSA_CmpWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_ML_DSA_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_ML_DSA_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKeyMgmtSlhDsa[] = {
#ifdef HITLS_CRYPTO_SLH_DSA
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_SLH_DSA_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_SLH_DSA_GenWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_SLH_DSA_SetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_SLH_DSA_SetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_SLH_DSA_GetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_SLH_DSA_GetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_SLH_DSA_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_SLH_DSA_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_SLH_DSA_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */ | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/iso_prov/crypt_iso_keymgmt.c | C | unknown | 52,129 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "crypt_eal_implprovider.h"
#include "crypt_hmac.h"
#include "crypt_cmac.h"
#include "crypt_cbc_mac.h"
#include "crypt_gmac.h"
#include "crypt_siphash.h"
#include "crypt_ealinit.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "bsl_log_internal.h"
#include "bsl_err_internal.h"
#include "cmvp_iso19790.h"
#include "crypt_iso_selftest.h"
#include "crypt_iso_provider.h"
#define MAC_KEY_LEN_MIN 14
typedef struct {
int32_t algId;
void *ctx;
void *provCtx;
} IsoMacCtx;
static int32_t CRYPT_ASMCAP_MacCheck(int32_t algId)
{
#ifdef HITLS_CRYPTO_ASM_CHECK
if (CRYPT_ASMCAP_Mac(algId) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
}
#else
(void)algId;
#endif
return CRYPT_SUCCESS;
}
static int32_t CheckMacKeyLen(IsoMacCtx *ctx, uint32_t keyLen)
{
if (!CMVP_Iso19790MacC2(ctx->algId, keyLen)) {
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_MAC, ctx->algId);
BSL_ERR_PUSH_ERROR(CRYPT_CMVP_ERR_PARAM_CHECK);
return CRYPT_CMVP_ERR_PARAM_CHECK;
}
return CRYPT_SUCCESS;
}
#define MAC_NewCtx_FUNC(name) \
static void *CRYPT_##name##_NewCtxExWrapper(CRYPT_EAL_IsoProvCtx *provCtx, int32_t algId) \
{ \
if (CRYPT_ASMCAP_MacCheck(algId) != CRYPT_SUCCESS) { \
return NULL; \
} \
if (provCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return NULL; \
} \
void *macCtx = CRYPT_##name##_NewCtxEx(provCtx->libCtx, algId); \
if (macCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
return NULL; \
} \
IsoMacCtx *ctx = BSL_SAL_Calloc(1, sizeof(IsoMacCtx)); \
if (ctx == NULL) { \
CRYPT_##name##_FreeCtx(macCtx); \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
return NULL; \
} \
ctx->algId = algId; \
ctx->ctx = macCtx; \
ctx->provCtx = provCtx; \
return ctx; \
}
#define MAC_INIT_FUNC(name) \
static int32_t CRYPT_##name##_InitWrapper(IsoMacCtx *ctx, const uint8_t *key, uint32_t len, void *param) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_MAC, CRYPT_ALGO_MAC, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
ret = CheckMacKeyLen(ctx, len); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_SETSSP, CRYPT_ALGO_MAC, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_Init(ctx->ctx, key, len, param); \
}
#define MAC_Update_FUNC(name) \
static int32_t CRYPT_##name##_UpdateWrapper(IsoMacCtx *ctx, const uint8_t *in, uint32_t len) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return CRYPT_##name##_Update(ctx->ctx, in, len); \
}
#define MAC_Final_FUNC(name) \
static int32_t CRYPT_##name##_FinalWrapper(IsoMacCtx *ctx, uint8_t *out, uint32_t *len) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return CRYPT_##name##_Final(ctx->ctx, out, len); \
}
#define MAC_Ctrl_FUNC(name) \
static int32_t CRYPT_##name##_CtrlWrapper(IsoMacCtx *ctx, CRYPT_MacCtrl opt, void *val, uint32_t len) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return CRYPT_##name##_Ctrl(ctx->ctx, opt, val, len); \
}
#define MAC_FreeCtx_FUNC(name) \
static void CRYPT_##name##_FreeCtxWrapper(IsoMacCtx *ctx) \
{ \
if (ctx == NULL) { \
return; \
} \
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_ZERO, CRYPT_ALGO_MAC, ctx->algId); \
if (ctx->ctx != NULL) { \
CRYPT_##name##_FreeCtx(ctx->ctx); \
} \
BSL_SAL_Free(ctx); \
}
#define MAC_DEINIT_FUNC(name) \
static int32_t CRYPT_##name##_DeinitWrapper(IsoMacCtx *ctx) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_ZERO, CRYPT_ALGO_MAC, ctx->algId); \
return CRYPT_##name##_Deinit(ctx->ctx); \
}
#define MAC_REINIT_FUNC(name) \
static int32_t CRYPT_##name##_ReinitWrapper(IsoMacCtx *ctx) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return CRYPT_##name##_Reinit(ctx->ctx); \
}
#define MAC_SET_PARAM_FUNC(name) \
static int32_t CRYPT_##name##_SetParamWrapper(IsoMacCtx *ctx, const BSL_Param *param) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return CRYPT_##name##_SetParam(ctx->ctx, param); \
}
#define MAC_FUNCS(name) \
MAC_NewCtx_FUNC(name) \
MAC_INIT_FUNC(name) \
MAC_Update_FUNC(name) \
MAC_Final_FUNC(name) \
MAC_DEINIT_FUNC(name) \
MAC_Ctrl_FUNC(name) \
MAC_FreeCtx_FUNC(name)
#ifdef HITLS_CRYPTO_HMAC
MAC_FUNCS(HMAC)
MAC_REINIT_FUNC(HMAC)
MAC_SET_PARAM_FUNC(HMAC)
#endif
#ifdef HITLS_CRYPTO_CMAC
MAC_FUNCS(CMAC)
MAC_REINIT_FUNC(CMAC)
#endif
#ifdef HITLS_CRYPTO_GMAC
MAC_FUNCS(GMAC)
#endif
const CRYPT_EAL_Func g_isoMacHmac[] = {
#ifdef HITLS_CRYPTO_HMAC
{CRYPT_EAL_IMPLMAC_NEWCTX, (CRYPT_EAL_ImplMacNewCtx)CRYPT_HMAC_NewCtxExWrapper},
{CRYPT_EAL_IMPLMAC_INIT, (CRYPT_EAL_ImplMacInit)CRYPT_HMAC_InitWrapper},
{CRYPT_EAL_IMPLMAC_UPDATE, (CRYPT_EAL_ImplMacUpdate)CRYPT_HMAC_UpdateWrapper},
{CRYPT_EAL_IMPLMAC_FINAL, (CRYPT_EAL_ImplMacFinal)CRYPT_HMAC_FinalWrapper},
{CRYPT_EAL_IMPLMAC_DEINITCTX, (CRYPT_EAL_ImplMacDeInitCtx)CRYPT_HMAC_DeinitWrapper},
{CRYPT_EAL_IMPLMAC_REINITCTX, (CRYPT_EAL_ImplMacReInitCtx)CRYPT_HMAC_ReinitWrapper},
{CRYPT_EAL_IMPLMAC_CTRL, (CRYPT_EAL_ImplMacCtrl)CRYPT_HMAC_CtrlWrapper},
{CRYPT_EAL_IMPLMAC_FREECTX, (CRYPT_EAL_ImplMacFreeCtx)CRYPT_HMAC_FreeCtxWrapper},
{CRYPT_EAL_IMPLMAC_SETPARAM, (CRYPT_EAL_ImplMacSetParam)CRYPT_HMAC_SetParamWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoMacCmac[] = {
#ifdef HITLS_CRYPTO_CMAC
{CRYPT_EAL_IMPLMAC_NEWCTX, (CRYPT_EAL_ImplMacNewCtx)CRYPT_CMAC_NewCtxExWrapper},
{CRYPT_EAL_IMPLMAC_INIT, (CRYPT_EAL_ImplMacInit)CRYPT_CMAC_InitWrapper},
{CRYPT_EAL_IMPLMAC_UPDATE, (CRYPT_EAL_ImplMacUpdate)CRYPT_CMAC_UpdateWrapper},
{CRYPT_EAL_IMPLMAC_FINAL, (CRYPT_EAL_ImplMacFinal)CRYPT_CMAC_FinalWrapper},
{CRYPT_EAL_IMPLMAC_DEINITCTX, (CRYPT_EAL_ImplMacDeInitCtx)CRYPT_CMAC_DeinitWrapper},
{CRYPT_EAL_IMPLMAC_REINITCTX, (CRYPT_EAL_ImplMacReInitCtx)CRYPT_CMAC_ReinitWrapper},
{CRYPT_EAL_IMPLMAC_CTRL, (CRYPT_EAL_ImplMacCtrl)CRYPT_CMAC_CtrlWrapper},
{CRYPT_EAL_IMPLMAC_FREECTX, (CRYPT_EAL_ImplMacFreeCtx)CRYPT_CMAC_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoMacGmac[] = {
#ifdef HITLS_CRYPTO_GMAC
{CRYPT_EAL_IMPLMAC_NEWCTX, (CRYPT_EAL_ImplMacNewCtx)CRYPT_GMAC_NewCtxExWrapper},
{CRYPT_EAL_IMPLMAC_INIT, (CRYPT_EAL_ImplMacInit)CRYPT_GMAC_InitWrapper},
{CRYPT_EAL_IMPLMAC_UPDATE, (CRYPT_EAL_ImplMacUpdate)CRYPT_GMAC_UpdateWrapper},
{CRYPT_EAL_IMPLMAC_FINAL, (CRYPT_EAL_ImplMacFinal)CRYPT_GMAC_FinalWrapper},
{CRYPT_EAL_IMPLMAC_DEINITCTX, (CRYPT_EAL_ImplMacDeInitCtx)CRYPT_GMAC_DeinitWrapper},
{CRYPT_EAL_IMPLMAC_REINITCTX, NULL},
{CRYPT_EAL_IMPLMAC_CTRL, (CRYPT_EAL_ImplMacCtrl)CRYPT_GMAC_CtrlWrapper},
{CRYPT_EAL_IMPLMAC_FREECTX, (CRYPT_EAL_ImplMacFreeCtx)CRYPT_GMAC_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */ | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/iso_prov/crypt_iso_mac.c | C | unknown | 16,515 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "crypt_eal_implprovider.h"
#include "crypt_md5.h"
#include "crypt_sha1.h"
#include "crypt_sha2.h"
#include "crypt_sha3.h"
#include "crypt_sm3.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "bsl_err_internal.h"
#include "crypt_ealinit.h"
#include "crypt_iso_selftest.h"
#include "crypt_iso_provider.h"
typedef struct {
int32_t algId;
void *ctx;
void *provCtx;
} IsoMdCtx;
static uint32_t CRYPT_ASMCAP_Test(int32_t algId)
{
#ifdef HITLS_CRYPTO_ASM_CHECK
if (CRYPT_ASMCAP_Md(algId) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
}
#else
(void)algId;
#endif
return CRYPT_SUCCESS;
}
#define MD_METHOD_FUNC(name) \
static IsoMdCtx *CRYPT_##name##_NewCtxExWrapper(CRYPT_EAL_IsoProvCtx *provCtx, int32_t algId) \
{ \
int32_t ret = CRYPT_ASMCAP_Test(algId); \
if (ret != CRYPT_SUCCESS) { \
return NULL; \
} \
if (provCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return NULL; \
} \
void *mdCtx = CRYPT_##name##_NewCtxEx(provCtx->libCtx, algId); \
if (mdCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
return NULL; \
} \
IsoMdCtx *ctx = BSL_SAL_Calloc(1, sizeof(IsoMdCtx)); \
if (ctx == NULL) { \
CRYPT_##name##_FreeCtx(mdCtx); \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
return NULL; \
} \
ctx->algId = algId; \
ctx->ctx = mdCtx; \
ctx->provCtx = provCtx; \
return ctx; \
} \
\
static int32_t CRYPT_##name##_InitWrapper(IsoMdCtx *ctx, BSL_Param *param) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_MD, CRYPT_ALGO_MD, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_Init(ctx->ctx, param); \
} \
\
static int32_t CRYPT_##name##_UpdateWrapper(IsoMdCtx *ctx, const uint8_t *data, uint32_t nbytes) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return CRYPT_##name##_Update(ctx->ctx, data, nbytes); \
} \
\
static int32_t CRYPT_##name##_FinalWrapper(IsoMdCtx *ctx, uint8_t *digest, uint32_t *len) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return CRYPT_##name##_Final(ctx->ctx, digest, len); \
} \
\
static int32_t CRYPT_##name##_DeinitWrapper(IsoMdCtx *ctx) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return CRYPT_##name##_Deinit(ctx->ctx); \
} \
\
static IsoMdCtx *CRYPT_##name##_DupCtxWrapper(const IsoMdCtx *src) \
{ \
if (src == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return NULL; \
} \
void *mdCtx = CRYPT_##name##_DupCtx(src->ctx); \
if (mdCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
return NULL; \
} \
IsoMdCtx *dupCtx = BSL_SAL_Calloc(1, sizeof(IsoMdCtx)); \
if (dupCtx == NULL) { \
CRYPT_##name##_FreeCtx(mdCtx); \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
return NULL; \
} \
dupCtx->algId = src->algId; \
dupCtx->ctx = mdCtx; \
dupCtx->provCtx = src->provCtx; \
return dupCtx; \
} \
\
static void CRYPT_##name##_FreeCtxWrapper(IsoMdCtx *ctx) \
{ \
if (ctx == NULL) { \
return; \
} \
if (ctx->ctx != NULL) { \
CRYPT_##name##_FreeCtx(ctx->ctx); \
} \
BSL_SAL_Free(ctx); \
} \
\
static int32_t CRYPT_##name##_GetParamWrapper(IsoMdCtx *ctx, BSL_Param *param) \
{ \
(void)ctx; \
return CRYPT_##name##_GetParam(NULL, param); \
} \
\
static int32_t CRYPT_##name##_CopyCtxWrapper(IsoMdCtx *dst, const IsoMdCtx *src) \
{ \
if (dst == NULL || src == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
dst->algId = src->algId; \
dst->provCtx = src->provCtx; \
return CRYPT_##name##_CopyCtx(dst->ctx, src->ctx); \
}
MD_METHOD_FUNC(SHA1)
MD_METHOD_FUNC(SHA2_224)
MD_METHOD_FUNC(SHA2_256)
MD_METHOD_FUNC(SHA2_384)
MD_METHOD_FUNC(SHA2_512)
MD_METHOD_FUNC(SHA3_224)
MD_METHOD_FUNC(SHA3_256)
MD_METHOD_FUNC(SHA3_384)
MD_METHOD_FUNC(SHA3_512)
MD_METHOD_FUNC(SHAKE128)
MD_METHOD_FUNC(SHAKE256)
MD_METHOD_FUNC(SM3)
#define MD_SQUEEZE_FUNC(name) \
static int32_t CRYPT_##name##_SqueezeWrapper(IsoMdCtx *ctx, uint8_t *out, uint32_t len) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return CRYPT_##name##_Squeeze(ctx->ctx, out, len); \
}
MD_SQUEEZE_FUNC(SHAKE128)
MD_SQUEEZE_FUNC(SHAKE256)
const CRYPT_EAL_Func g_isoMdSha1[] = {
#ifdef HITLS_CRYPTO_SHA1
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_SHA1_NewCtxExWrapper},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHA1_InitWrapper},
{CRYPT_EAL_IMPLMD_UPDATE, (CRYPT_EAL_ImplMdUpdate)CRYPT_SHA1_UpdateWrapper},
{CRYPT_EAL_IMPLMD_FINAL, (CRYPT_EAL_ImplMdFinal)CRYPT_SHA1_FinalWrapper},
{CRYPT_EAL_IMPLMD_DEINITCTX, (CRYPT_EAL_ImplMdDeInitCtx)CRYPT_SHA1_DeinitWrapper},
{CRYPT_EAL_IMPLMD_DUPCTX, (CRYPT_EAL_ImplMdDupCtx)CRYPT_SHA1_DupCtxWrapper},
{CRYPT_EAL_IMPLMD_FREECTX, (CRYPT_EAL_ImplMdFreeCtx)CRYPT_SHA1_FreeCtxWrapper},
{CRYPT_EAL_IMPLMD_COPYCTX, (CRYPT_EAL_ImplMdCopyCtx)CRYPT_SHA1_CopyCtxWrapper},
{CRYPT_EAL_IMPLMD_GETPARAM, (CRYPT_EAL_ImplMdGetParam)CRYPT_SHA1_GetParamWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoMdSha224[] = {
#ifdef HITLS_CRYPTO_SHA224
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_SHA2_224_NewCtxExWrapper},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHA2_224_InitWrapper},
{CRYPT_EAL_IMPLMD_UPDATE, (CRYPT_EAL_ImplMdUpdate)CRYPT_SHA2_224_UpdateWrapper},
{CRYPT_EAL_IMPLMD_FINAL, (CRYPT_EAL_ImplMdFinal)CRYPT_SHA2_224_FinalWrapper},
{CRYPT_EAL_IMPLMD_DEINITCTX, (CRYPT_EAL_ImplMdDeInitCtx)CRYPT_SHA2_224_DeinitWrapper},
{CRYPT_EAL_IMPLMD_DUPCTX, (CRYPT_EAL_ImplMdDupCtx)CRYPT_SHA2_224_DupCtxWrapper},
{CRYPT_EAL_IMPLMD_FREECTX, (CRYPT_EAL_ImplMdFreeCtx)CRYPT_SHA2_224_FreeCtxWrapper},
{CRYPT_EAL_IMPLMD_COPYCTX, (CRYPT_EAL_ImplMdCopyCtx)CRYPT_SHA2_224_CopyCtxWrapper},
{CRYPT_EAL_IMPLMD_GETPARAM, (CRYPT_EAL_ImplMdGetParam)CRYPT_SHA2_224_GetParamWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoMdSha256[] = {
#ifdef HITLS_CRYPTO_SHA256
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_SHA2_256_NewCtxExWrapper},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHA2_256_InitWrapper},
{CRYPT_EAL_IMPLMD_UPDATE, (CRYPT_EAL_ImplMdUpdate)CRYPT_SHA2_256_UpdateWrapper},
{CRYPT_EAL_IMPLMD_FINAL, (CRYPT_EAL_ImplMdFinal)CRYPT_SHA2_256_FinalWrapper},
{CRYPT_EAL_IMPLMD_DEINITCTX, (CRYPT_EAL_ImplMdDeInitCtx)CRYPT_SHA2_256_DeinitWrapper},
{CRYPT_EAL_IMPLMD_DUPCTX, (CRYPT_EAL_ImplMdDupCtx)CRYPT_SHA2_256_DupCtxWrapper},
{CRYPT_EAL_IMPLMD_FREECTX, (CRYPT_EAL_ImplMdFreeCtx)CRYPT_SHA2_256_FreeCtxWrapper},
{CRYPT_EAL_IMPLMD_COPYCTX, (CRYPT_EAL_ImplMdCopyCtx)CRYPT_SHA2_256_CopyCtxWrapper},
{CRYPT_EAL_IMPLMD_GETPARAM, (CRYPT_EAL_ImplMdGetParam)CRYPT_SHA2_256_GetParamWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoMdSha384[] = {
#ifdef HITLS_CRYPTO_SHA384
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_SHA2_384_NewCtxExWrapper},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHA2_384_InitWrapper},
{CRYPT_EAL_IMPLMD_UPDATE, (CRYPT_EAL_ImplMdUpdate)CRYPT_SHA2_384_UpdateWrapper},
{CRYPT_EAL_IMPLMD_FINAL, (CRYPT_EAL_ImplMdFinal)CRYPT_SHA2_384_FinalWrapper},
{CRYPT_EAL_IMPLMD_DEINITCTX, (CRYPT_EAL_ImplMdDeInitCtx)CRYPT_SHA2_384_DeinitWrapper},
{CRYPT_EAL_IMPLMD_DUPCTX, (CRYPT_EAL_ImplMdDupCtx)CRYPT_SHA2_384_DupCtxWrapper},
{CRYPT_EAL_IMPLMD_FREECTX, (CRYPT_EAL_ImplMdFreeCtx)CRYPT_SHA2_384_FreeCtxWrapper},
{CRYPT_EAL_IMPLMD_COPYCTX, (CRYPT_EAL_ImplMdCopyCtx)CRYPT_SHA2_384_CopyCtxWrapper},
{CRYPT_EAL_IMPLMD_GETPARAM, (CRYPT_EAL_ImplMdGetParam)CRYPT_SHA2_384_GetParamWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoMdSha512[] = {
#ifdef HITLS_CRYPTO_SHA512
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_SHA2_512_NewCtxExWrapper},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHA2_512_InitWrapper},
{CRYPT_EAL_IMPLMD_UPDATE, (CRYPT_EAL_ImplMdUpdate)CRYPT_SHA2_512_UpdateWrapper},
{CRYPT_EAL_IMPLMD_FINAL, (CRYPT_EAL_ImplMdFinal)CRYPT_SHA2_512_FinalWrapper},
{CRYPT_EAL_IMPLMD_DEINITCTX, (CRYPT_EAL_ImplMdDeInitCtx)CRYPT_SHA2_512_DeinitWrapper},
{CRYPT_EAL_IMPLMD_DUPCTX, (CRYPT_EAL_ImplMdDupCtx)CRYPT_SHA2_512_DupCtxWrapper},
{CRYPT_EAL_IMPLMD_FREECTX, (CRYPT_EAL_ImplMdFreeCtx)CRYPT_SHA2_512_FreeCtxWrapper},
{CRYPT_EAL_IMPLMD_COPYCTX, (CRYPT_EAL_ImplMdCopyCtx)CRYPT_SHA2_512_CopyCtxWrapper},
{CRYPT_EAL_IMPLMD_GETPARAM, (CRYPT_EAL_ImplMdGetParam)CRYPT_SHA2_512_GetParamWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoMdSha3224[] = {
#ifdef HITLS_CRYPTO_SHA3
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_SHA3_224_NewCtxExWrapper},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHA3_224_InitWrapper},
{CRYPT_EAL_IMPLMD_UPDATE, (CRYPT_EAL_ImplMdUpdate)CRYPT_SHA3_224_UpdateWrapper},
{CRYPT_EAL_IMPLMD_FINAL, (CRYPT_EAL_ImplMdFinal)CRYPT_SHA3_224_FinalWrapper},
{CRYPT_EAL_IMPLMD_DEINITCTX, (CRYPT_EAL_ImplMdDeInitCtx)CRYPT_SHA3_224_DeinitWrapper},
{CRYPT_EAL_IMPLMD_DUPCTX, (CRYPT_EAL_ImplMdDupCtx)CRYPT_SHA3_224_DupCtxWrapper},
{CRYPT_EAL_IMPLMD_FREECTX, (CRYPT_EAL_ImplMdFreeCtx)CRYPT_SHA3_224_FreeCtxWrapper},
{CRYPT_EAL_IMPLMD_COPYCTX, (CRYPT_EAL_ImplMdCopyCtx)CRYPT_SHA3_224_CopyCtxWrapper},
{CRYPT_EAL_IMPLMD_GETPARAM, (CRYPT_EAL_ImplMdGetParam)CRYPT_SHA3_224_GetParamWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoMdSha3256[] = {
#ifdef HITLS_CRYPTO_SHA3
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_SHA3_256_NewCtxExWrapper},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHA3_256_InitWrapper},
{CRYPT_EAL_IMPLMD_UPDATE, (CRYPT_EAL_ImplMdUpdate)CRYPT_SHA3_256_UpdateWrapper},
{CRYPT_EAL_IMPLMD_FINAL, (CRYPT_EAL_ImplMdFinal)CRYPT_SHA3_256_FinalWrapper},
{CRYPT_EAL_IMPLMD_DEINITCTX, (CRYPT_EAL_ImplMdDeInitCtx)CRYPT_SHA3_256_DeinitWrapper},
{CRYPT_EAL_IMPLMD_DUPCTX, (CRYPT_EAL_ImplMdDupCtx)CRYPT_SHA3_256_DupCtxWrapper},
{CRYPT_EAL_IMPLMD_FREECTX, (CRYPT_EAL_ImplMdFreeCtx)CRYPT_SHA3_256_FreeCtxWrapper},
{CRYPT_EAL_IMPLMD_COPYCTX, (CRYPT_EAL_ImplMdCopyCtx)CRYPT_SHA3_256_CopyCtxWrapper},
{CRYPT_EAL_IMPLMD_GETPARAM, (CRYPT_EAL_ImplMdGetParam)CRYPT_SHA3_256_GetParamWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoMdSha3384[] = {
#ifdef HITLS_CRYPTO_SHA3
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_SHA3_384_NewCtxExWrapper},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHA3_384_InitWrapper},
{CRYPT_EAL_IMPLMD_UPDATE, (CRYPT_EAL_ImplMdUpdate)CRYPT_SHA3_384_UpdateWrapper},
{CRYPT_EAL_IMPLMD_FINAL, (CRYPT_EAL_ImplMdFinal)CRYPT_SHA3_384_FinalWrapper},
{CRYPT_EAL_IMPLMD_DEINITCTX, (CRYPT_EAL_ImplMdDeInitCtx)CRYPT_SHA3_384_DeinitWrapper},
{CRYPT_EAL_IMPLMD_DUPCTX, (CRYPT_EAL_ImplMdDupCtx)CRYPT_SHA3_384_DupCtxWrapper},
{CRYPT_EAL_IMPLMD_FREECTX, (CRYPT_EAL_ImplMdFreeCtx)CRYPT_SHA3_384_FreeCtxWrapper},
{CRYPT_EAL_IMPLMD_COPYCTX, (CRYPT_EAL_ImplMdCopyCtx)CRYPT_SHA3_384_CopyCtxWrapper},
{CRYPT_EAL_IMPLMD_GETPARAM, (CRYPT_EAL_ImplMdGetParam)CRYPT_SHA3_384_GetParamWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoMdSha3512[] = {
#ifdef HITLS_CRYPTO_SHA3
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_SHA3_512_NewCtxExWrapper},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHA3_512_InitWrapper},
{CRYPT_EAL_IMPLMD_UPDATE, (CRYPT_EAL_ImplMdUpdate)CRYPT_SHA3_512_UpdateWrapper},
{CRYPT_EAL_IMPLMD_FINAL, (CRYPT_EAL_ImplMdFinal)CRYPT_SHA3_512_FinalWrapper},
{CRYPT_EAL_IMPLMD_DEINITCTX, (CRYPT_EAL_ImplMdDeInitCtx)CRYPT_SHA3_512_DeinitWrapper},
{CRYPT_EAL_IMPLMD_DUPCTX, (CRYPT_EAL_ImplMdDupCtx)CRYPT_SHA3_512_DupCtxWrapper},
{CRYPT_EAL_IMPLMD_FREECTX, (CRYPT_EAL_ImplMdFreeCtx)CRYPT_SHA3_512_FreeCtxWrapper},
{CRYPT_EAL_IMPLMD_COPYCTX, (CRYPT_EAL_ImplMdCopyCtx)CRYPT_SHA3_512_CopyCtxWrapper},
{CRYPT_EAL_IMPLMD_GETPARAM, (CRYPT_EAL_ImplMdGetParam)CRYPT_SHA3_512_GetParamWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoMdShake128[] = {
#ifdef HITLS_CRYPTO_SHA3
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_SHAKE128_NewCtxExWrapper},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHAKE128_InitWrapper},
{CRYPT_EAL_IMPLMD_UPDATE, (CRYPT_EAL_ImplMdUpdate)CRYPT_SHAKE128_UpdateWrapper},
{CRYPT_EAL_IMPLMD_FINAL, (CRYPT_EAL_ImplMdFinal)CRYPT_SHAKE128_FinalWrapper},
{CRYPT_EAL_IMPLMD_DEINITCTX, (CRYPT_EAL_ImplMdDeInitCtx)CRYPT_SHAKE128_DeinitWrapper},
{CRYPT_EAL_IMPLMD_DUPCTX, (CRYPT_EAL_ImplMdDupCtx)CRYPT_SHAKE128_DupCtxWrapper},
{CRYPT_EAL_IMPLMD_FREECTX, (CRYPT_EAL_ImplMdFreeCtx)CRYPT_SHAKE128_FreeCtxWrapper},
{CRYPT_EAL_IMPLMD_SQUEEZE, (CRYPT_EAL_ImplMdSqueeze)CRYPT_SHAKE128_SqueezeWrapper},
{CRYPT_EAL_IMPLMD_COPYCTX, (CRYPT_EAL_ImplMdCopyCtx)CRYPT_SHAKE128_CopyCtxWrapper},
{CRYPT_EAL_IMPLMD_GETPARAM, (CRYPT_EAL_ImplMdGetParam)CRYPT_SHAKE128_GetParamWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoMdShake256[] = {
#ifdef HITLS_CRYPTO_SHA3
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_SHAKE256_NewCtxExWrapper},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SHAKE256_InitWrapper},
{CRYPT_EAL_IMPLMD_UPDATE, (CRYPT_EAL_ImplMdUpdate)CRYPT_SHAKE256_UpdateWrapper},
{CRYPT_EAL_IMPLMD_FINAL, (CRYPT_EAL_ImplMdFinal)CRYPT_SHAKE256_FinalWrapper},
{CRYPT_EAL_IMPLMD_DEINITCTX, (CRYPT_EAL_ImplMdDeInitCtx)CRYPT_SHAKE256_DeinitWrapper},
{CRYPT_EAL_IMPLMD_DUPCTX, (CRYPT_EAL_ImplMdDupCtx)CRYPT_SHAKE256_DupCtxWrapper},
{CRYPT_EAL_IMPLMD_FREECTX, (CRYPT_EAL_ImplMdFreeCtx)CRYPT_SHAKE256_FreeCtxWrapper},
{CRYPT_EAL_IMPLMD_SQUEEZE, (CRYPT_EAL_ImplMdSqueeze)CRYPT_SHAKE256_SqueezeWrapper},
{CRYPT_EAL_IMPLMD_COPYCTX, (CRYPT_EAL_ImplMdCopyCtx)CRYPT_SHAKE256_CopyCtxWrapper},
{CRYPT_EAL_IMPLMD_GETPARAM, (CRYPT_EAL_ImplMdGetParam)CRYPT_SHAKE256_GetParamWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoMdSm3[] = {
#ifdef HITLS_CRYPTO_SM3
{CRYPT_EAL_IMPLMD_NEWCTX, (CRYPT_EAL_ImplMdNewCtx)CRYPT_SM3_NewCtxExWrapper},
{CRYPT_EAL_IMPLMD_INITCTX, (CRYPT_EAL_ImplMdInitCtx)CRYPT_SM3_InitWrapper},
{CRYPT_EAL_IMPLMD_UPDATE, (CRYPT_EAL_ImplMdUpdate)CRYPT_SM3_UpdateWrapper},
{CRYPT_EAL_IMPLMD_FINAL, (CRYPT_EAL_ImplMdFinal)CRYPT_SM3_FinalWrapper},
{CRYPT_EAL_IMPLMD_DEINITCTX, (CRYPT_EAL_ImplMdDeInitCtx)CRYPT_SM3_DeinitWrapper},
{CRYPT_EAL_IMPLMD_DUPCTX, (CRYPT_EAL_ImplMdDupCtx)CRYPT_SM3_DupCtxWrapper},
{CRYPT_EAL_IMPLMD_FREECTX, (CRYPT_EAL_ImplMdFreeCtx)CRYPT_SM3_FreeCtxWrapper},
{CRYPT_EAL_IMPLMD_COPYCTX, (CRYPT_EAL_ImplMdCopyCtx)CRYPT_SM3_CopyCtxWrapper},
{CRYPT_EAL_IMPLMD_GETPARAM, (CRYPT_EAL_ImplMdGetParam)CRYPT_SM3_GetParamWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */ | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/iso_prov/crypt_iso_md.c | C | unknown | 25,596 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "crypt_eal_implprovider.h"
#include "crypt_rsa.h"
#include "crypt_sm2.h"
#include "crypt_paillier.h"
#include "crypt_elgamal.h"
#include "bsl_err_internal.h"
#include "crypt_errno.h"
#include "crypt_iso_selftest.h"
#include "crypt_iso_provderimpl.h"
#define PKEY_CIPHER_FUNC(name) \
static int32_t CRYPT_##name##_EncryptWrapper(CRYPT_Iso_Pkey_Ctx *ctx, const uint8_t *data, uint32_t dataLen, \
uint8_t *out, uint32_t *outLen) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_ENC, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_Encrypt(ctx->ctx, data, dataLen, out, outLen); \
} \
\
static int32_t CRYPT_##name##_DecryptWrapper(CRYPT_Iso_Pkey_Ctx *ctx, const uint8_t *data, uint32_t dataLen, \
uint8_t *out, uint32_t *outLen) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_DEC, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_Decrypt(ctx->ctx, data, dataLen, out, outLen); \
}
PKEY_CIPHER_FUNC(RSA)
PKEY_CIPHER_FUNC(SM2)
const CRYPT_EAL_Func g_isoAsymCipherRsa[] = {
#ifdef HITLS_CRYPTO_RSA_ENCRYPT
{CRYPT_EAL_IMPLPKEYCIPHER_ENCRYPT, (CRYPT_EAL_ImplPkeyEncrypt)CRYPT_RSA_EncryptWrapper},
#endif
#ifdef HITLS_CRYPTO_RSA_DECRYPT
{CRYPT_EAL_IMPLPKEYCIPHER_DECRYPT, (CRYPT_EAL_ImplPkeyDecrypt)CRYPT_RSA_DecryptWrapper},
#endif
CRYPT_EAL_FUNC_END
};
const CRYPT_EAL_Func g_isoAsymCipherSm2[] = {
#ifdef HITLS_CRYPTO_SM2_CRYPT
{CRYPT_EAL_IMPLPKEYCIPHER_ENCRYPT, (CRYPT_EAL_ImplPkeyEncrypt)CRYPT_SM2_EncryptWrapper},
{CRYPT_EAL_IMPLPKEYCIPHER_DECRYPT, (CRYPT_EAL_ImplPkeyDecrypt)CRYPT_SM2_DecryptWrapper},
#endif
CRYPT_EAL_FUNC_END
};
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */ | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/iso_prov/crypt_iso_pkeycipher.c | C | unknown | 4,774 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/**
* @defgroup crypt_eal_provider
* @ingroup crypt
* @brief iso19790 provider impl
*/
#ifndef CRYPT_EAL_ISO_PROVIDERIMPL_H
#define CRYPT_EAL_ISO_PROVIDERIMPL_H
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "crypt_eal_implprovider.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
typedef struct {
int32_t algId;
void *ctx;
void *provCtx;
} CRYPT_Iso_Pkey_Ctx;
extern const CRYPT_EAL_Func g_isoMdSha1[];
extern const CRYPT_EAL_Func g_isoMdSha224[];
extern const CRYPT_EAL_Func g_isoMdSha256[];
extern const CRYPT_EAL_Func g_isoMdSha384[];
extern const CRYPT_EAL_Func g_isoMdSha512[];
extern const CRYPT_EAL_Func g_isoMdSha3224[];
extern const CRYPT_EAL_Func g_isoMdSha3256[];
extern const CRYPT_EAL_Func g_isoMdSha3384[];
extern const CRYPT_EAL_Func g_isoMdSha3512[];
extern const CRYPT_EAL_Func g_isoMdShake512[];
extern const CRYPT_EAL_Func g_isoMdShake128[];
extern const CRYPT_EAL_Func g_isoMdShake256[];
extern const CRYPT_EAL_Func g_isoMdSm3[];
extern const CRYPT_EAL_Func g_isoKdfScrypt[];
extern const CRYPT_EAL_Func g_isoKdfPBKdf2[];
extern const CRYPT_EAL_Func g_isoKdfKdfTLS12[];
extern const CRYPT_EAL_Func g_isoKdfHkdf[];
extern const CRYPT_EAL_Func g_isoKeyMgmtDsa[];
extern const CRYPT_EAL_Func g_isoKeyMgmtEd25519[];
extern const CRYPT_EAL_Func g_isoKeyMgmtX25519[];
extern const CRYPT_EAL_Func g_isoKeyMgmtRsa[];
extern const CRYPT_EAL_Func g_isoKeyMgmtDh[];
extern const CRYPT_EAL_Func g_isoKeyMgmtEcdsa[];
extern const CRYPT_EAL_Func g_isoKeyMgmtEcdh[];
extern const CRYPT_EAL_Func g_isoKeyMgmtSm2[];
extern const CRYPT_EAL_Func g_isoKeyMgmtSlhDsa[];
extern const CRYPT_EAL_Func g_isoKeyMgmtMlKem[];
extern const CRYPT_EAL_Func g_isoKeyMgmtMlDsa[];
extern const CRYPT_EAL_Func g_isoExchX25519[];
extern const CRYPT_EAL_Func g_isoExchDh[];
extern const CRYPT_EAL_Func g_isoExchEcdh[];
extern const CRYPT_EAL_Func g_isoExchSm2[];
extern const CRYPT_EAL_Func g_isoAsymCipherRsa[];
extern const CRYPT_EAL_Func g_isoAsymCipherSm2[];
extern const CRYPT_EAL_Func g_isoSignDsa[];
extern const CRYPT_EAL_Func g_isoSignEd25519[];
extern const CRYPT_EAL_Func g_isoSignRsa[];
extern const CRYPT_EAL_Func g_isoSignEcdsa[];
extern const CRYPT_EAL_Func g_isoSignSm2[];
extern const CRYPT_EAL_Func g_isoSignMlDsa[];
extern const CRYPT_EAL_Func g_isoMacHmac[];
extern const CRYPT_EAL_Func g_isoSignSlhDsa[];
extern const CRYPT_EAL_Func g_isoMacCmac[];
extern const CRYPT_EAL_Func g_isoMacGmac[];
extern const CRYPT_EAL_Func g_isoRand[];
extern const CRYPT_EAL_Func g_isoCbc[];
extern const CRYPT_EAL_Func g_isoCcm[];
extern const CRYPT_EAL_Func g_isoCfb[];
extern const CRYPT_EAL_Func g_isoChaCha[];
extern const CRYPT_EAL_Func g_isoCtr[];
extern const CRYPT_EAL_Func g_isoEcb[];
extern const CRYPT_EAL_Func g_isoGcm[];
extern const CRYPT_EAL_Func g_isoOfb[];
extern const CRYPT_EAL_Func g_isoXts[];
extern const CRYPT_EAL_Func g_isoMlKem[];
extern const CRYPT_EAL_Func g_isoSelftest[];
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */
#endif /* CRYPT_EAL_ISO_PROVIDERIMPL_H */ | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/iso_prov/crypt_iso_provderimpl.h | C | unknown | 3,600 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include <stdint.h>
#include <string.h>
#include "bsl_sal.h"
#include "bsl_obj.h"
#include "bsl_errno.h"
#include "bsl_params.h"
#include "bsl_err_internal.h"
#include "crypt_algid.h"
#include "crypt_errno.h"
#include "crypt_utils.h"
#include "cmvp_iso19790.h"
#include "crypt_eal_entropy.h"
#include "crypt_eal_implprovider.h"
#include "crypt_eal_provider.h"
#include "crypt_iso_provderimpl.h"
#include "crypt_iso_provider.h"
#include "crypt_iso_selftest.h"
#include "crypt_params_key.h"
#include "crypt_params_key.h"
#include "hitls_crypt_type.h"
#include "hitls_cert_type.h"
#include "crypt_eal_rand.h"
#include "hitls_type.h"
#define CRYPT_ENTROPY_SOURCE_ENTROPY 8
#define CRYPT_ENTROPY_SEED_POOL_SIZE 4096
static const CRYPT_EAL_AlgInfo g_isoMds[] = {
{CRYPT_MD_SHA1, g_isoMdSha1, CRYPT_EAL_ISO_ATTR},
{CRYPT_MD_SHA224, g_isoMdSha224, CRYPT_EAL_ISO_ATTR},
{CRYPT_MD_SHA256, g_isoMdSha256, CRYPT_EAL_ISO_ATTR},
{CRYPT_MD_SHA384, g_isoMdSha384, CRYPT_EAL_ISO_ATTR},
{CRYPT_MD_SHA512, g_isoMdSha512, CRYPT_EAL_ISO_ATTR},
{CRYPT_MD_SHA3_224, g_isoMdSha3224, CRYPT_EAL_ISO_ATTR},
{CRYPT_MD_SHA3_256, g_isoMdSha3256, CRYPT_EAL_ISO_ATTR},
{CRYPT_MD_SHA3_384, g_isoMdSha3384, CRYPT_EAL_ISO_ATTR},
{CRYPT_MD_SHA3_512, g_isoMdSha3512, CRYPT_EAL_ISO_ATTR},
{CRYPT_MD_SHAKE128, g_isoMdShake128, CRYPT_EAL_ISO_ATTR},
{CRYPT_MD_SHAKE256, g_isoMdShake256, CRYPT_EAL_ISO_ATTR},
{CRYPT_MD_SM3, g_isoMdSm3, CRYPT_EAL_ISO_ATTR},
CRYPT_EAL_ALGINFO_END
};
static const CRYPT_EAL_AlgInfo g_isoKdfs[] = {
{CRYPT_KDF_SCRYPT, g_isoKdfScrypt, CRYPT_EAL_ISO_ATTR},
{CRYPT_KDF_PBKDF2, g_isoKdfPBKdf2, CRYPT_EAL_ISO_ATTR},
{CRYPT_KDF_KDFTLS12, g_isoKdfKdfTLS12, CRYPT_EAL_ISO_ATTR},
{CRYPT_KDF_HKDF, g_isoKdfHkdf, CRYPT_EAL_ISO_ATTR},
CRYPT_EAL_ALGINFO_END
};
static const CRYPT_EAL_AlgInfo g_isoKeyMgmt[] = {
{CRYPT_PKEY_DSA, g_isoKeyMgmtDsa, CRYPT_EAL_ISO_ATTR},
{CRYPT_PKEY_ED25519, g_isoKeyMgmtEd25519, CRYPT_EAL_ISO_ATTR},
{CRYPT_PKEY_X25519, g_isoKeyMgmtX25519, CRYPT_EAL_ISO_ATTR},
{CRYPT_PKEY_RSA, g_isoKeyMgmtRsa, CRYPT_EAL_ISO_ATTR},
{CRYPT_PKEY_DH, g_isoKeyMgmtDh, CRYPT_EAL_ISO_ATTR},
{CRYPT_PKEY_ECDSA, g_isoKeyMgmtEcdsa, CRYPT_EAL_ISO_ATTR},
{CRYPT_PKEY_ECDH, g_isoKeyMgmtEcdh, CRYPT_EAL_ISO_ATTR},
{CRYPT_PKEY_SM2, g_isoKeyMgmtSm2, CRYPT_EAL_ISO_ATTR},
{CRYPT_PKEY_SLH_DSA, g_isoKeyMgmtSlhDsa, CRYPT_EAL_ISO_ATTR},
{CRYPT_PKEY_ML_KEM, g_isoKeyMgmtMlKem, CRYPT_EAL_ISO_ATTR},
{CRYPT_PKEY_ML_DSA, g_isoKeyMgmtMlDsa, CRYPT_EAL_ISO_ATTR},
CRYPT_EAL_ALGINFO_END
};
static const CRYPT_EAL_AlgInfo g_isoAsymCiphers[] = {
{CRYPT_PKEY_RSA, g_isoAsymCipherRsa, CRYPT_EAL_ISO_ATTR},
{CRYPT_PKEY_SM2, g_isoAsymCipherSm2, CRYPT_EAL_ISO_ATTR},
CRYPT_EAL_ALGINFO_END
};
static const CRYPT_EAL_AlgInfo g_isoKeyExch[] = {
{CRYPT_PKEY_X25519, g_isoExchX25519, CRYPT_EAL_ISO_ATTR},
{CRYPT_PKEY_DH, g_isoExchDh, CRYPT_EAL_ISO_ATTR},
{CRYPT_PKEY_ECDH, g_isoExchEcdh, CRYPT_EAL_ISO_ATTR},
{CRYPT_PKEY_SM2, g_isoExchSm2, CRYPT_EAL_ISO_ATTR},
CRYPT_EAL_ALGINFO_END
};
static const CRYPT_EAL_AlgInfo g_isoSigns[] = {
{CRYPT_PKEY_DSA, g_isoSignDsa, CRYPT_EAL_ISO_ATTR},
{CRYPT_PKEY_ED25519, g_isoSignEd25519, CRYPT_EAL_ISO_ATTR},
{CRYPT_PKEY_RSA, g_isoSignRsa, CRYPT_EAL_ISO_ATTR},
{CRYPT_PKEY_ECDSA, g_isoSignEcdsa, CRYPT_EAL_ISO_ATTR},
{CRYPT_PKEY_SM2, g_isoSignSm2, CRYPT_EAL_ISO_ATTR},
{CRYPT_PKEY_SLH_DSA, g_isoSignSlhDsa, CRYPT_EAL_ISO_ATTR},
{CRYPT_PKEY_ML_DSA, g_isoSignMlDsa, CRYPT_EAL_ISO_ATTR},
CRYPT_EAL_ALGINFO_END
};
static const CRYPT_EAL_AlgInfo g_isoMacs[] = {
{CRYPT_MAC_HMAC_SHA1, g_isoMacHmac, CRYPT_EAL_ISO_ATTR},
{CRYPT_MAC_HMAC_SHA224, g_isoMacHmac, CRYPT_EAL_ISO_ATTR},
{CRYPT_MAC_HMAC_SHA256, g_isoMacHmac, CRYPT_EAL_ISO_ATTR},
{CRYPT_MAC_HMAC_SHA384, g_isoMacHmac, CRYPT_EAL_ISO_ATTR},
{CRYPT_MAC_HMAC_SHA512, g_isoMacHmac, CRYPT_EAL_ISO_ATTR},
{CRYPT_MAC_HMAC_SHA3_224, g_isoMacHmac, CRYPT_EAL_ISO_ATTR},
{CRYPT_MAC_HMAC_SHA3_256, g_isoMacHmac, CRYPT_EAL_ISO_ATTR},
{CRYPT_MAC_HMAC_SHA3_384, g_isoMacHmac, CRYPT_EAL_ISO_ATTR},
{CRYPT_MAC_HMAC_SHA3_512, g_isoMacHmac, CRYPT_EAL_ISO_ATTR},
{CRYPT_MAC_HMAC_SM3, g_isoMacHmac, CRYPT_EAL_ISO_ATTR},
{CRYPT_MAC_CMAC_AES128, g_isoMacCmac, CRYPT_EAL_ISO_ATTR},
{CRYPT_MAC_CMAC_AES192, g_isoMacCmac, CRYPT_EAL_ISO_ATTR},
{CRYPT_MAC_CMAC_AES256, g_isoMacCmac, CRYPT_EAL_ISO_ATTR},
{CRYPT_MAC_CMAC_SM4, g_isoMacCmac, CRYPT_EAL_ISO_ATTR},
{CRYPT_MAC_GMAC_AES128, g_isoMacGmac, CRYPT_EAL_ISO_ATTR},
{CRYPT_MAC_GMAC_AES192, g_isoMacGmac, CRYPT_EAL_ISO_ATTR},
{CRYPT_MAC_GMAC_AES256, g_isoMacGmac, CRYPT_EAL_ISO_ATTR},
CRYPT_EAL_ALGINFO_END
};
static const CRYPT_EAL_AlgInfo g_isoRands[] = {
{CRYPT_RAND_SHA1, g_isoRand, CRYPT_EAL_ISO_ATTR},
{CRYPT_RAND_SHA224, g_isoRand, CRYPT_EAL_ISO_ATTR},
{CRYPT_RAND_SHA256, g_isoRand, CRYPT_EAL_ISO_ATTR},
{CRYPT_RAND_SHA384, g_isoRand, CRYPT_EAL_ISO_ATTR},
{CRYPT_RAND_SHA512, g_isoRand, CRYPT_EAL_ISO_ATTR},
{CRYPT_RAND_SM3, g_isoRand, CRYPT_EAL_ISO_ATTR},
{CRYPT_RAND_HMAC_SHA1, g_isoRand, CRYPT_EAL_ISO_ATTR},
{CRYPT_RAND_HMAC_SHA224, g_isoRand, CRYPT_EAL_ISO_ATTR},
{CRYPT_RAND_HMAC_SHA256, g_isoRand, CRYPT_EAL_ISO_ATTR},
{CRYPT_RAND_HMAC_SHA384, g_isoRand, CRYPT_EAL_ISO_ATTR},
{CRYPT_RAND_HMAC_SHA512, g_isoRand, CRYPT_EAL_ISO_ATTR},
{CRYPT_RAND_AES128_CTR, g_isoRand, CRYPT_EAL_ISO_ATTR},
{CRYPT_RAND_AES192_CTR, g_isoRand, CRYPT_EAL_ISO_ATTR},
{CRYPT_RAND_AES256_CTR, g_isoRand, CRYPT_EAL_ISO_ATTR},
{CRYPT_RAND_AES128_CTR_DF, g_isoRand, CRYPT_EAL_ISO_ATTR},
{CRYPT_RAND_AES192_CTR_DF, g_isoRand, CRYPT_EAL_ISO_ATTR},
{CRYPT_RAND_AES256_CTR_DF, g_isoRand, CRYPT_EAL_ISO_ATTR},
{CRYPT_RAND_SM4_CTR_DF, g_isoRand, CRYPT_EAL_ISO_ATTR},
CRYPT_EAL_ALGINFO_END
};
static const CRYPT_EAL_AlgInfo g_isoCiphers[] = {
{CRYPT_CIPHER_AES128_CBC, g_isoCbc, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES192_CBC, g_isoCbc, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES256_CBC, g_isoCbc, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES128_CTR, g_isoCtr, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES192_CTR, g_isoCtr, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES256_CTR, g_isoCtr, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES128_ECB, g_isoEcb, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES192_ECB, g_isoEcb, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES256_ECB, g_isoEcb, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES128_CCM, g_isoCcm, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES192_CCM, g_isoCcm, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES256_CCM, g_isoCcm, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES128_GCM, g_isoGcm, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES192_GCM, g_isoGcm, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES256_GCM, g_isoGcm, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES128_XTS, g_isoXts, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES256_XTS, g_isoXts, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_CHACHA20_POLY1305, g_isoChaCha, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_SM4_XTS, g_isoXts, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_SM4_CBC, g_isoCbc, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_SM4_ECB, g_isoEcb, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_SM4_CTR, g_isoCtr, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_SM4_GCM, g_isoGcm, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_SM4_CFB, g_isoCfb, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_SM4_OFB, g_isoOfb, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES128_CFB, g_isoCfb, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES192_CFB, g_isoCfb, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES256_CFB, g_isoCfb, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES128_OFB, g_isoOfb, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES192_OFB, g_isoOfb, CRYPT_EAL_ISO_ATTR},
{CRYPT_CIPHER_AES256_OFB, g_isoOfb, CRYPT_EAL_ISO_ATTR},
CRYPT_EAL_ALGINFO_END
};
static const CRYPT_EAL_AlgInfo g_isoKems[] = {
{CRYPT_PKEY_ML_KEM, g_isoMlKem, CRYPT_EAL_ISO_ATTR},
CRYPT_EAL_ALGINFO_END
};
static const CRYPT_EAL_AlgInfo g_isoSelftests[] = {
{CRYPT_CMVP_PROVIDER_SELFTEST, g_isoSelftest, CRYPT_EAL_ISO_ATTR},
CRYPT_EAL_ALGINFO_END
};
static int32_t CRYPT_EAL_IsoProvQuery(void *provCtx, int32_t operaId, const CRYPT_EAL_AlgInfo **algInfos)
{
(void)provCtx;
int32_t ret = CRYPT_SUCCESS;
switch (operaId) {
case CRYPT_EAL_OPERAID_SYMMCIPHER:
*algInfos = g_isoCiphers;
break;
case CRYPT_EAL_OPERAID_KEYMGMT:
*algInfos = g_isoKeyMgmt;
break;
case CRYPT_EAL_OPERAID_SIGN:
*algInfos = g_isoSigns;
break;
case CRYPT_EAL_OPERAID_ASYMCIPHER:
*algInfos = g_isoAsymCiphers;
break;
case CRYPT_EAL_OPERAID_KEYEXCH:
*algInfos = g_isoKeyExch;
break;
case CRYPT_EAL_OPERAID_KEM:
*algInfos = g_isoKems;
break;
case CRYPT_EAL_OPERAID_HASH:
*algInfos = g_isoMds;
break;
case CRYPT_EAL_OPERAID_MAC:
*algInfos = g_isoMacs;
break;
case CRYPT_EAL_OPERAID_KDF:
*algInfos = g_isoKdfs;
break;
case CRYPT_EAL_OPERAID_RAND:
*algInfos = g_isoRands;
break;
case CRYPT_EAL_OPERAID_SELFTEST:
*algInfos = g_isoSelftests;
break;
default:
ret = CRYPT_NOT_SUPPORT;
break;
}
return ret;
}
static void CRYPT_EAL_IsoProvFree(void *provCtx)
{
if (provCtx == NULL) {
return;
}
CRYPT_EAL_IsoProvCtx *temp = (CRYPT_EAL_IsoProvCtx *)provCtx;
CRYPT_EAL_SeedPoolFree(temp->pool);
CRYPT_EAL_EsFree(temp->es);
BSL_SAL_Free(provCtx);
}
static CRYPT_EAL_Func g_isoProvOutFuncs[] = {
{CRYPT_EAL_PROVCB_QUERY, CRYPT_EAL_IsoProvQuery},
{CRYPT_EAL_PROVCB_FREE, CRYPT_EAL_IsoProvFree},
{CRYPT_EAL_PROVCB_CTRL, NULL},
{CRYPT_EAL_PROVCB_GETCAPS, NULL},
CRYPT_EAL_FUNC_END
};
static void EntropyRunLogCb(int32_t ret)
{
CMVP_Iso19790EventProcess(CRYPT_EVENT_ES_HEALTH_TEST, 0, 0, ret);
}
static int32_t CreateIsoEs(CRYPT_EAL_Es **es)
{
int32_t ret = CRYPT_SUCCESS;
CRYPT_EAL_Es *esTemp = CRYPT_EAL_EsNew();
RETURN_RET_IF(esTemp == NULL, CRYPT_MEM_ALLOC_FAIL);
ret = CRYPT_EAL_EsCtrl(esTemp, CRYPT_ENTROPY_SET_CF, "sha256_df", (uint32_t)strlen("sha256_df"));
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
ret = CRYPT_EAL_EsCtrl(esTemp, CRYPT_ENTROPY_REMOVE_NS, "timestamp", (uint32_t)strlen("timestamp"));
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
ret = CRYPT_EAL_EsCtrl(esTemp, CRYPT_ENTROPY_SET_LOG_CALLBACK, EntropyRunLogCb, 0);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
bool healthTest = true;
ret = CRYPT_EAL_EsCtrl(esTemp, CRYPT_ENTROPY_ENABLE_TEST, &healthTest, sizeof(healthTest));
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
uint32_t size = CRYPT_ENTROPY_SEED_POOL_SIZE;
ret = CRYPT_EAL_EsCtrl(esTemp, CRYPT_ENTROPY_SET_POOL_SIZE, &size, sizeof(size));
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
ret = CRYPT_EAL_EsInit(esTemp);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
*es = esTemp;
return ret;
ERR:
CRYPT_EAL_EsFree(esTemp);
return ret;
}
static int32_t CreateSeedPool(CRYPT_EAL_SeedPoolCtx **seedPool, CRYPT_EAL_Es **es)
{
CRYPT_EAL_SeedPoolCtx *poolTemp = NULL;
CRYPT_EAL_Es *esTemp = NULL;
int32_t ret = CreateIsoEs(&esTemp);
if (ret != CRYPT_SUCCESS) {
return ret;
}
poolTemp = CRYPT_EAL_SeedPoolNew(true);
if (poolTemp == NULL) {
CRYPT_EAL_EsFree(esTemp);
BSL_ERR_PUSH_ERROR(CRYPT_SEED_POOL_NEW_ERROR);
return CRYPT_SEED_POOL_NEW_ERROR;
}
CRYPT_EAL_EsPara para = {false, CRYPT_ENTROPY_SOURCE_ENTROPY, esTemp, (CRYPT_EAL_EntropyGet)CRYPT_EAL_EsEntropyGet};
ret = CRYPT_EAL_SeedPoolAddEs(poolTemp, ¶);
if (ret != CRYPT_SUCCESS) {
CRYPT_EAL_SeedPoolFree(poolTemp);
CRYPT_EAL_EsFree(esTemp);
return ret;
}
*seedPool = poolTemp;
*es = esTemp;
return CRYPT_SUCCESS;
}
static int32_t IsoCreateProvCtx(void *libCtx, CRYPT_EAL_ProvMgrCtx *mgrCtx, BSL_Param *param, void **provCtx)
{
CRYPT_EAL_IsoProvCtx *temp = BSL_SAL_Calloc(1, sizeof(CRYPT_EAL_IsoProvCtx));
if (temp == NULL) {
BSL_ERR_PUSH_ERROR(BSL_MALLOC_FAIL);
return BSL_MALLOC_FAIL;
}
int32_t ret = CRYPT_Iso_GetLogFunc(param, &temp->runLog);
if (ret != CRYPT_SUCCESS) {
BSL_SAL_Free(temp);
return ret;
}
CRYPT_EAL_SetRandCallBackEx((CRYPT_EAL_RandFuncEx)CRYPT_EAL_RandbytesEx);
ret = CreateSeedPool(&temp->pool, &temp->es);
if (ret != CRYPT_SUCCESS) {
BSL_SAL_Free(temp);
return ret;
}
temp->libCtx = libCtx;
temp->mgrCtx = mgrCtx;
*provCtx = temp;
return CRYPT_SUCCESS;
}
int32_t CRYPT_EAL_ProviderInit(CRYPT_EAL_ProvMgrCtx *mgrCtx, BSL_Param *param, CRYPT_EAL_Func *capFuncs,
CRYPT_EAL_Func **outFuncs, void **provCtx)
{
void *libCtx = NULL;
CRYPT_EAL_ProvMgrCtrlCb mgrCtrl = NULL;
int32_t index = 0;
int32_t ret;
while (capFuncs[index].id != 0) {
switch (capFuncs[index].id) {
case CRYPT_EAL_CAP_MGRCTXCTRL:
mgrCtrl = capFuncs[index].func;
break;
default:
break;
}
index++;
}
if (mgrCtrl == NULL) {
return CRYPT_PROVIDER_NOT_SUPPORT;
}
ret = mgrCtrl(mgrCtx, CRYPT_EAL_MGR_GETLIBCTX, &libCtx, 0);
if (ret != CRYPT_SUCCESS) {
return ret;
}
ret = CRYPT_Iso_Selftest(param);
if (ret != CRYPT_SUCCESS) {
return ret;
}
ret = IsoCreateProvCtx(libCtx, mgrCtx, param, provCtx);
if (ret != CRYPT_SUCCESS) {
return ret;
}
*outFuncs = g_isoProvOutFuncs;
return CRYPT_SUCCESS;
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/iso_prov/crypt_iso_provider.c | C | unknown | 14,518 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/**
* @defgroup crypt_eal_provider
* @ingroup crypt
* @brief iso19790 provider header
*/
#ifndef CRYPT_EAL_ISO_PROVIDER_H
#define CRYPT_EAL_ISO_PROVIDER_H
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include <stdint.h>
#include "crypt_eal_entropy.h"
#include "crypt_eal_implprovider.h"
#include "crypt_eal_cmvp.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#define CRYPT_PARAM_EVENT 1
#define CRYPT_PARAM_ALGID 2
#define CRYPT_PARAM_ALGO_TYPE 3
#define CRYPT_PARAM_LIB_CTX 4
#define CRYPT_EAL_ISO_ATTR "provider=iso"
typedef struct EalIsoProvCtx {
void *libCtx;
void *mgrCtx;
CRYPT_EAL_Es *es;
CRYPT_EAL_SeedPoolCtx *pool;
CRYPT_EAL_CMVP_LogFunc runLog;
} CRYPT_EAL_IsoProvCtx;
int32_t CRYPT_EAL_ProviderInit(CRYPT_EAL_ProvMgrCtx *mgrCtx, BSL_Param *param, CRYPT_EAL_Func *capFuncs,
CRYPT_EAL_Func **outFuncs, void **provCtx);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */
#endif /* CRYPT_EAL_ISO_PROVIDER_H */ | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/iso_prov/crypt_iso_provider.h | C | unknown | 1,566 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include <string.h>
#include "crypt_eal_implprovider.h"
#include "crypt_drbg.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "bsl_err_internal.h"
#include "crypt_ealinit.h"
#include "bsl_params.h"
#include "eal_entropy.h"
#include "cmvp_iso19790.h"
#include "crypt_iso_selftest.h"
#include "crypt_iso_provider.h"
#if defined(HITLS_CRYPTO_DRBG)
#define CRYPT_DRBG_PARAM_NUM 6
typedef struct {
int32_t algId;
void *ctx;
void *provCtx;
} IsoRandCtx;
static void *DefaultDrbgNew(CRYPT_EAL_IsoProvCtx *provCtx, int32_t algId)
{
void *randCtx = NULL;
CRYPT_RandSeedMethod seedMethond = {0};
int32_t ret = EAL_SetDefaultEntropyMeth(&seedMethond);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return NULL;
}
int32_t index = 0;
BSL_Param randParam[CRYPT_DRBG_PARAM_NUM] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
(void)BSL_PARAM_InitValue(&randParam[index++], CRYPT_PARAM_RAND_SEED_GETENTROPY, BSL_PARAM_TYPE_FUNC_PTR,
seedMethond.getEntropy, 0);
(void)BSL_PARAM_InitValue(&randParam[index++], CRYPT_PARAM_RAND_SEED_CLEANENTROPY, BSL_PARAM_TYPE_FUNC_PTR,
seedMethond.cleanEntropy, 0);
(void)BSL_PARAM_InitValue(&randParam[index++], CRYPT_PARAM_RAND_SEED_GETNONCE, BSL_PARAM_TYPE_FUNC_PTR,
seedMethond.getNonce, 0);
(void)BSL_PARAM_InitValue(&randParam[index++], CRYPT_PARAM_RAND_SEED_CLEANNONCE, BSL_PARAM_TYPE_FUNC_PTR,
seedMethond.cleanNonce, 0);
(void)BSL_PARAM_InitValue(&randParam[index++], CRYPT_PARAM_RAND_SEEDCTX, BSL_PARAM_TYPE_CTX_PTR,
provCtx->pool, 0);
randCtx = DRBG_New(provCtx->libCtx, algId, randParam);
if (randCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_PROVIDER_NOT_SUPPORT);
return NULL;
}
return randCtx;
}
static void *CRYPT_EAL_IsoRandNewCtx(CRYPT_EAL_IsoProvCtx *provCtx, int32_t algId, BSL_Param *param)
{
void *randCtx = NULL;
#ifdef HITLS_CRYPTO_ASM_CHECK
if (CRYPT_ASMCAP_Drbg(algId) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
return NULL;
}
#endif
BSL_Param *getEnt = BSL_PARAM_FindParam(param, CRYPT_PARAM_RAND_SEED_GETENTROPY);
if (param == NULL || getEnt == NULL) {
return DefaultDrbgNew(provCtx, algId);
}
randCtx = DRBG_New(provCtx->libCtx, algId, param);
if (randCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_PROVIDER_NOT_SUPPORT);
return NULL;
}
return randCtx;
}
static void *CRYPT_EAL_IsoRandNewCtxWrapper(CRYPT_EAL_IsoProvCtx *provCtx, int32_t algId, BSL_Param *param)
{
if (provCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return NULL;
}
IsoRandCtx *ctx = BSL_SAL_Calloc(1, sizeof(IsoRandCtx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
void *randCtx = CRYPT_EAL_IsoRandNewCtx(provCtx, algId, param);
if (randCtx == NULL) {
BSL_SAL_FREE(ctx);
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
ctx->algId = algId;
ctx->ctx = randCtx;
ctx->provCtx = provCtx;
return ctx;
}
static int32_t DRBG_InstantiateWrapper(IsoRandCtx *ctx, const uint8_t *person, uint32_t persLen, BSL_Param *param)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_SETSSP, CRYPT_ALGO_RAND, ctx->algId);
if (ret != CRYPT_SUCCESS) {
return ret;
}
return DRBG_Instantiate(ctx->ctx, person, persLen, param);
}
static int32_t DRBG_UninstantiateWrapper(IsoRandCtx *ctx)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_ZERO, CRYPT_ALGO_RAND, ctx->algId);
if (ret != CRYPT_SUCCESS) {
return ret;
}
return DRBG_Uninstantiate(ctx->ctx);
}
static int32_t DRBG_GenerateBytesWrapper(IsoRandCtx *ctx, uint8_t *out, uint32_t outLen, const uint8_t *adin,
uint32_t adinLen, BSL_Param *param)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_RANDGEN, CRYPT_ALGO_RAND, ctx->algId);
if (ret != CRYPT_SUCCESS) {
return ret;
}
return DRBG_GenerateBytes(ctx->ctx, out, outLen, adin, adinLen, param);
}
static int32_t DRBG_ReseedWrapper(IsoRandCtx *ctx, const uint8_t *adin, uint32_t adinLen, BSL_Param *param)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_SETSSP, CRYPT_ALGO_RAND, ctx->algId);
if (ret != CRYPT_SUCCESS) {
return ret;
}
return DRBG_Reseed(ctx->ctx, adin, adinLen, param);
}
static int32_t DRBG_CtrlWrapper(IsoRandCtx *ctx, int32_t opt, void *val, uint32_t len)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return DRBG_Ctrl(ctx->ctx, opt, val, len);
}
static void DRBG_FreeWrapper(IsoRandCtx *ctx)
{
if (ctx == NULL) {
return;
}
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_ZERO, CRYPT_ALGO_RAND, ctx->algId);
if (ctx->ctx != NULL) {
DRBG_Free(ctx->ctx);
}
BSL_SAL_Free(ctx);
}
#endif
const CRYPT_EAL_Func g_isoRand[] = {
#if defined(HITLS_CRYPTO_DRBG)
{CRYPT_EAL_IMPLRAND_DRBGNEWCTX, (CRYPT_EAL_ImplRandDrbgNewCtx)CRYPT_EAL_IsoRandNewCtxWrapper},
{CRYPT_EAL_IMPLRAND_DRBGINST, (CRYPT_EAL_ImplRandDrbgInst)DRBG_InstantiateWrapper},
{CRYPT_EAL_IMPLRAND_DRBGUNINST, (CRYPT_EAL_ImplRandDrbgUnInst)DRBG_UninstantiateWrapper},
{CRYPT_EAL_IMPLRAND_DRBGGEN, (CRYPT_EAL_ImplRandDrbgGen)DRBG_GenerateBytesWrapper},
{CRYPT_EAL_IMPLRAND_DRBGRESEED, (CRYPT_EAL_ImplRandDrbgReSeed)DRBG_ReseedWrapper},
{CRYPT_EAL_IMPLRAND_DRBGCTRL, (CRYPT_EAL_ImplRandDrbgCtrl)DRBG_CtrlWrapper},
{CRYPT_EAL_IMPLRAND_DRBGFREECTX, (CRYPT_EAL_ImplRandDrbgFreeCtx)DRBG_FreeWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */ | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/iso_prov/crypt_iso_rand.c | C | unknown | 6,755 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "securec.h"
#include "crypt_types.h"
#include "crypt_errno.h"
#include "crypt_iso_provider.h"
#include "bsl_params.h"
#include "bsl_err_internal.h"
#include "cmvp_iso19790.h"
#include "crypt_cmvp_selftest.h"
#include "crypt_params_key.h"
#include "cmvp_common.h"
#include "crypt_iso_selftest.h"
#define BSL_PARAM_COUNT 4
int32_t CRYPT_Iso_Log(void *provCtx, CRYPT_EVENT_TYPE event, CRYPT_ALGO_TYPE type, int32_t id)
{
int32_t algId = id;
int32_t algType = type;
int index = 0;
BSL_Param param[BSL_PARAM_COUNT] = {{0}, {0}, {0}, BSL_PARAM_END};
(void)BSL_PARAM_InitValue(¶m[index++], CRYPT_PARAM_EVENT, BSL_PARAM_TYPE_INT32, &event, sizeof(event));
(void)BSL_PARAM_InitValue(¶m[index++], CRYPT_PARAM_ALGID, BSL_PARAM_TYPE_INT32, &algId, sizeof(algId));
(void)BSL_PARAM_InitValue(¶m[index++], CRYPT_PARAM_ALGO_TYPE, BSL_PARAM_TYPE_INT32, &algType, sizeof(algType));
return CRYPT_Iso_EventOperation(provCtx, param);
}
static void IsoRunLog(void *provCtx, CRYPT_EVENT_TYPE oper, CRYPT_ALGO_TYPE type, int32_t id, int32_t err)
{
if (provCtx == NULL || ((CRYPT_EAL_IsoProvCtx *)provCtx)->runLog == NULL) {
return;
}
((CRYPT_EAL_IsoProvCtx *)provCtx)->runLog(oper, type, id, err);
}
static int32_t IsoLogEvent(CRYPT_EVENT_TYPE event, void *provCtx, BSL_Param *param, int32_t ret)
{
BSL_Param *temp = BSL_PARAM_FindParam(param, CRYPT_PARAM_ALGID);
if (temp == NULL || temp->valueType != BSL_PARAM_TYPE_INT32) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t id = *(int32_t *)(uintptr_t)temp->value;
temp = BSL_PARAM_FindParam(param, CRYPT_PARAM_ALGO_TYPE);
if (temp == NULL || temp->valueType != BSL_PARAM_TYPE_INT32) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t type = *(int32_t *)(uintptr_t)temp->value;
IsoRunLog(provCtx, event, type, id, ret);
return CRYPT_SUCCESS;
}
static int32_t IsoIntegrityTest(void *provCtx, BSL_Param *param)
{
void *libCtx = NULL;
BSL_Param *temp = BSL_PARAM_FindParam(param, CRYPT_PARAM_LIB_CTX);
int32_t ret = BSL_PARAM_GetPtrValue(temp, CRYPT_PARAM_LIB_CTX, BSL_PARAM_TYPE_CTX_PTR, &libCtx, NULL);
if (ret != BSL_SUCCESS || libCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
IsoRunLog(provCtx, CRYPT_EVENT_INTEGRITY_TEST, 0, 0, CRYPT_SUCCESS);
ret = CMVP_Iso19790CheckIntegrity(libCtx, CRYPT_EAL_ISO_ATTR);
if (ret != CRYPT_SUCCESS) {
IsoRunLog(provCtx, CRYPT_EVENT_INTEGRITY_TEST, 0, 0, ret);
return ret;
}
return CRYPT_SUCCESS;
}
static int32_t IsoKatTest(void *provCtx, BSL_Param *param)
{
void *libCtx = NULL;
BSL_Param *temp = BSL_PARAM_FindParam(param, CRYPT_PARAM_LIB_CTX);
int32_t ret = BSL_PARAM_GetPtrValue(temp, CRYPT_PARAM_LIB_CTX, BSL_PARAM_TYPE_CTX_PTR, &libCtx, NULL);
if (ret != BSL_SUCCESS || libCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
IsoRunLog(provCtx, CRYPT_EVENT_KAT_TEST, 0, 0, CRYPT_SUCCESS);
ret = CMVP_Iso19790Kat(libCtx, CRYPT_EAL_ISO_ATTR);
if (ret != CRYPT_SUCCESS) {
IsoRunLog(provCtx, CRYPT_EVENT_KAT_TEST, 0, 0, ret);
return ret;
}
return CRYPT_SUCCESS;
}
int32_t CRYPT_Iso_EventOperation(void *provCtx, BSL_Param *param)
{
BSL_Param *temp = BSL_PARAM_FindParam(param, CRYPT_PARAM_EVENT);
if (temp == NULL || temp->valueType != BSL_PARAM_TYPE_INT32) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t event = *(int32_t *)(uintptr_t)temp->value;
switch (event) {
case CRYPT_EVENT_KAT_TEST:
return IsoKatTest(provCtx, param);
case CRYPT_EVENT_INTEGRITY_TEST:
return IsoIntegrityTest(provCtx, param);
case CRYPT_EVENT_PARAM_CHECK:
return IsoLogEvent(event, provCtx, param, CRYPT_CMVP_ERR_PARAM_CHECK);
case CRYPT_EVENT_ENC:
case CRYPT_EVENT_DEC:
case CRYPT_EVENT_GEN:
case CRYPT_EVENT_SIGN:
case CRYPT_EVENT_VERIFY:
case CRYPT_EVENT_MD:
case CRYPT_EVENT_MAC:
case CRYPT_EVENT_KDF:
case CRYPT_EVENT_KEYAGGREMENT:
case CRYPT_EVENT_RANDGEN:
case CRYPT_EVENT_ZERO:
case CRYPT_EVENT_SETSSP:
case CRYPT_EVENT_GETSSP:
case CRYPT_EVENT_ENCAPS:
case CRYPT_EVENT_DECAPS:
case CRYPT_EVENT_BLIND:
case CRYPT_EVENT_UNBLIND:
case CRYPT_EVENT_PCT_TEST:
case CRYPT_EVENT_GET_VERSION:
return IsoLogEvent(event, provCtx, param, CRYPT_SUCCESS);
default:
break;
}
return CRYPT_NOT_SUPPORT;
}
int32_t CRYPT_Iso_GetLogFunc(BSL_Param *param, CRYPT_EAL_CMVP_LogFunc *logFunc)
{
int32_t ret = CRYPT_SUCCESS;
BSL_Param *temp = BSL_PARAM_FindParam(param, CRYPT_PARAM_CMVP_LOG_FUNC);
if (temp == NULL) {
*logFunc = CMVP_Iso19790EventProcess;
return CRYPT_SUCCESS;
}
ret = BSL_PARAM_GetPtrValue(temp, CRYPT_PARAM_CMVP_LOG_FUNC, BSL_PARAM_TYPE_FUNC_PTR, (void **)logFunc, NULL);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
if (*logFunc == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return CRYPT_SUCCESS;
}
int32_t CRYPT_Iso_Selftest(BSL_Param *param)
{
CRYPT_EAL_LibCtx *libCtx = NULL;
if (CMVP_CheckIsInternalLibCtx(param)) {
return CRYPT_SUCCESS;
}
int32_t ret = CMVP_CreateInternalLibCtx(param, &libCtx, CRYPT_Iso_Selftest);
if (ret != CRYPT_SUCCESS) {
return ret;
}
CRYPT_EAL_CMVP_LogFunc runLog = NULL;
ret = CRYPT_Iso_GetLogFunc(param, &runLog);
if (ret != CRYPT_SUCCESS) {
CRYPT_EAL_LibCtxFree(libCtx);
return ret;
}
runLog(CRYPT_EVENT_INTEGRITY_TEST, 0, 0, CRYPT_SUCCESS);
ret = CMVP_Iso19790CheckIntegrity(libCtx, CRYPT_EAL_ISO_ATTR);
if (ret != CRYPT_SUCCESS) {
runLog(CRYPT_EVENT_INTEGRITY_TEST, 0, 0, ret);
CRYPT_EAL_LibCtxFree(libCtx);
return ret;
}
runLog(CRYPT_EVENT_KAT_TEST, 0, 0, CRYPT_SUCCESS);
ret = CMVP_Iso19790Kat(libCtx, CRYPT_EAL_ISO_ATTR);
CRYPT_EAL_LibCtxFree(libCtx);
if (ret != CRYPT_SUCCESS) {
runLog(CRYPT_EVENT_KAT_TEST, 0, 0, ret);
return ret;
}
return CRYPT_SUCCESS;
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */ | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/iso_prov/crypt_iso_selftest.c | C | unknown | 7,110 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/**
* @defgroup crypt_eal_provider
* @ingroup crypt
* @brief iso19790 provider header
*/
#ifndef CRYPT_EAL_ISO_SELFTEST_H
#define CRYPT_EAL_ISO_SELFTEST_H
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include <stdint.h>
#include "crypt_iso_provider.h"
#include "crypt_eal_provider.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
int32_t CRYPT_Iso_Selftest(BSL_Param *param);
int32_t CRYPT_Iso_Log(void *provCtx, CRYPT_EVENT_TYPE event, CRYPT_ALGO_TYPE type, int32_t id);
int32_t CRYPT_Iso_EventOperation(void *provCtx, BSL_Param *param);
int32_t CRYPT_Iso_GetLogFunc(BSL_Param *param, CRYPT_EAL_CMVP_LogFunc *logFunc);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */
#endif /* CRYPT_EAL_ISO_SELFTEST_H */ | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/iso_prov/crypt_iso_selftest.h | C | unknown | 1,301 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "crypt_eal_implprovider.h"
#include "crypt_dsa.h"
#include "crypt_rsa.h"
#include "crypt_ecdsa.h"
#include "crypt_sm2.h"
#include "crypt_curve25519.h"
#include "crypt_slh_dsa.h"
#include "crypt_mldsa.h"
#include "bsl_err_internal.h"
#include "crypt_errno.h"
#include "crypt_cmvp.h"
#include "cmvp_iso19790.h"
#include "crypt_iso_selftest.h"
#include "crypt_iso_provderimpl.h"
static int32_t CheckSignVerifyMdAlgId(CRYPT_Iso_Pkey_Ctx *ctx, int32_t algId, bool isSign)
{
CRYPT_EVENT_TYPE event = isSign ? CRYPT_EVENT_SIGN : CRYPT_EVENT_VERIFY;
CRYPT_EAL_PkeyC2Data data = {NULL, NULL, NULL, algId, CRYPT_PKEY_PARAID_MAX, event, NULL, NULL, NULL};
if (!CMVP_Iso19790PkeyC2(ctx->algId, &data)) {
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_PKEY, ctx->algId);
return CRYPT_CMVP_ERR_PARAM_CHECK;
}
return CRYPT_SUCCESS;
}
#define PKEY_SIGN_FUNC(name) \
static int32_t CRYPT_##name##_SignWrapper(CRYPT_Iso_Pkey_Ctx *ctx, int32_t algId, const uint8_t *data, \
uint32_t dataLen, uint8_t *sign, uint32_t *signLen) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_SIGN, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
ret = CheckSignVerifyMdAlgId(ctx, algId, true); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_Sign(ctx->ctx, algId, data, dataLen, sign, signLen); \
} \
\
static int32_t CRYPT_##name##_VerifyWrapper(CRYPT_Iso_Pkey_Ctx *ctx, int32_t algId, const uint8_t *msg, \
uint32_t msgLen, uint8_t *sign, uint32_t signLen) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_VERIFY, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
ret = CheckSignVerifyMdAlgId(ctx, algId, false); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_Verify(ctx->ctx, algId, msg, msgLen, sign, signLen); \
}
#define PKEY_SIGN_DATA_FUNC(name) \
static int32_t CRYPT_##name##_SignDataWrapper(CRYPT_Iso_Pkey_Ctx *ctx, const uint8_t *data, uint32_t dataLen, \
uint8_t *sign, uint32_t *signLen) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_SIGN, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_SignData(ctx->ctx, data, dataLen, sign, signLen); \
} \
\
static int32_t CRYPT_##name##_VerifyDataWrapper(CRYPT_Iso_Pkey_Ctx *ctx, const uint8_t *data, uint32_t dataLen, \
uint8_t *sign, uint32_t signLen) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_VERIFY, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_VerifyData(ctx->ctx, data, dataLen, sign, signLen); \
}
static int32_t CRYPT_RSA_RecoverWrapper(CRYPT_Iso_Pkey_Ctx *ctx, const uint8_t *data, uint32_t dataLen, uint8_t *out,
uint32_t *outLen)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return CRYPT_RSA_Recover(ctx->ctx, data, dataLen, out, outLen);
}
static int32_t CRYPT_RSA_BlindWrapper(CRYPT_Iso_Pkey_Ctx *ctx, int32_t algId, const uint8_t *input, uint32_t inputLen,
uint8_t *out, uint32_t *outLen)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_BLIND, CRYPT_ALGO_PKEY, ctx->algId);
if (ret != CRYPT_SUCCESS) {
return ret;
}
return CRYPT_RSA_Blind(ctx->ctx, algId, input, inputLen, out, outLen);
}
static int32_t CRYPT_RSA_UnBlindWrapper(CRYPT_Iso_Pkey_Ctx *ctx, const uint8_t *input, uint32_t inputLen,
uint8_t *out, uint32_t *outLen)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_UNBLIND, CRYPT_ALGO_PKEY, ctx->algId);
if (ret != CRYPT_SUCCESS) {
return ret;
}
return CRYPT_RSA_UnBlind(ctx->ctx, input, inputLen, out, outLen);
}
PKEY_SIGN_FUNC(DSA)
PKEY_SIGN_FUNC(CURVE25519)
PKEY_SIGN_FUNC(RSA)
PKEY_SIGN_FUNC(ECDSA)
PKEY_SIGN_FUNC(SM2)
PKEY_SIGN_FUNC(SLH_DSA)
PKEY_SIGN_FUNC(ML_DSA)
PKEY_SIGN_DATA_FUNC(DSA)
PKEY_SIGN_DATA_FUNC(RSA)
PKEY_SIGN_DATA_FUNC(ECDSA)
const CRYPT_EAL_Func g_isoSignDsa[] = {
#ifdef HITLS_CRYPTO_DSA
{CRYPT_EAL_IMPLPKEYSIGN_SIGN, (CRYPT_EAL_ImplPkeySign)CRYPT_DSA_SignWrapper},
{CRYPT_EAL_IMPLPKEYSIGN_SIGNDATA, (CRYPT_EAL_ImplPkeySignData)CRYPT_DSA_SignDataWrapper},
{CRYPT_EAL_IMPLPKEYSIGN_VERIFY, (CRYPT_EAL_ImplPkeyVerify)CRYPT_DSA_VerifyWrapper},
{CRYPT_EAL_IMPLPKEYSIGN_VERIFYDATA, (CRYPT_EAL_ImplPkeyVerifyData)CRYPT_DSA_VerifyDataWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoSignEd25519[] = {
#ifdef HITLS_CRYPTO_ED25519
{CRYPT_EAL_IMPLPKEYSIGN_SIGN, (CRYPT_EAL_ImplPkeySign)CRYPT_CURVE25519_SignWrapper},
{CRYPT_EAL_IMPLPKEYSIGN_VERIFY, (CRYPT_EAL_ImplPkeyVerify)CRYPT_CURVE25519_VerifyWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoSignRsa[] = {
#ifdef HITLS_CRYPTO_RSA_SIGN
{CRYPT_EAL_IMPLPKEYSIGN_SIGN, (CRYPT_EAL_ImplPkeySign)CRYPT_RSA_SignWrapper},
{CRYPT_EAL_IMPLPKEYSIGN_SIGNDATA, (CRYPT_EAL_ImplPkeySignData)CRYPT_RSA_SignDataWrapper},
#endif
#ifdef HITLS_CRYPTO_RSA_VERIFY
{CRYPT_EAL_IMPLPKEYSIGN_VERIFY, (CRYPT_EAL_ImplPkeyVerify)CRYPT_RSA_VerifyWrapper},
{CRYPT_EAL_IMPLPKEYSIGN_VERIFYDATA, (CRYPT_EAL_ImplPkeyVerifyData)CRYPT_RSA_VerifyDataWrapper},
{CRYPT_EAL_IMPLPKEYSIGN_RECOVER, (CRYPT_EAL_ImplPkeyRecover)CRYPT_RSA_RecoverWrapper},
#endif
#ifdef HITLS_CRYPTO_RSA_BSSA
#ifdef HITLS_CRYPTO_RSA_SIGN
{CRYPT_EAL_IMPLPKEYSIGN_BLIND, (CRYPT_EAL_ImplPkeyBlind)CRYPT_RSA_BlindWrapper},
#endif
#ifdef HITLS_CRYPTO_RSA_VERIFY
{CRYPT_EAL_IMPLPKEYSIGN_UNBLIND, (CRYPT_EAL_ImplPkeyUnBlind)CRYPT_RSA_UnBlindWrapper},
#endif
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoSignEcdsa[] = {
#ifdef HITLS_CRYPTO_ECDSA
{CRYPT_EAL_IMPLPKEYSIGN_SIGN, (CRYPT_EAL_ImplPkeySign)CRYPT_ECDSA_SignWrapper},
{CRYPT_EAL_IMPLPKEYSIGN_SIGNDATA, (CRYPT_EAL_ImplPkeySignData)CRYPT_ECDSA_SignDataWrapper},
{CRYPT_EAL_IMPLPKEYSIGN_VERIFY, (CRYPT_EAL_ImplPkeyVerify)CRYPT_ECDSA_VerifyWrapper},
{CRYPT_EAL_IMPLPKEYSIGN_VERIFYDATA, (CRYPT_EAL_ImplPkeyVerifyData)CRYPT_ECDSA_VerifyDataWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoSignSm2[] = {
#ifdef HITLS_CRYPTO_SM2_SIGN
{CRYPT_EAL_IMPLPKEYSIGN_SIGN, (CRYPT_EAL_ImplPkeySign)CRYPT_SM2_SignWrapper},
{CRYPT_EAL_IMPLPKEYSIGN_VERIFY, (CRYPT_EAL_ImplPkeyVerify)CRYPT_SM2_VerifyWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoSignSlhDsa[] = {
#ifdef HITLS_CRYPTO_SLH_DSA
{CRYPT_EAL_IMPLPKEYSIGN_SIGN, (CRYPT_EAL_ImplPkeySign)CRYPT_SLH_DSA_SignWrapper},
{CRYPT_EAL_IMPLPKEYSIGN_VERIFY, (CRYPT_EAL_ImplPkeyVerify)CRYPT_SLH_DSA_VerifyWrapper},
#endif
CRYPT_EAL_FUNC_END
};
const CRYPT_EAL_Func g_isoSignMlDsa[] = {
#ifdef HITLS_CRYPTO_MLDSA
{CRYPT_EAL_IMPLPKEYSIGN_SIGN, (CRYPT_EAL_ImplPkeySign)CRYPT_ML_DSA_SignWrapper},
{CRYPT_EAL_IMPLPKEYSIGN_VERIFY, (CRYPT_EAL_ImplPkeyVerify)CRYPT_ML_DSA_VerifyWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */ | 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/iso_prov/crypt_iso_sign.c | C | unknown | 13,342 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_SM
#include "cmvp_sm.h"
#include "cmvp_common.h"
#include "crypt_errno.h"
#include "crypt_cmvp_selftest.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "cmvp_integrity_hmac.h"
#include "crypt_params_key.h"
#include "securec.h"
#include "bsl_sal.h"
bool CMVP_SmPkeyPct(void *ctx, int32_t algId)
{
return CRYPT_CMVP_SelftestPkeyPct(ctx, algId);
}
bool CMVP_SmPkeyC2(int32_t algId)
{
if (algId != CRYPT_MD_SM3) {
return false;
}
return true;
}
bool CMVP_SmKdfC2(const CRYPT_EAL_KdfC2Data *data)
{
// According to GM/T 0091-2020 A1.1 and A1.2, min saltLen is 8, min iter is 1024.
if (data->pbkdf2->macId != CRYPT_MAC_HMAC_SM3 || data->pbkdf2->saltLen < 8 || data->pbkdf2->iter < 1024) {
return false;
}
return true;
}
static bool CipherKat(void *libCtx, const char *attrName)
{
static const uint32_t list[] = {
CRYPT_CIPHER_SM4_XTS, CRYPT_CIPHER_SM4_CBC, CRYPT_CIPHER_SM4_ECB,
CRYPT_CIPHER_SM4_CTR, CRYPT_CIPHER_SM4_GCM, CRYPT_CIPHER_SM4_CFB,
CRYPT_CIPHER_SM4_OFB,
};
bool ret = false;
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
ret = CRYPT_CMVP_SelftestProviderCipher(libCtx, attrName, list[i]);
if (!ret) {
return false;
}
}
return true;
}
static bool MdKat(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestProviderMd(libCtx, attrName, CRYPT_MD_SM3);
}
static bool MacKat(void *libCtx, const char *attrName)
{
static const uint32_t list[] = {
CRYPT_MAC_HMAC_SM3,
CRYPT_MAC_CBC_MAC_SM4,
};
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
if (!CRYPT_CMVP_SelftestProviderMac(libCtx, attrName, list[i])) {
return false;
}
}
return true;
}
static bool DrbgKat(void *libCtx, const char *attrName)
{
static const uint32_t list[] = {
CRYPT_RAND_SM4_CTR_DF,
CRYPT_RAND_SM3,
};
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
if (!CRYPT_CMVP_SelftestProviderDrbg(libCtx, attrName, list[i])) {
return false;
}
}
return true;
}
static bool KdfKat(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestProviderPbkdf2(libCtx, attrName, CRYPT_MAC_HMAC_SM3);
}
static bool PkeyKat(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestProviderSM2(libCtx, attrName);
}
int32_t CMVP_SmKat(void *libCtx, const char *attrName)
{
bool ret = CipherKat(libCtx, attrName);
RETURN_RET_IF(ret == false, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = MdKat(libCtx, attrName);
RETURN_RET_IF(ret == false, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = MacKat(libCtx, attrName);
RETURN_RET_IF(ret == false, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = DrbgKat(libCtx, attrName);
RETURN_RET_IF(ret == false, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = KdfKat(libCtx, attrName);
RETURN_RET_IF(ret == false, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = PkeyKat(libCtx, attrName);
RETURN_RET_IF(ret == false, CRYPT_CMVP_ERR_ALGO_SELFTEST);
return CRYPT_SUCCESS;
}
int32_t CMVP_SmCheckIntegrity(void *libCtx, const char *attrName)
{
return CMVP_CheckIntegrity(libCtx, attrName, CRYPT_MAC_HMAC_SM3);
}
#endif /* HITLS_CRYPTO_CMVP_SM */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/sm_prov/cmvp_sm.c | C | unknown | 3,902 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CMVP_SM_H
#define CMVP_SM_H
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_SM
#include <stdint.h>
#include <stdbool.h>
#include "crypt_cmvp.h"
#include "crypt_algid.h"
#include "crypt_sm_provider.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
bool CMVP_SmPkeyC2(int32_t algId);
bool CMVP_SmKdfC2(const CRYPT_EAL_KdfC2Data *data);
int32_t CMVP_SmKat(void *libCtx, const char *attrName);
int32_t CMVP_SmCheckIntegrity(void *libCtx, const char *attrName);
bool CMVP_SmPkeyPct(void *ctx, int32_t algId);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* HITLS_CRYPTO_CMVP_SM */
#endif /* CMVP_SM_H */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/sm_prov/cmvp_sm.h | C | unknown | 1,181 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_SM
#include "crypt_eal_implprovider.h"
#include "crypt_modes_cbc.h"
#include "crypt_modes_ctr.h"
#include "crypt_modes_ecb.h"
#include "crypt_modes_gcm.h"
#include "crypt_modes_ofb.h"
#include "crypt_modes_cfb.h"
#include "crypt_modes_xts.h"
#include "crypt_local_types.h"
#include "crypt_errno.h"
#include "bsl_err_internal.h"
#include "crypt_ealinit.h"
static void *CRYPT_EAL_SmCipherNewCtx(void *provCtx, int32_t algId)
{
(void) provCtx;
#ifdef HITLS_CRYPTO_ASM_CHECK
if (CRYPT_ASMCAP_Cipher(algId) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
return NULL;
}
#endif
CRYPT_EAL_Func cipherNewCtxFunc[] = {
{CRYPT_CIPHER_SM4_XTS, MODES_XTS_NewCtx},
{CRYPT_CIPHER_SM4_CBC, MODES_CBC_NewCtx},
{CRYPT_CIPHER_SM4_ECB, MODES_ECB_NewCtx},
{CRYPT_CIPHER_SM4_CTR, MODES_CTR_NewCtx},
{CRYPT_CIPHER_SM4_GCM, MODES_GCM_NewCtx},
{CRYPT_CIPHER_SM4_CFB, MODES_CFB_NewCtx},
{CRYPT_CIPHER_SM4_OFB, MODES_OFB_NewCtx},
};
for (size_t i = 0; i < sizeof(cipherNewCtxFunc)/sizeof(cipherNewCtxFunc[0]); i++) {
if (cipherNewCtxFunc[i].id == algId) {
return ((CipherNewCtx)cipherNewCtxFunc[i].func)(algId);
}
}
BSL_ERR_PUSH_ERROR(CRYPT_PROVIDER_NOT_SUPPORT);
return NULL;
}
const CRYPT_EAL_Func g_smCbc[] = {
#ifdef HITLS_CRYPTO_CBC
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)CRYPT_EAL_SmCipherNewCtx},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_CBC_InitCtxEx},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_CBC_UpdateEx},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_CBC_FinalEx},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CBC_DeInitCtx},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CBC_Ctrl},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CBC_FreeCtx},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_smCfb[] = {
#ifdef HITLS_CRYPTO_CFB
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)CRYPT_EAL_SmCipherNewCtx},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_CFB_InitCtxEx},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_CFB_UpdateEx},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_CFB_Final},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CFB_DeInitCtx},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CFB_Ctrl},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CFB_FreeCtx},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_smCtr[] = {
#ifdef HITLS_CRYPTO_CTR
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)CRYPT_EAL_SmCipherNewCtx},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_CTR_InitCtxEx},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_CTR_UpdateEx},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_CTR_Final},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CTR_DeInitCtx},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CTR_Ctrl},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CTR_FreeCtx},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_smEcb[] = {
#ifdef HITLS_CRYPTO_ECB
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)CRYPT_EAL_SmCipherNewCtx},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_ECB_InitCtxEx},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_ECB_UpdateEx},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_ECB_FinalEx},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_ECB_DeinitCtx},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_ECB_Ctrl},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_ECB_FreeCtx},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_smGcm[] = {
#ifdef HITLS_CRYPTO_GCM
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)CRYPT_EAL_SmCipherNewCtx},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_GCM_InitCtxEx},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_GCM_UpdateEx},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_GCM_Final},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_GCM_DeInitCtx},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_GCM_Ctrl},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_GCM_FreeCtx},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_smOfb[] = {
#ifdef HITLS_CRYPTO_OFB
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)CRYPT_EAL_SmCipherNewCtx},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_OFB_InitCtxEx},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_OFB_UpdateEx},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_OFB_Final},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_OFB_DeInitCtx},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_OFB_Ctrl},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_OFB_FreeCtx},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_smXts[] = {
#ifdef HITLS_CRYPTO_XTS
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)CRYPT_EAL_SmCipherNewCtx},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_XTS_InitCtxEx},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_XTS_UpdateEx},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_XTS_Final},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_XTS_DeInitCtx},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_XTS_Ctrl},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_XTS_FreeCtx},
#endif
CRYPT_EAL_FUNC_END,
};
#endif /* HITLS_CRYPTO_CMVP_SM */
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/sm_prov/crypt_sm_cipher.c | C | unknown | 6,701 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_SM
#include "crypt_eal_implprovider.h"
#include "bsl_err_internal.h"
#include "crypt_errno.h"
#include "crypt_cmvp_selftest.h"
#include "cmvp_sm.h"
#include "crypt_params_key.h"
#include "crypt_sm_provider.h"
#define SM_PROVIDER_VERSION "openHiTLS SM Provider Version : V0.3.0"
typedef struct {
void *provCtx;
void *libCtx;
} SmSelftestCtx;
static SmSelftestCtx *CRYPT_Selftest_NewCtx(CRYPT_EAL_SmProvCtx *provCtx)
{
if (provCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return NULL;
}
SmSelftestCtx *ctx = (SmSelftestCtx *)BSL_SAL_Calloc(1, sizeof(SmSelftestCtx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
ctx->provCtx = provCtx;
ctx->libCtx = provCtx->libCtx;
return ctx;
}
static const char *CRYPT_Selftest_GetVersion(SmSelftestCtx *ctx)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return NULL;
}
return SM_PROVIDER_VERSION;
}
static int32_t CRYPT_Selftest_Selftest(SmSelftestCtx *ctx, const BSL_Param *param)
{
int32_t type = 0;
uint32_t len = sizeof(type);
if (ctx == NULL || param == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
const BSL_Param *temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_CMVP_SELFTEST_TYPE);
if (temp == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
int32_t ret = BSL_PARAM_GetValue(temp, CRYPT_PARAM_CMVP_SELFTEST_TYPE, BSL_PARAM_TYPE_INT32, &type, &len);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
switch (type) {
case CRYPT_CMVP_INTEGRITY_TEST:
ret = CMVP_SmCheckIntegrity(ctx->libCtx, CRYPT_EAL_SM_ATTR);
break;
case CRYPT_CMVP_KAT_TEST:
ret = CMVP_SmKat(ctx->libCtx, CRYPT_EAL_SM_ATTR);
break;
case CRYPT_CMVP_RANDOMNESS_TEST:
if ((temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_CMVP_RANDOM)) == NULL ||
temp->valueType != BSL_PARAM_TYPE_OCTETS || temp->value == NULL || temp->valueLen == 0) {
ret = CRYPT_INVALID_ARG;
break;
}
ret = CRYPT_CMVP_RandomnessTest(temp->value, temp->valueLen);
break;
default:
BSL_ERR_PUSH_ERROR(CRYPT_NOT_SUPPORT);
return CRYPT_NOT_SUPPORT;
}
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
}
static void CRYPT_Selftest_FreeCtx(SmSelftestCtx *ctx)
{
if (ctx == NULL) {
return;
}
BSL_SAL_Free(ctx);
}
const CRYPT_EAL_Func g_smSelftest[] = {
{CRYPT_EAL_IMPLSELFTEST_NEWCTX, (CRYPT_EAL_ImplSelftestNewCtx)CRYPT_Selftest_NewCtx},
{CRYPT_EAL_IMPLSELFTEST_GETVERSION, (CRYPT_EAL_ImplSelftestGetVersion)CRYPT_Selftest_GetVersion},
{CRYPT_EAL_IMPLSELFTEST_SELFTEST, (CRYPT_EAL_ImplSelftestSelftest)CRYPT_Selftest_Selftest},
{CRYPT_EAL_IMPLSELFTEST_FREECTX, (CRYPT_EAL_ImplSelftestFreeCtx)CRYPT_Selftest_FreeCtx},
CRYPT_EAL_FUNC_END
};
#endif // HITLS_CRYPTO_CMVP_SM
| 2302_82127028/openHiTLS-examples_1508 | crypto/provider/src/cmvp/sm_prov/crypt_sm_cmvp.c | C | unknown | 3,745 |