wolfSSL/wolfssl
1
0
Fork 1
mirror of https://github.com/wolfSSL/wolfssl.git synced 2026-07-05 15:10:48 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
master
wolfssl/bsdkm/wolfkmod_aes.c
T
jordan cfdbeac11b bsdkm: fenrir and misc cleanup.
2026-06-25 22:43:38 -05:00

369 lines
11 KiB
C
Raw Permalink Blame History

#if !defined(WC_SKIP_INCLUDED_C_FILES) && defined(BSDKM_CRYPTO_REGISTER)
#include <wolfssl/wolfcrypt/aes.h>
/*
* the cryptodev framework always calls a callback, even when CRYPTOCAP_F_SYNC.
*/
static int
wolfkdriv_test_crp_callback(struct cryptop * crp)
{
(void)crp;
return (0);
}
/* Test aes-cbc with a buffer larger than aes block size.
* Verify direct wolfcrypt API and opencrypto framework return
* same result. */
static int wolfkdriv_test_aes_cbc_big(device_t dev, int crid)
{
crypto_session_t session = NULL;
struct crypto_session_params csp;
struct cryptop * crp = NULL;
Aes * aes_encrypt = NULL;
int error = -1;
byte msg[] = {
0x6e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,
0x68,0x65,0x20,0x74,0x69,0x6d,0x65,0x20,
0x6e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,
0x68,0x65,0x20,0x74,0x69,0x6d,0x65,0x20,
0x6e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,
0x68,0x65,0x20,0x74,0x69,0x6d,0x65,0x20
};
byte work1[WC_AES_BLOCK_SIZE * 3]; /* wolfcrypt buffer */
byte work2[WC_AES_BLOCK_SIZE * 3]; /* opencrypto buffer */
/* padded to 16-bytes */
const byte key[] = "0123456789abcdef ";
/* padded to 16-bytes */
const byte iv[] = "1234567890abcdef ";
memset(&csp, 0, sizeof(csp));
memcpy(work1, msg, sizeof(msg)); /* wolfcrypt work buffer */
memcpy(work2, msg, sizeof(msg)); /* opencrypto work buffer */
/* wolfcrypt encrypt */
aes_encrypt = (Aes *)XMALLOC(sizeof(Aes), NULL, DYNAMIC_TYPE_AES);
if (aes_encrypt == NULL) {
error = ENOMEM;
device_printf(dev, "error: malloc failed\n");
goto test_aes_cbc_big_out;
}
error = wc_AesInit(aes_encrypt, NULL, INVALID_DEVID);
if (error) {
device_printf(dev, "error: wc_AesInit: %d\n", error);
goto test_aes_cbc_big_out;
}
error = wc_AesSetKey(aes_encrypt, key, 16, iv, AES_ENCRYPTION);
if (error) {
device_printf(dev, "error: wc_AesSetKey: %d\n", error);
goto test_aes_cbc_big_out;
}
error = wc_AesCbcEncrypt(aes_encrypt, work1, work1, sizeof(work1));
if (error) {
device_printf(dev, "error: wc_AesCbcEncrypt: %d\n", error);
goto test_aes_cbc_big_out;
}
/* opencrypto encrypt */
csp.csp_mode = CSP_MODE_CIPHER;
csp.csp_cipher_alg = CRYPTO_AES_CBC;
csp.csp_ivlen = WC_AES_BLOCK_SIZE;
csp.csp_cipher_key = key;
csp.csp_cipher_klen = WC_AES_BLOCK_SIZE;
/* get crypto session handle */
error = crypto_newsession(&session, &csp, crid);
if (error || session == NULL) {
device_printf(dev, "error: test_aes: crypto_newsession: %d, %p\n",
error, (void *)session);
error = ENOMEM;
goto test_aes_cbc_big_out;
}
crp = crypto_getreq(session, M_WAITOK);
if (crp == NULL) {
device_printf(dev, "error: test_aes: crypto_getreq failed\n");
error = ENOMEM;
goto test_aes_cbc_big_out;
}
/* configure it.
* note: CRYPTO_F_CBIFSYNC is required, or the callback may be deferred
* to later, even if the session was sync. */
crp->crp_callback = wolfkdriv_test_crp_callback;
crp->crp_op = CRYPTO_OP_ENCRYPT;
crp->crp_flags = CRYPTO_F_IV_SEPARATE | CRYPTO_F_CBIFSYNC;
memcpy(crp->crp_iv, iv, WC_AES_BLOCK_SIZE);
crypto_use_buf(crp, work2, sizeof(work2));
crp->crp_payload_start = 0;
crp->crp_payload_length = sizeof(work2);
error = crypto_dispatch(crp);
if (error) {
goto test_aes_cbc_big_out;
}
error = XMEMCMP(work1, work2, sizeof(work2));
if (error) {
device_printf(dev, "error: test_aes: enc vectors diff: %d\n", error);
goto test_aes_cbc_big_out;
}
/* opencrypto decrypt */
crp->crp_op = CRYPTO_OP_DECRYPT;
error = crypto_dispatch(crp);
if (error) {
goto test_aes_cbc_big_out;
}
error = XMEMCMP(work2, msg, sizeof(msg));
if (error) {
device_printf(dev, "error: test_aes: dec vectors diff: %d\n", error);
goto test_aes_cbc_big_out;
}
device_printf(dev, "info: test_aes_cbc_big: passed\n");
test_aes_cbc_big_out:
#if defined(WOLFSSL_BSDKM_VERBOSE_DEBUG)
device_printf(dev, "info: test_aes_cbc_big: error=%d, session=%p, crp=%p\n",
error, (void *)session, (void*)crp);
#endif /* WOLFSSL_BSDKM_VERBOSE_DEBUG */
if (crp != NULL) {
crypto_freereq(crp);
crp = NULL;
}
if (session != NULL) {
crypto_freesession(session);
session = NULL;
}
if (aes_encrypt != NULL) {
wc_AesFree(aes_encrypt);
XFREE(aes_encrypt, NULL, DYNAMIC_TYPE_AES);
aes_encrypt = NULL;
}
return (error);
}
/* Test aes-gcm encrypt and decrypt a small buffer with opencrypto
* framework and wolfcrypt.
*/
static int wolfkdriv_test_aes_gcm(device_t dev, int crid)
{
crypto_session_t session = NULL;
struct crypto_session_params csp;
struct cryptop * crp = NULL;
Aes * enc = NULL;
int error = -1;
WOLFSSL_SMALL_STACK_STATIC const byte p[] =
{
0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
0xba, 0x63, 0x7b, 0x39
};
WOLFSSL_SMALL_STACK_STATIC const byte c1[] =
{
0x52, 0x2d, 0xc1, 0xf0, 0x99, 0x56, 0x7d, 0x07,
0xf4, 0x7f, 0x37, 0xa3, 0x2a, 0x84, 0x42, 0x7d,
0x64, 0x3a, 0x8c, 0xdc, 0xbf, 0xe5, 0xc0, 0xc9,
0x75, 0x98, 0xa2, 0xbd, 0x25, 0x55, 0xd1, 0xaa,
0x8c, 0xb0, 0x8e, 0x48, 0x59, 0x0d, 0xbb, 0x3d,
0xa7, 0xb0, 0x8b, 0x10, 0x56, 0x82, 0x88, 0x38,
0xc5, 0xf6, 0x1e, 0x63, 0x93, 0xba, 0x7a, 0x0a,
0xbc, 0xc9, 0xf6, 0x62
};
WOLFSSL_SMALL_STACK_STATIC byte a[] =
{
0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
0xab, 0xad, 0xda, 0xd2
};
WOLFSSL_SMALL_STACK_STATIC const byte k1[] =
{
0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08,
0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08
};
WOLFSSL_SMALL_STACK_STATIC const byte iv1[] =
{
0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
0xde, 0xca, 0xf8, 0x88
};
WOLFSSL_SMALL_STACK_STATIC const byte t1[] =
{
0x76, 0xfc, 0x6e, 0xce, 0x0f, 0x4e, 0x17, 0x68,
0xcd, 0xdf, 0x88, 0x53, 0xbb, 0x2d, 0x55, 0x1b
};
byte resultT[sizeof(t1) + WC_AES_BLOCK_SIZE];
byte resultC[sizeof(p) + WC_AES_BLOCK_SIZE];
byte resultC2[sizeof(p) + WC_AES_BLOCK_SIZE];
XMEMSET(resultT, 0, sizeof(resultT));
XMEMSET(resultC, 0, sizeof(resultC));
XMEMSET(resultC2, 0, sizeof(resultC2));
XMEMCPY(resultC2, p, sizeof(p));
/* wolfcrypt encrypt */
enc = (Aes *)XMALLOC(sizeof(Aes), NULL, DYNAMIC_TYPE_AES);
if (enc == NULL) {
error = ENOMEM;
device_printf(dev, "error: malloc failed\n");
goto test_aes_gcm_out;
}
error = wc_AesInit(enc, NULL, INVALID_DEVID);
if (error) {
device_printf(dev, "error: wc_AesInit: %d\n", error);
goto test_aes_gcm_out;
}
error = wc_AesGcmEncryptInit(enc, k1, sizeof(k1), iv1, sizeof(iv1));
if (error) { goto test_aes_gcm_out; }
error = wc_AesGcmEncryptUpdate(enc, resultC, p, sizeof(p), a, sizeof(a));
if (error) { goto test_aes_gcm_out; }
error = wc_AesGcmEncryptFinal(enc, resultT, sizeof(t1));
if (error) { goto test_aes_gcm_out; }
error = XMEMCMP(resultC, c1, sizeof(c1));
if (error) { goto test_aes_gcm_out; }
error = XMEMCMP(resultT, t1, sizeof(t1));
if (error) { goto test_aes_gcm_out; }
/*
* opencrypto encrypt
* */
/* set crypto session params */
memset(&csp, 0, sizeof(csp));
csp.csp_flags |= CSP_F_SEPARATE_AAD;
csp.csp_mode = CSP_MODE_AEAD;
csp.csp_cipher_alg = CRYPTO_AES_NIST_GCM_16;
csp.csp_ivlen = sizeof(iv1);
csp.csp_cipher_key = k1;
csp.csp_cipher_klen = sizeof(k1);
/* get crypto session handle */
error = crypto_newsession(&session, &csp, crid);
if (error || session == NULL) {
device_printf(dev, "error: test_aes: crypto_newsession: %d, %p\n",
error, (void *)session);
error = ENOMEM;
goto test_aes_gcm_out;
}
/* get a crypto op handle */
crp = crypto_getreq(session, M_WAITOK);
if (crp == NULL) {
device_printf(dev, "error: test_aes: crypto_getreq failed\n");
error = ENOMEM;
goto test_aes_gcm_out;
}
/* configure it.
* note: CRYPTO_F_CBIFSYNC is required, or the callback may be deferred
* to later, even if the session was sync. */
crp->crp_callback = wolfkdriv_test_crp_callback;
crp->crp_op = (CRYPTO_OP_ENCRYPT | CRYPTO_OP_COMPUTE_DIGEST);
crp->crp_flags = CRYPTO_F_IV_SEPARATE | CRYPTO_F_CBIFSYNC;
memcpy(crp->crp_iv, iv1, sizeof(iv1));
crypto_use_buf(crp, resultC2, sizeof(resultC2));
crp->crp_payload_start = 0;
crp->crp_payload_length = sizeof(p);
crp->crp_aad = a;
crp->crp_aad_start = 0;
crp->crp_aad_length = sizeof(a);
crp->crp_digest_start = crp->crp_payload_start + sizeof(p);
error = crypto_dispatch(crp);
if (error) {
goto test_aes_gcm_out;
}
error = XMEMCMP(resultC2, c1, sizeof(c1));
if (error) { goto test_aes_gcm_out; }
error = XMEMCMP(resultC2 + sizeof(p), t1, sizeof(t1));
if (error) { goto test_aes_gcm_out; }
/* opencrypto decrypt */
crp->crp_op = (CRYPTO_OP_DECRYPT | CRYPTO_OP_VERIFY_DIGEST);
error = crypto_dispatch(crp);
if (error) {
goto test_aes_gcm_out;
}
error = XMEMCMP(resultC2, p, sizeof(p));
if (error) { goto test_aes_gcm_out; }
device_printf(dev, "info: test_aes_gcm: passed\n");
test_aes_gcm_out:
#if defined(WOLFSSL_BSDKM_VERBOSE_DEBUG)
device_printf(dev, "info: test_aes_gcm: error=%d, session=%p, crp=%p\n",
error, (void *)session, (void*)crp);
#endif /* WOLFSSL_BSDKM_VERBOSE_DEBUG */
if (crp != NULL) {
crypto_freereq(crp);
crp = NULL;
}
if (session != NULL) {
crypto_freesession(session);
session = NULL;
}
if (enc != NULL) {
wc_AesFree(enc);
XFREE(enc, NULL, DYNAMIC_TYPE_AES);
enc = NULL;
}
return (error);
}
static int wolfkdriv_test_aes(device_t dev, int crid)
{
int error = 0;
if (error == 0) {
error = wolfkdriv_test_aes_cbc_big(dev, crid);
}
if (error == 0) {
error = wolfkdriv_test_aes_gcm(dev, crid);
}
return (error);
}
#endif /* !WC_SKIP_INCLUDED_C_FILES && BSDKM_CRYPTO_REGISTER */
Reference in New Issue View Git Blame Copy Permalink