wolfSSL/wolfssl
1
0
Fork 1
mirror of https://github.com/wolfSSL/wolfssl.git synced 2025-07-30 18:57:27 +02:00
Code Issues Packages Projects Releases Wiki Activity

Addressing PR comments

Browse Source
This commit is contained in:
Andras Fekete
2023-07-06 16:33:32 -04:00
parent 266307da6c
commit ef9206f73f
2 changed files with 738 additions and 682 deletions
Download Patch File Download Diff File Expand all files Collapse all files

407
wolfcrypt/src/port/aria/aria-crypt.c
View File

@ -37,234 +37,251 @@ size and a key size of 128, 192, or 256 bits.
#include <wolfssl/wolfcrypt/port/aria/aria-crypt.h> #include <wolfssl/wolfcrypt/port/aria/aria-crypt.h>
#ifdef HAVE_ARIA #ifdef HAVE_ARIA
/* return 0 on success or WC_INIT_E on failure */
int wc_AriaInitCrypt(wc_Aria* aria, MC_ALGID algo)
{
MC_RV rv = MC_OK;
MC_APIMODE gApimode = MC_MODE_KCMV; /* return 0 on success or WC_INIT_E on failure */
MC_ALGMODE algMode = MC_ALGMODE_GCM; int wc_AriaInitCrypt(wc_Aria* aria, MC_ALGID algo)
MC_PADTYPE algPad = MC_PADTYPE_NONE; {
MC_RV rv = MC_OK;
if (aria == NULL) return BAD_FUNC_ARG; MC_APIMODE gApimode = MC_MODE_KCMV;
MC_ALGMODE algMode = MC_ALGMODE_GCM;
MC_PADTYPE algPad = MC_PADTYPE_NONE;
if (rv == MC_OK) rv = MC_Initialize(NULL); if (aria == NULL)
return BAD_FUNC_ARG;
if (rv == MC_OK) rv = wc_AriaFreeCrypt(aria); if (rv == MC_OK)
rv = MC_Initialize(NULL);
if (rv == MC_OK) rv = MC_OpenSession(&(aria->hSession)); if (rv == MC_OK)
rv = wc_AriaFreeCrypt(aria);
if (rv == MC_OK) rv = MC_SetApiMode(aria->hSession, gApimode); if (rv == MC_OK)
rv = MC_OpenSession(&(aria->hSession));
if (rv == MC_OK) rv = MC_SetOption(aria->hSession, algMode, algPad); if (rv == MC_OK)
rv = MC_SetApiMode(aria->hSession, gApimode);
if (rv == MC_OK) { if (rv == MC_OK)
aria->algo = algo; rv = MC_SetOption(aria->hSession, algMode, algPad);
XMEMSET(aria->nonce,0,sizeof(aria->nonce));
aria->nonceSz = 0;
}
if (rv != MC_OK) { if (rv == MC_OK) {
WOLFSSL_MSG(MC_GetErrorString(rv)); aria->algo = algo;
return WC_INIT_E; XMEMSET(aria->nonce,0,sizeof(aria->nonce));
} aria->nonceSz = 0;
}
if (rv != MC_OK) {
WOLFSSL_MSG(MC_GetErrorString(rv));
return WC_INIT_E;
}
return 0;
}
/* return 0 on success or BAD_STATE_E on failure */
int wc_AriaFreeCrypt(wc_Aria* aria)
{
MC_RV rv = MC_OK;
if (aria == NULL)
return 0; return 0;
if (aria->hKey != NULL) {
if (rv == MC_OK) rv = MC_DestroyObject(aria->hSession, aria->hKey);
if (rv == MC_OK) aria->hKey = NULL;
}
if (aria->hSession != NULL) {
if (rv == MC_OK) rv = MC_CloseSession(aria->hSession);
if (rv == MC_OK) aria->hSession = NULL;
} }
/* return 0 on success or BAD_STATE_E on failure */ if (rv != MC_OK) {
int wc_AriaFreeCrypt(wc_Aria* aria) WOLFSSL_MSG(MC_GetErrorString(rv));
{ return BAD_STATE_E;
if (aria == NULL) return 0; }
return 0;
}
MC_RV rv = MC_OK; /* return 0 on success or BAD_FUNC_ARG/PUBLIC_KEY_E on failure */
if (aria->hKey != NULL) { int wc_AriaSetKey(wc_Aria* aria, byte* key)
if (rv == MC_OK) rv = MC_DestroyObject(aria->hSession, aria->hKey); {
if (rv == MC_OK) aria->hKey = NULL; MC_RV rv = MC_OK;
} MC_UINT keylen;
if (aria->hSession != NULL) { if (aria->algo == MC_ALGID_ARIA_128BITKEY) {
if (rv == MC_OK) rv = MC_CloseSession(aria->hSession); keylen = ARIA_128_KEY_SIZE;
if (rv == MC_OK) aria->hSession = NULL; } else if (aria->algo == MC_ALGID_ARIA_192BITKEY) {
} keylen = ARIA_192_KEY_SIZE;
} else if (aria->algo == MC_ALGID_ARIA_256BITKEY) {
if (rv != MC_OK) { keylen = ARIA_256_KEY_SIZE;
WOLFSSL_MSG(MC_GetErrorString(rv)); } else {
return BAD_STATE_E; WOLFSSL_MSG_EX("Unsupported algorithm: %d", aria->algo);
} return PUBLIC_KEY_E;
return 0;
} }
/* return 0 on success or BAD_FUNC_ARG/PUBLIC_KEY_E on failure */ if (aria->hKey != NULL) {
int wc_AriaSetKey(wc_Aria* aria, byte* key) if (rv == MC_OK)
{ rv = MC_DestroyObject(aria->hSession, aria->hKey);
MC_RV rv = MC_OK; if (rv == MC_OK)
MC_UINT keylen; aria->hKey = NULL;
if (aria->algo == MC_ALGID_ARIA_128BITKEY) { }
keylen = ARIA_128_KEY_SIZE; if (rv == MC_OK)
} else if (aria->algo == MC_ALGID_ARIA_192BITKEY) { rv = MC_CreateObject(aria->hSession, (MC_UCHAR*)key, keylen, &(aria->hKey));
keylen = ARIA_192_KEY_SIZE;
} else if (aria->algo == MC_ALGID_ARIA_256BITKEY) {
keylen = ARIA_256_KEY_SIZE;
} else {
WOLFSSL_MSG_EX("Unsupported algorithm: %d", aria->algo);
return PUBLIC_KEY_E;
}
if (aria->hKey != NULL) { if (rv != MC_OK) {
if (rv == MC_OK) rv = MC_DestroyObject(aria->hSession, aria->hKey); WOLFSSL_MSG(MC_GetErrorString(rv));
if (rv == MC_OK) aria->hKey = NULL; return BAD_FUNC_ARG;
} }
if (rv == MC_OK) rv = MC_CreateObject(aria->hSession, (MC_UCHAR*)key, keylen, &(aria->hKey)); return 0;
}
if (rv != MC_OK) { static WARN_UNUSED_RESULT WC_INLINE int CheckAriaGcmIvSize(int ivSz) {
WOLFSSL_MSG(MC_GetErrorString(rv)); return (ivSz == GCM_NONCE_MIN_SZ ||
return BAD_FUNC_ARG; ivSz == GCM_NONCE_MID_SZ ||
} ivSz == GCM_NONCE_MAX_SZ);
return 0; }
/* return 0 on success or BAD_FUNC_ARG on failure */
int wc_AriaGcmSetExtIV(wc_Aria* aria, const byte* iv, word32 ivSz)
{
int ret = 0;
if (aria == NULL || iv == NULL || !CheckAriaGcmIvSize((int)ivSz)) {
ret = BAD_FUNC_ARG;
} }
static WARN_UNUSED_RESULT WC_INLINE int CheckAriaGcmIvSize(int ivSz) { if (ret == 0) {
return (ivSz == GCM_NONCE_MIN_SZ || XMEMCPY((byte*)aria->nonce, iv, ivSz);
ivSz == GCM_NONCE_MID_SZ || aria->nonceSz = ivSz;
ivSz == GCM_NONCE_MAX_SZ);
} }
/* return 0 on success or BAD_FUNC_ARG on failure */ return ret;
int wc_AriaGcmSetExtIV(wc_Aria* aria, const byte* iv, word32 ivSz) }
{
int ret = 0;
if (aria == NULL || iv == NULL || !CheckAriaGcmIvSize((int)ivSz)) { /* return 0 on success or BAD_FUNC_ARG on failure */
ret = BAD_FUNC_ARG; int wc_AriaGcmSetIV(wc_Aria* aria, word32 ivSz,
} const byte* ivFixed, word32 ivFixedSz,
WC_RNG* rng)
{
int ret = 0;
if (ret == 0) { if (aria == NULL || rng == NULL || !CheckAriaGcmIvSize((int)ivSz) ||
XMEMCPY((byte*)aria->nonce, iv, ivSz); (ivFixed == NULL && ivFixedSz != 0) ||
aria->nonceSz = ivSz; (ivFixed != NULL && ivFixedSz != AES_IV_FIXED_SZ)) {
} ret = BAD_FUNC_ARG;
return ret;
} }
/* return 0 on success or BAD_FUNC_ARG on failure */ if (ret == 0) {
int wc_AriaGcmSetIV(wc_Aria* aria, word32 ivSz, byte* iv = (byte*)aria->nonce;
const byte* ivFixed, word32 ivFixedSz,
WC_RNG* rng)
{
int ret = 0;
if (aria == NULL || rng == NULL || !CheckAriaGcmIvSize((int)ivSz) || if (ivFixedSz)
(ivFixed == NULL && ivFixedSz != 0) || XMEMCPY(iv, ivFixed, ivFixedSz);
(ivFixed != NULL && ivFixedSz != AES_IV_FIXED_SZ)) {
ret = BAD_FUNC_ARG;
}
if (ret == 0) { ret = wc_RNG_GenerateBlock(rng, iv + ivFixedSz, ivSz - ivFixedSz);
byte* iv = (byte*)aria->nonce;
if (ivFixedSz)
XMEMCPY(iv, ivFixed, ivFixedSz);
ret = wc_RNG_GenerateBlock(rng, iv + ivFixedSz, ivSz - ivFixedSz);
}
if (ret == 0) {
aria->nonceSz = ivSz;
}
return ret;
} }
/* 'out' buffer is expected to be 'inSz + authTagSz' if (ret == 0) {
* return 0 on success or BAD_FUNC_ARG/ENCRYPT_ERROR on failure */ aria->nonceSz = ivSz;
int wc_AriaEncrypt(wc_Aria* aria, byte* out, byte* in, word32 inSz,
byte* iv, word32 ivSz, byte* aad, word32 aadSz,
byte* authTag, word32 authTagSz)
{
MC_RV rv = MC_OK;
MC_ALGPARAM param = {
.pNonce = iv,
.nNonce = ivSz,
.pAData = aad,
.nAData = aadSz,
.nTLen = authTagSz,
.nDataLen = inSz
};
MC_ALGORITHM mcAlg = {aria->algo, NULL, 0};
mcAlg.pParam = (MC_UCHAR*)&param;
mcAlg.nParam = sizeof(param);
MC_UINT outSz = inSz + authTagSz;
if (authTag == NULL || iv == NULL || authTagSz > ARIA_BLOCK_SIZE ||
authTagSz < WOLFSSL_MIN_AUTH_TAG_SZ ||
ivSz == 0 || ivSz > ARIA_BLOCK_SIZE) {
return BAD_FUNC_ARG;
}
if (out == NULL || in == NULL || inSz == 0) {
return BAD_FUNC_ARG;
}
if (out <= in + inSz && in <= out + inSz) { /* check for overlapping range */
return BAD_FUNC_ARG;
}
if (rv == MC_OK) rv = MC_EncryptInit(aria->hSession, &mcAlg, aria->hKey);
if (rv == MC_OK) rv = MC_Encrypt(aria->hSession, in, inSz, out, &outSz);
if (rv == MC_OK) XMEMCPY(authTag, out + inSz, authTagSz);
if (rv != MC_OK) {
WOLFSSL_MSG(MC_GetErrorString(rv));
return ENCRYPT_ERROR;
}
return 0;
} }
/* 'in' buffer is expected to be 'inSz + authTagSz' return ret;
* return 0 on success or BAD_FUNC_ARG/ENCRYPT_ERROR on failure */ }
int wc_AriaDecrypt(wc_Aria* aria, byte* out, byte* in, word32 inSz,
byte* iv, word32 ivSz, byte* aad, word32 aadSz,
byte* authTag, word32 authTagSz)
{
MC_RV rv = MC_OK;
MC_ALGPARAM param = { /* 'out' buffer is expected to be 'inSz + authTagSz'
.pNonce = iv, * return 0 on success or BAD_FUNC_ARG/ENCRYPT_ERROR on failure */
.nNonce = ivSz, int wc_AriaEncrypt(wc_Aria* aria, byte* out, byte* in, word32 inSz,
.pAData = aad, byte* iv, word32 ivSz, byte* aad, word32 aadSz,
.nAData = aadSz, byte* authTag, word32 authTagSz)
.nTLen = authTagSz, {
.nDataLen = inSz MC_RV rv = MC_OK;
};
MC_ALGORITHM mcAlg = {aria->algo, NULL, 0};
mcAlg.pParam = (MC_UCHAR*)&param;
mcAlg.nParam = sizeof(param);
MC_UINT outSz = inSz;
if (authTag == NULL || iv == NULL || authTagSz > ARIA_BLOCK_SIZE || MC_ALGPARAM param = {
authTagSz < WOLFSSL_MIN_AUTH_TAG_SZ || .pNonce = iv,
ivSz == 0 || ivSz > ARIA_BLOCK_SIZE) { .nNonce = ivSz,
return BAD_FUNC_ARG; .pAData = aad,
} .nAData = aadSz,
if (out == NULL || in == NULL || inSz == 0) { .nTLen = authTagSz,
return BAD_FUNC_ARG; .nDataLen = inSz
} };
if (out <= in + inSz && in <= out + inSz) { /* check for overlapping range */ MC_UINT outSz = inSz + authTagSz;
return BAD_FUNC_ARG; MC_ALGORITHM mcAlg = {aria->algo, NULL, 0};
} mcAlg.pParam = (MC_UCHAR*)&param;
mcAlg.nParam = sizeof(param);
if (rv == MC_OK) rv = MC_DecryptInit(aria->hSession, &mcAlg, aria->hKey); if (authTag == NULL || iv == NULL || authTagSz > ARIA_BLOCK_SIZE ||
authTagSz < WOLFSSL_MIN_AUTH_TAG_SZ ||
if (rv == MC_OK) { ivSz == 0 || ivSz > ARIA_BLOCK_SIZE) {
XMEMCPY((byte*)in + inSz, authTag, authTagSz); return BAD_FUNC_ARG;
inSz += authTagSz;
}
if (rv == MC_OK) rv = MC_Decrypt(aria->hSession, in, inSz, out, &outSz);
if (rv != MC_OK) {
WOLFSSL_MSG(MC_GetErrorString(rv));
return DECRYPT_ERROR;
}
return 0;
} }
if (out == NULL || in == NULL || inSz == 0) {
return BAD_FUNC_ARG;
}
if (out <= in + inSz && in <= out + inSz) { /* check for overlapping range */
return BAD_FUNC_ARG;
}
if (rv == MC_OK)
rv = MC_EncryptInit(aria->hSession, &mcAlg, aria->hKey);
if (rv == MC_OK)
rv = MC_Encrypt(aria->hSession, in, inSz, out, &outSz);
if (rv == MC_OK)
XMEMCPY(authTag, out + inSz, authTagSz);
if (rv != MC_OK) {
WOLFSSL_MSG(MC_GetErrorString(rv));
return ENCRYPT_ERROR;
}
return 0;
}
/* 'in' buffer is expected to be 'inSz + authTagSz'
* return 0 on success or BAD_FUNC_ARG/ENCRYPT_ERROR on failure */
int wc_AriaDecrypt(wc_Aria* aria, byte* out, byte* in, word32 inSz,
byte* iv, word32 ivSz, byte* aad, word32 aadSz,
byte* authTag, word32 authTagSz)
{
MC_RV rv = MC_OK;
MC_ALGPARAM param = {
.pNonce = iv,
.nNonce = ivSz,
.pAData = aad,
.nAData = aadSz,
.nTLen = authTagSz,
.nDataLen = inSz
};
MC_UINT outSz = inSz;
MC_ALGORITHM mcAlg = {aria->algo, NULL, 0};
mcAlg.pParam = (MC_UCHAR*)&param;
mcAlg.nParam = sizeof(param);
if (authTag == NULL || iv == NULL || authTagSz > ARIA_BLOCK_SIZE ||
authTagSz < WOLFSSL_MIN_AUTH_TAG_SZ ||
ivSz == 0 || ivSz > ARIA_BLOCK_SIZE) {
return BAD_FUNC_ARG;
}
if (out == NULL || in == NULL || inSz == 0) {
return BAD_FUNC_ARG;
}
if (out <= in + inSz && in <= out + inSz) { /* check for overlapping range */
return BAD_FUNC_ARG;
}
if (rv == MC_OK)
rv = MC_DecryptInit(aria->hSession, &mcAlg, aria->hKey);
if (rv == MC_OK) {
XMEMCPY((byte*)in + inSz, authTag, authTagSz);
inSz += authTagSz;
}
if (rv == MC_OK)
rv = MC_Decrypt(aria->hSession, in, inSz, out, &outSz);
if (rv != MC_OK) {
WOLFSSL_MSG(MC_GetErrorString(rv));
return DECRYPT_ERROR;
}
return 0;
}
#endif /* HAVE_ARIA */ #endif /* HAVE_ARIA */

1013
wolfcrypt/src/port/aria/aria-cryptocb.c
View File

File diff suppressed because it is too large Load Diff