diff --git a/tests/api/test_pkcs11.c b/tests/api/test_pkcs11.c index 4fd54f54560..5af56fe4efd 100644 --- a/tests/api/test_pkcs11.c +++ b/tests/api/test_pkcs11.c @@ -75,6 +75,14 @@ defined(TEST_PKCS11_RD_MLKEM_DEC) || defined(TEST_PKCS11_RD_CERT) #define TEST_PKCS11_VALUE_READ #endif +#if !defined(NO_AES) && !defined(NO_PKCS11_AES) && \ + defined(WOLFSSL_AES_COUNTER) && defined(WOLFSSL_AES_128) && \ + !defined(WOLF_CRYPTO_CB_ONLY_AES) + #define TEST_PKCS11_AES_CTR +#endif + +#define TEST_PKCS11_DEVID 0x7031 +#define TEST_CKR_GENERAL_ERROR ((CK_RV)0x00000005UL) #ifdef TEST_PKCS11_ECDSA static int test_pkcs11_verify_init_calls = 0; @@ -97,7 +105,8 @@ static CK_RV test_pkcs11_get_mechanism_info(CK_SLOT_ID slotId, } #endif -#if defined(TEST_PKCS11_ECDSA) || defined(TEST_PKCS11_VALUE_READ) +#if defined(TEST_PKCS11_ECDSA) || defined(TEST_PKCS11_VALUE_READ) || \ + defined(TEST_PKCS11_AES_CTR) static CK_RV test_pkcs11_create_object(CK_SESSION_HANDLE session, CK_ATTRIBUTE_PTR template, CK_ULONG count, CK_OBJECT_HANDLE_PTR object) { @@ -1218,7 +1227,6 @@ int test_wc_Pkcs11_EcdsaSigDecode(void) #define TEST_PKCS11_MAX_OBJS 8 #define TEST_PKCS11_MAX_ID_LEN 32 -#define TEST_CKR_GENERAL_ERROR ((CK_RV)0x00000005UL) typedef struct TestPkcs11Obj { int used; @@ -1815,8 +1823,6 @@ int test_wc_Pkcs11_RsaIdNoLeak(void) return EXPECT_RESULT(); } -#define TEST_PKCS11_DEVID 0x7031 - #ifndef NO_PKCS11_ECDH #define TEST_PKCS11_DFLT_DERIVE CK_TRUE #define TEST_PKCS11_NONAME_SIGN CK_FALSE @@ -2359,3 +2365,242 @@ int test_wc_Pkcs11_RsaKeyGenError(void) } #endif /* TEST_PKCS11_ECDSA */ + +#ifdef TEST_PKCS11_AES_CTR +/* Same layout as CK_AES_CTR_PARAMS in wc_pkcs11.c. */ +typedef struct TestPkcs11CtrParams { + CK_ULONG ulCounterBits; + CK_BYTE cb[WC_AES_BLOCK_SIZE]; +} TestPkcs11CtrParams; + +static const byte test_pkcs11_ctr_key[16] = { + 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, + 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c +}; +static byte test_pkcs11_ctr_cb[WC_AES_BLOCK_SIZE]; +static int test_pkcs11_ctr_inits = 0; +static int test_pkcs11_ctr_encrypts = 0; +static int test_pkcs11_ctr_fail_at = 0; +static int test_pkcs11_ctr_no_mech = 0; + +static CK_RV test_pkcs11_ctr_mech_info(CK_SLOT_ID slotId, + CK_MECHANISM_TYPE type, CK_MECHANISM_INFO_PTR info) +{ + (void)slotId; + + if (type != CKM_AES_CTR || info == NULL || test_pkcs11_ctr_no_mech) + return CKR_MECHANISM_INVALID; + + XMEMSET(info, 0, sizeof(*info)); + info->flags = CKF_ENCRYPT; + return CKR_OK; +} + +static CK_RV test_pkcs11_ctr_encrypt_init(CK_SESSION_HANDLE session, + CK_MECHANISM_PTR mech, CK_OBJECT_HANDLE key) +{ + TestPkcs11CtrParams* params; + + (void)session; + (void)key; + + if (mech == NULL || mech->mechanism != CKM_AES_CTR || + mech->pParameter == NULL || + mech->ulParameterLen != sizeof(TestPkcs11CtrParams)) + return CKR_MECHANISM_INVALID; + + params = (TestPkcs11CtrParams*)mech->pParameter; + if (params->ulCounterBits != WC_AES_BLOCK_SIZE * 8) + return CKR_MECHANISM_INVALID; + + XMEMCPY(test_pkcs11_ctr_cb, params->cb, WC_AES_BLOCK_SIZE); + test_pkcs11_ctr_inits++; + return CKR_OK; +} + +/* Single-part AES-CTR from the counter given to the last C_EncryptInit. */ +static CK_RV test_pkcs11_ctr_encrypt(CK_SESSION_HANDLE session, + CK_BYTE_PTR in, CK_ULONG inLen, CK_BYTE_PTR out, CK_ULONG_PTR outLen) +{ + CK_RV rv = CKR_OK; + Aes aes; + + (void)session; + + test_pkcs11_ctr_encrypts++; + if (test_pkcs11_ctr_encrypts == test_pkcs11_ctr_fail_at) + return TEST_CKR_GENERAL_ERROR; + if (in == NULL || out == NULL || outLen == NULL || *outLen < inLen) + return TEST_CKR_GENERAL_ERROR; + + if (wc_AesInit(&aes, NULL, INVALID_DEVID) != 0) + return TEST_CKR_GENERAL_ERROR; + if (wc_AesSetKey(&aes, test_pkcs11_ctr_key, sizeof(test_pkcs11_ctr_key), + test_pkcs11_ctr_cb, AES_ENCRYPTION) != 0) { + rv = TEST_CKR_GENERAL_ERROR; + } + if (rv == CKR_OK && + wc_AesCtrEncrypt(&aes, out, in, (word32)inLen) != 0) { + rv = TEST_CKR_GENERAL_ERROR; + } + wc_AesFree(&aes); + + if (rv == CKR_OK) + *outLen = inLen; + return rv; +} + +/* Encrypt in from the start of iv, in calls of the given sizes. */ +static int test_pkcs11_ctr_split(Aes* aes, const byte* iv, const byte* in, + byte* out, const word32* parts, int cnt) +{ + int ret; + int i; + word32 off = 0; + + ret = wc_AesSetIV(aes, iv); + for (i = 0; ret == 0 && i < cnt; i++) { + ret = wc_AesCtrEncrypt(aes, out + off, in + off, parts[i]); + off += parts[i]; + } + return ret; +} +#endif /* TEST_PKCS11_AES_CTR */ + +int test_wc_Pkcs11_AesCtrStream(void) +{ + EXPECT_DECLS; +#ifdef TEST_PKCS11_AES_CTR + static const word32 split1[] = { 64 }; + static const word32 split2[] = { 32, 32 }; + static const word32 split3[] = { 16, 16, 16, 16 }; + static const word32 split4[] = { 10, 22, 32 }; + static const word32 split5[] = { 10, 10, 3, 41 }; + static const word32 split6[] = { 3, 13, 48 }; + static const word32* splits[] = { + split1, split2, split3, split4, split5, split6 + }; + static const int splitCnt[] = { 1, 2, 4, 3, 4, 3 }; + static const word32 wrapSplit[] = { 16, 16 }; + byte iv[WC_AES_BLOCK_SIZE]; + byte wrapIv[WC_AES_BLOCK_SIZE]; + byte reg[WC_AES_BLOCK_SIZE]; + byte tmp[WC_AES_BLOCK_SIZE]; + byte plain[64]; + byte ref[64]; + byte out[64]; + byte zeros[64]; + word32 left = 0; + int inits = 0; + int i; + Pkcs11Token token; + CK_FUNCTION_LIST func; + Aes sw; + Aes dev; + + for (i = 0; i < (int)sizeof(plain); i++) + plain[i] = (byte)i; + for (i = 0; i < WC_AES_BLOCK_SIZE; i++) + iv[i] = (byte)(0xf0 + i); + XMEMSET(wrapIv, 0xff, sizeof(wrapIv)); + XMEMSET(zeros, 0, sizeof(zeros)); + + XMEMSET(&sw, 0, sizeof(sw)); + XMEMSET(&dev, 0, sizeof(dev)); + XMEMSET(&token, 0, sizeof(token)); + XMEMSET(&func, 0, sizeof(func)); + func.C_GetMechanismInfo = test_pkcs11_ctr_mech_info; + func.C_CreateObject = test_pkcs11_create_object; + func.C_DestroyObject = test_pkcs11_destroy_object; + func.C_EncryptInit = test_pkcs11_ctr_encrypt_init; + func.C_Encrypt = test_pkcs11_ctr_encrypt; + token.func = &func; + token.slotId = 1; + token.handle = 1; + token.version = WC_PCKS11VERSION_2_40; + test_pkcs11_ctr_inits = 0; + test_pkcs11_ctr_encrypts = 0; + test_pkcs11_ctr_fail_at = 0; + test_pkcs11_ctr_no_mech = 0; + ExpectIntEQ(wc_CryptoCb_RegisterDevice(TEST_PKCS11_DEVID, + wc_Pkcs11_CryptoDevCb, &token), 0); + + ExpectIntEQ(wc_AesInit(&sw, NULL, INVALID_DEVID), 0); + ExpectIntEQ(wc_AesSetKey(&sw, test_pkcs11_ctr_key, + sizeof(test_pkcs11_ctr_key), iv, AES_ENCRYPTION), 0); + ExpectIntEQ(wc_AesCtrEncrypt(&sw, ref, plain, sizeof(plain)), 0); + + ExpectIntEQ(wc_AesInit(&dev, NULL, TEST_PKCS11_DEVID), 0); + ExpectIntEQ(wc_AesSetKey(&dev, test_pkcs11_ctr_key, + sizeof(test_pkcs11_ctr_key), iv, AES_ENCRYPTION), 0); + + /* Any split of the stream gives the software one-shot output. */ + for (i = 0; i < (int)(sizeof(splitCnt) / sizeof(splitCnt[0])); i++) { + XMEMSET(out, 0, sizeof(out)); + ExpectIntEQ(test_pkcs11_ctr_split(&dev, iv, plain, out, splits[i], + splitCnt[i]), 0); + ExpectBufEQ(out, ref, sizeof(ref)); + } + + /* Setting the IV drops the unused keystream of the last call. */ + ExpectIntEQ(wc_AesCtrEncrypt(&dev, out, plain, 10), 0); + XMEMSET(out, 0, sizeof(out)); + ExpectIntEQ(test_pkcs11_ctr_split(&dev, iv, plain, out, split1, 1), 0); + ExpectBufEQ(out, ref, sizeof(ref)); + + /* A call served from the unused keystream does not use the token. */ + XMEMSET(out, 0, sizeof(out)); + ExpectIntEQ(wc_AesSetIV(&dev, iv), 0); + ExpectIntEQ(wc_AesCtrEncrypt(&dev, out, plain, 10), 0); + inits = test_pkcs11_ctr_inits; + ExpectIntEQ(wc_AesCtrEncrypt(&dev, out + 10, plain + 10, 3), 0); + ExpectIntEQ(test_pkcs11_ctr_inits, inits); + ExpectIntEQ(wc_AesCtrEncrypt(&dev, out + 13, plain + 13, 51), 0); + ExpectBufEQ(out, ref, sizeof(ref)); + + /* A failed call after leftover keystream wipes the output and keeps the + * state. i = 1: the whole-block call fails, i = 2: the tail call fails. */ + for (i = 1; i <= 2; i++) { + XMEMSET(out, 0, sizeof(out)); + ExpectIntEQ(wc_AesSetIV(&dev, iv), 0); + ExpectIntEQ(wc_AesCtrEncrypt(&dev, out, plain, 10), 0); + XMEMCPY(reg, dev.reg, sizeof(reg)); + XMEMCPY(tmp, dev.tmp, sizeof(tmp)); + left = dev.left; + XMEMSET(out + 10, 0xa5, 26); + test_pkcs11_ctr_fail_at = test_pkcs11_ctr_encrypts + i; + ExpectIntEQ(wc_AesCtrEncrypt(&dev, out + 10, plain + 10, 26), + WC_NO_ERR_TRACE(WC_HW_E)); + test_pkcs11_ctr_fail_at = 0; + ExpectBufEQ(dev.reg, reg, sizeof(reg)); + ExpectBufEQ(dev.tmp, tmp, sizeof(tmp)); + ExpectIntEQ(dev.left, left); + ExpectBufEQ(out + 10, zeros, 26); + ExpectIntEQ(wc_AesCtrEncrypt(&dev, out + 10, plain + 10, 54), 0); + ExpectBufEQ(out, ref, sizeof(ref)); + } + + /* Software fallback in place continues the stream from the token. */ + XMEMSET(out, 0, sizeof(out)); + ExpectIntEQ(wc_AesSetIV(&dev, iv), 0); + ExpectIntEQ(wc_AesCtrEncrypt(&dev, out, plain, 10), 0); + XMEMCPY(out + 10, plain + 10, sizeof(out) - 10); + test_pkcs11_ctr_no_mech = 1; + ExpectIntEQ(wc_AesCtrEncrypt(&dev, out + 10, out + 10, 54), 0); + test_pkcs11_ctr_no_mech = 0; + ExpectBufEQ(out, ref, sizeof(ref)); + + /* The counter wraps from all ones to zero as in software. */ + ExpectIntEQ(wc_AesSetIV(&sw, wrapIv), 0); + ExpectIntEQ(wc_AesCtrEncrypt(&sw, ref, plain, 32), 0); + XMEMSET(out, 0, sizeof(out)); + ExpectIntEQ(test_pkcs11_ctr_split(&dev, wrapIv, plain, out, wrapSplit, + 2), 0); + ExpectBufEQ(out, ref, 32); + + wc_AesFree(&dev); + wc_AesFree(&sw); + wc_CryptoCb_UnRegisterDevice(TEST_PKCS11_DEVID); +#endif + return EXPECT_RESULT(); +} diff --git a/tests/api/test_pkcs11.h b/tests/api/test_pkcs11.h index cf700e87de9..e23495b25cd 100644 --- a/tests/api/test_pkcs11.h +++ b/tests/api/test_pkcs11.h @@ -26,6 +26,7 @@ int test_wc_Pkcs11_EcdsaSigDecode(void); int test_wc_Pkcs11_ValueRead(void); +int test_wc_Pkcs11_AesCtrStream(void); #if defined(HAVE_PKCS11) && defined(HAVE_ECC) && !defined(NO_PKCS11_ECC) && \ defined(HAVE_ECC_VERIFY) && !defined(WC_NO_RNG) && \ @@ -48,13 +49,15 @@ int test_wc_Pkcs11_KeyGenSessionClosed(void); TEST_DECL_GROUP("pkcs11", test_wc_Pkcs11_RsaKeyGenExponent), \ TEST_DECL_GROUP("pkcs11", test_wc_Pkcs11_FreeNoObject), \ TEST_DECL_GROUP("pkcs11", test_wc_Pkcs11_KeyGenSessionClosed), \ - TEST_DECL_GROUP("pkcs11", test_wc_Pkcs11_ValueRead) + TEST_DECL_GROUP("pkcs11", test_wc_Pkcs11_ValueRead), \ + TEST_DECL_GROUP("pkcs11", test_wc_Pkcs11_AesCtrStream) #else #define TEST_PKCS11_DECLS \ TEST_DECL_GROUP("pkcs11", test_wc_Pkcs11_EcdsaSigDecode), \ - TEST_DECL_GROUP("pkcs11", test_wc_Pkcs11_ValueRead) + TEST_DECL_GROUP("pkcs11", test_wc_Pkcs11_ValueRead), \ + TEST_DECL_GROUP("pkcs11", test_wc_Pkcs11_AesCtrStream) #endif diff --git a/wolfcrypt/src/wc_pkcs11.c b/wolfcrypt/src/wc_pkcs11.c index a918d5374ba..337b1807c0c 100644 --- a/wolfcrypt/src/wc_pkcs11.c +++ b/wolfcrypt/src/wc_pkcs11.c @@ -6295,8 +6295,76 @@ static int Pkcs11AesCbcDecrypt(Pkcs11Session* session, wc_CryptoInfo* info) #endif #if !defined(NO_AES) && defined(WOLFSSL_AES_COUNTER) +/** + * Adds a number of blocks to a big-endian AES-CTR counter block. + * The whole block is the counter, so it wraps at 2^128. + * + * @param [in, out] ctr Counter block. + * @param [in] blocks Number of blocks to add. + */ +static WC_INLINE void Pkcs11AesCtrAdd(byte* ctr, word32 blocks) +{ + int i; + word32 carry = blocks; + + for (i = WC_AES_BLOCK_SIZE - 1; i >= 0 && carry != 0; i--) { + carry += ctr[i]; + ctr[i] = WC_OCTET(carry); + carry >>= 8; + } +} + +/** + * Performs one single-part AES-CTR encryption starting at a counter block. + * + * @param [in] session Session object. + * @param [in] key Handle of the AES key object. + * @param [in] ctr Counter block to start from. + * @param [in] in Data to encrypt. + * @param [out] out Buffer to hold encrypted data. + * @param [in] sz Length of data in bytes. + * @return WC_HW_E when a PKCS#11 library call fails. + * @return 0 on success. + */ +static int Pkcs11AesCtrOp(Pkcs11Session* session, CK_OBJECT_HANDLE key, + const byte* ctr, const byte* in, byte* out, + word32 sz) +{ + int ret = 0; + CK_RV rv; + CK_AES_CTR_PARAMS params; + CK_MECHANISM mech; + CK_ULONG outLen = sz; + + XMEMSET(¶ms, 0, sizeof(params)); + params.ulCounterBits = WC_AES_BLOCK_SIZE * 8; + XMEMCPY(params.cb, ctr, WC_AES_BLOCK_SIZE); + + mech.mechanism = CKM_AES_CTR; + mech.ulParameterLen = sizeof(params); + mech.pParameter = ¶ms; + + rv = session->func->C_EncryptInit(session->handle, &mech, key); + PKCS11_RV("C_EncryptInit", rv); + if (rv != CKR_OK) { + ret = WC_HW_E; + } + if (ret == 0) { + rv = session->func->C_Encrypt(session->handle, (CK_BYTE_PTR)in, sz, + out, &outLen); + PKCS11_RV("C_Encrypt", rv); + if (rv != CKR_OK || outLen != sz) { + ret = WC_HW_E; + } + } + + return ret; +} + /** * Performs the AES-CTR encryption operation. + * The counter and the unused keystream of a partial block are kept in the + * Aes object between calls. * * @param [in] session Session object. * @param [in] info Cryptographic operation data. @@ -6307,20 +6375,34 @@ static int Pkcs11AesCbcDecrypt(Pkcs11Session* session, wc_CryptoInfo* info) static int Pkcs11AesCtrEncrypt(Pkcs11Session* session, wc_CryptoInfo* info) { int ret = 0; - CK_RV rv; Aes* aes = info->cipher.aesctr.aes; + const byte* in = info->cipher.aesctr.in; + byte* out = info->cipher.aesctr.out; + word32 sz = info->cipher.aesctr.sz; + word32 fromLeft; + word32 blocks; + word32 rem; CK_MECHANISM_INFO mechInfo; - CK_AES_CTR_PARAMS params; CK_OBJECT_HANDLE key = NULL_PTR; - CK_MECHANISM mech; - CK_ULONG outLen; + byte ctr[WC_AES_BLOCK_SIZE]; + byte zeros[WC_AES_BLOCK_SIZE]; + byte ks[WC_AES_BLOCK_SIZE]; + + fromLeft = min(aes->left, sz); + blocks = (sz - fromLeft) / WC_AES_BLOCK_SIZE; + rem = (sz - fromLeft) % WC_AES_BLOCK_SIZE; + XMEMCPY(ctr, aes->reg, WC_AES_BLOCK_SIZE); + XMEMSET(zeros, 0, sizeof(zeros)); + XMEMSET(ks, 0, sizeof(ks)); /* Check operation is supported. */ - ret = Pkcs11MechAvail(session, CKM_AES_CTR, &mechInfo); - if (ret == 0 && (mechInfo.flags & CKF_ENCRYPT) == 0) { - ret = NOT_COMPILED_IN; + if (sz > fromLeft) { + ret = Pkcs11MechAvail(session, CKM_AES_CTR, &mechInfo); + if (ret == 0 && (mechInfo.flags & CKF_ENCRYPT) == 0) { + ret = NOT_COMPILED_IN; + } } - if (ret == 0) { + if (ret == 0 && sz > fromLeft) { WOLFSSL_MSG("PKCS#11: AES-CTR Encryption Operation"); /* Create a private key object or find by id. */ @@ -6341,35 +6423,43 @@ static int Pkcs11AesCtrEncrypt(Pkcs11Session* session, wc_CryptoInfo* info) } if (ret == 0) { - XMEMSET(¶ms, 0, sizeof(params)); - params.ulCounterBits = WC_AES_BLOCK_SIZE * 8; - XMEMCPY(params.cb, info->cipher.aesctr.aes->reg, WC_AES_BLOCK_SIZE); - - mech.mechanism = CKM_AES_CTR; - mech.ulParameterLen = sizeof(params); - mech.pParameter = ¶ms; + xorbufout(out, in, (byte*)aes->tmp + WC_AES_BLOCK_SIZE - aes->left, + fromLeft); + if (blocks > 0) { + ret = Pkcs11AesCtrOp(session, key, ctr, in + fromLeft, + out + fromLeft, blocks * WC_AES_BLOCK_SIZE); + if (ret == 0) { + Pkcs11AesCtrAdd(ctr, blocks); + } + } + /* Encrypting zeros gives the keystream block for the partial tail. */ + if (ret == 0 && rem > 0) { + ret = Pkcs11AesCtrOp(session, key, ctr, zeros, ks, + WC_AES_BLOCK_SIZE); + if (ret == 0) { + xorbufout(out + sz - rem, in + sz - rem, ks, rem); + Pkcs11AesCtrAdd(ctr, 1); + } + } - rv = session->func->C_EncryptInit(session->handle, &mech, key); - PKCS11_RV("C_EncryptInit", rv); - if (rv != CKR_OK) { - ret = WC_HW_E; + if (ret == 0) { + XMEMCPY(aes->reg, ctr, WC_AES_BLOCK_SIZE); + if (rem > 0) { + XMEMCPY(aes->tmp, ks, WC_AES_BLOCK_SIZE); + aes->left = WC_AES_BLOCK_SIZE - rem; + } + else { + aes->left -= fromLeft; + } } - } - if (ret == 0) { - outLen = info->cipher.aesctr.sz; - rv = session->func->C_Encrypt(session->handle, - (CK_BYTE_PTR)info->cipher.aesctr.in, - info->cipher.aesctr.sz, - info->cipher.aesctr.out, - &outLen); - PKCS11_RV("C_Encrypt", rv); - if (rv != CKR_OK) { - ret = WC_HW_E; + else { + ForceZero(out, sz); } } if (aes->idLen == 0 && aes->labelLen == 0 && key != NULL_PTR) session->func->C_DestroyObject(session->handle, key); + ForceZero(ks, sizeof(ks)); return ret; }