diff --git a/src/ssl.c b/src/ssl.c index 6dd0b4c1685..f370ffdb4fd 100644 --- a/src/ssl.c +++ b/src/ssl.c @@ -10829,7 +10829,7 @@ void wolfSSL_BUF_MEM_free(WOLFSSL_BUF_MEM* buf) case WC_AES_192_CCM_TYPE : case WC_AES_256_CCM_TYPE : WOLFSSL_MSG("AES CCM"); - XMEMCPY(ctx->iv, &ctx->cipher.aes.reg, ctx->ivSz); + /* CCM encrypt/decrypt takes ctx->iv directly. */ break; #endif /* HAVE_AESCCM */ #ifdef HAVE_AES_ECB diff --git a/tests/api/test_evp_cipher.c b/tests/api/test_evp_cipher.c index bfc84542367..d4cb8c3dcc3 100644 --- a/tests/api/test_evp_cipher.c +++ b/tests/api/test_evp_cipher.c @@ -1799,6 +1799,379 @@ int test_wolfSSL_EVP_aes_128_ccm(void) return EXPECT_RESULT(); } +int test_evp_cipher_aes_ccm_message_iv(void) +{ + EXPECT_DECLS; +#if defined(OPENSSL_EXTRA) && defined(HAVE_AESCCM) && \ + defined(WOLFSSL_AES_128) && !defined(HAVE_FIPS) && \ + !defined(HAVE_SELFTEST) + EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new(); + EVP_CIPHER_CTX* decryptCtx = EVP_CIPHER_CTX_new(); + byte key[AES_128_KEY_SIZE] = {0}; + byte iv[GCM_NONCE_MID_SZ] = {1}; + byte cycleIv[GCM_NONCE_MID_SZ] = {3}; + byte input[4] = {1, 2, 3, 4}; + byte output[sizeof(input)] = {0}; + byte firstOutput[sizeof(input)] = {0}; + byte tag[WC_AES_BLOCK_SIZE] = {0}; +#if defined(HAVE_AESGCM) && !defined(_WIN32) && !defined(WC_NO_RNG) + byte generated[GCM_NONCE_MID_SZ] = {0}; + byte firstGenerated[GCM_NONCE_MID_SZ] = {0}; +#endif + int len = 0; + + ExpectNotNull(ctx); + ExpectNotNull(decryptCtx); + if (ctx != NULL && decryptCtx != NULL) { + ExpectIntEQ(EVP_EncryptInit_ex(ctx, EVP_aes_128_ccm(), NULL, + key, iv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptUpdate(ctx, output, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(ctx, output, &len), + WOLFSSL_SUCCESS); + XMEMCPY(firstOutput, output, sizeof(firstOutput)); + + ExpectIntEQ(EVP_EncryptInit_ex(decryptCtx, EVP_aes_128_ccm(), NULL, + key, cycleIv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(decryptCtx, output, &len), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(decryptCtx, EVP_CTRL_CCM_GET_TAG, + sizeof(tag), tag), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_DecryptInit_ex(decryptCtx, NULL, NULL, + key, cycleIv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(decryptCtx, EVP_CTRL_CCM_SET_TAG, + sizeof(tag), tag), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_DecryptFinal_ex(decryptCtx, output, &len), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptInit_ex(decryptCtx, NULL, NULL, NULL, NULL), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptUpdate(decryptCtx, output, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(decryptCtx, output, &len), + WOLFSSL_FAILURE); + + ExpectIntEQ(EVP_EncryptUpdate(ctx, output, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(ctx, output, &len), + WOLFSSL_FAILURE); + + iv[0]++; + ExpectIntEQ(EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptUpdate(ctx, output, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(ctx, output, &len), + WOLFSSL_SUCCESS); + ExpectBufNE(output, firstOutput, sizeof(output)); + + iv[0]++; + ExpectIntEQ(EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_Cipher(ctx, output, input, sizeof(input)), + (int)sizeof(input)); + ExpectIntLT(EVP_Cipher(ctx, output, input, sizeof(input)), 0); + +#if defined(HAVE_AESGCM) && !defined(_WIN32) && !defined(WC_NO_RNG) + iv[0]++; + ExpectIntEQ(EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IV_FIXED, + -1, iv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_IV_GEN, + sizeof(generated), generated), + WOLFSSL_SUCCESS); + XMEMCPY(firstGenerated, generated, sizeof(generated)); + ExpectIntEQ(EVP_EncryptUpdate(ctx, output, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(ctx, output, &len), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_IV_GEN, + sizeof(generated), generated), + WOLFSSL_SUCCESS); + ExpectBufNE(generated, firstGenerated, sizeof(generated)); + ExpectIntEQ(EVP_EncryptUpdate(ctx, output, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(ctx, output, &len), + WOLFSSL_SUCCESS); + + iv[0]++; + ExpectIntEQ(EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IV_FIXED, + -1, iv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_IV_GEN, + sizeof(generated), generated), + WOLFSSL_SUCCESS); + XMEMCPY(firstGenerated, generated, sizeof(generated)); + ExpectIntEQ(EVP_Cipher(ctx, output, input, sizeof(input)), + (int)sizeof(input)); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_IV_GEN, + sizeof(generated), generated), + WOLFSSL_SUCCESS); + ExpectBufNE(generated, firstGenerated, sizeof(generated)); + ExpectIntEQ(EVP_Cipher(ctx, output, input, sizeof(input)), + (int)sizeof(input)); +#endif + + } + EVP_CIPHER_CTX_free(decryptCtx); + EVP_CIPHER_CTX_free(ctx); +#endif + return EXPECT_RESULT(); +} + +int test_evp_cipher_aes_ccm_iv_lifecycle(void) +{ + EXPECT_DECLS; +#if defined(OPENSSL_EXTRA) && defined(HAVE_AESCCM) && \ + defined(WOLFSSL_AES_128) && !defined(HAVE_FIPS) && \ + !defined(HAVE_SELFTEST) + EVP_CIPHER_CTX* enc = EVP_CIPHER_CTX_new(); + EVP_CIPHER_CTX* dec = EVP_CIPHER_CTX_new(); + EVP_CIPHER_CTX* fresh = EVP_CIPHER_CTX_new(); + byte key[AES_128_KEY_SIZE] = {0}; + byte iv[GCM_NONCE_MID_SZ] = {5}; + byte input[4] = {1, 2, 3, 4}; + byte ct[sizeof(input)] = {0}; + byte pt[sizeof(input)] = {0}; + byte tag[WC_AES_BLOCK_SIZE] = {0}; +#if (defined(HAVE_AESGCM) || defined(WOLFSSL_SM4_GCM)) && \ + !defined(_WIN32) && !defined(WC_NO_RNG) + byte encIv[GCM_NONCE_MID_SZ] = {0}; + byte decIv[GCM_NONCE_MID_SZ] = {0}; + byte seqIv[GCM_NONCE_MID_SZ] = {0xA1, 0xA2, 0xA3, 0xA4}; + byte expIv[GCM_NONCE_MID_SZ] = {0xA1, 0xA2, 0xA3, 0xA4, 0x01}; + byte aad[3] = {7, 8, 9}; + byte refTag[WC_AES_BLOCK_SIZE] = {0}; + int i; +#endif + int len = 0; + + ExpectNotNull(enc); + ExpectNotNull(dec); + ExpectNotNull(fresh); + if (enc != NULL && dec != NULL && fresh != NULL) { + /* A key-only init on a new context must not encrypt under ctx->iv. */ + ExpectIntEQ(EVP_EncryptInit_ex(fresh, EVP_aes_128_ccm(), NULL, + key, NULL), WOLFSSL_SUCCESS); + ExpectIntLT(EVP_Cipher(fresh, ct, input, sizeof(input)), 0); + ExpectIntEQ(EVP_EncryptUpdate(fresh, ct, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(fresh, ct, &len), WOLFSSL_FAILURE); + + /* Reset keeps ctx->iv, so a key-only re-init must stay blocked. */ + ExpectIntEQ(EVP_EncryptInit_ex(enc, EVP_aes_128_ccm(), NULL, + key, iv), WOLFSSL_SUCCESS); +#if INT_MAX == 0x7FFFFFFF + ExpectIntLT(EVP_Cipher(enc, ct, input, (word32)INT_MAX + 1U), 0); +#endif + ExpectIntEQ(EVP_Cipher(enc, ct, input, sizeof(input)), + (int)sizeof(input)); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_CCM_GET_TAG, + sizeof(tag), tag), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_reset(enc), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptInit_ex(enc, EVP_aes_128_ccm(), NULL, + key, NULL), WOLFSSL_SUCCESS); + ExpectIntLT(EVP_Cipher(enc, pt, input, sizeof(input)), 0); + + /* One-shot decrypt consumes the IV for a later encrypt. */ + ExpectIntEQ(EVP_DecryptInit_ex(dec, EVP_aes_128_ccm(), NULL, + key, iv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(dec, EVP_CTRL_CCM_SET_TAG, + sizeof(tag), tag), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_Cipher(dec, pt, ct, sizeof(ct)), (int)sizeof(ct)); + ExpectBufEQ(pt, input, sizeof(input)); + ExpectIntEQ(EVP_EncryptInit_ex(dec, NULL, NULL, NULL, NULL), + WOLFSSL_SUCCESS); + ExpectIntLT(EVP_Cipher(dec, ct, input, sizeof(input)), 0); + +#if (defined(HAVE_AESGCM) || defined(WOLFSSL_SM4_GCM)) && \ + !defined(_WIN32) && !defined(WC_NO_RNG) + /* A fixed prefix after an explicit-IV message yields a fresh IV. */ + iv[0]++; + ExpectIntEQ(EVP_EncryptInit_ex(enc, NULL, NULL, NULL, iv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptUpdate(enc, ct, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(enc, ct, &len), WOLFSSL_SUCCESS); + /* A rejected message's AAD must not leak into the next one. */ + ExpectIntEQ(EVP_EncryptUpdate(enc, NULL, &len, aad, sizeof(aad)), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptUpdate(enc, ct, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(enc, ct, &len), WOLFSSL_FAILURE); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_GCM_SET_IV_FIXED, + 4, iv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_GCM_IV_GEN, + sizeof(encIv), encIv), + WOLFSSL_SUCCESS); + ExpectBufEQ(encIv, iv, 4); + ExpectIntEQ(EVP_EncryptUpdate(enc, ct, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(enc, ct, &len), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_CCM_GET_TAG, + sizeof(tag), tag), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptInit_ex(fresh, EVP_aes_128_ccm(), NULL, + key, encIv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptUpdate(fresh, pt, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(fresh, pt, &len), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(fresh, EVP_CTRL_CCM_GET_TAG, + sizeof(refTag), refTag), WOLFSSL_SUCCESS); + ExpectBufEQ(tag, refTag, sizeof(tag)); + ExpectBufEQ(ct, pt, sizeof(ct)); + + /* Same for AAD queued ahead of a rejected one-shot encrypt. */ + ExpectIntEQ(EVP_Cipher(enc, ct, input, sizeof(input)), + (int)sizeof(input)); + ExpectIntEQ(EVP_Cipher(enc, NULL, aad, sizeof(aad)), (int)sizeof(aad)); + ExpectIntLT(EVP_Cipher(enc, ct, input, sizeof(input)), 0); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_GCM_SET_IV_FIXED, + 4, iv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_GCM_IV_GEN, + sizeof(encIv), encIv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_Cipher(enc, ct, input, sizeof(input)), + (int)sizeof(input)); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_CCM_GET_TAG, + sizeof(tag), tag), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptInit_ex(fresh, NULL, NULL, NULL, encIv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_Cipher(fresh, pt, input, sizeof(input)), + (int)sizeof(input)); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(fresh, EVP_CTRL_CCM_GET_TAG, + sizeof(refTag), refTag), WOLFSSL_SUCCESS); + ExpectBufEQ(tag, refTag, sizeof(tag)); + ExpectBufEQ(ct, pt, sizeof(ct)); + + /* Both sides step through the same generated IVs. */ + iv[0]++; + ExpectIntEQ(EVP_EncryptInit_ex(enc, NULL, NULL, NULL, iv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_GCM_SET_IV_FIXED, + -1, iv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_DecryptInit_ex(dec, NULL, NULL, NULL, iv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(dec, EVP_CTRL_GCM_SET_IV_FIXED, + -1, iv), WOLFSSL_SUCCESS); + for (i = 0; i < 2; i++) { + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_GCM_IV_GEN, + sizeof(encIv), encIv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(dec, EVP_CTRL_GCM_IV_GEN, + sizeof(decIv), decIv), + WOLFSSL_SUCCESS); + ExpectBufEQ(decIv, encIv, sizeof(encIv)); + ExpectIntEQ(EVP_EncryptUpdate(enc, ct, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(enc, ct, &len), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_CCM_GET_TAG, + sizeof(tag), tag), WOLFSSL_SUCCESS); + XMEMSET(pt, 0, sizeof(pt)); + ExpectIntEQ(EVP_DecryptUpdate(dec, pt, &len, ct, sizeof(ct)), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(dec, EVP_CTRL_CCM_SET_TAG, + sizeof(tag), tag), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_DecryptFinal_ex(dec, pt, &len), WOLFSSL_SUCCESS); + ExpectBufEQ(pt, input, sizeof(input)); + } + + /* A carry stays inside the invocation field. */ + XMEMSET(seqIv + 5, 0xff, sizeof(seqIv) - 5); + ExpectIntEQ(EVP_EncryptInit_ex(enc, NULL, NULL, NULL, seqIv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_GCM_SET_IV_FIXED, + -1, seqIv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_GCM_IV_GEN, + sizeof(encIv), encIv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_Cipher(enc, ct, input, sizeof(input)), + (int)sizeof(input)); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_GCM_IV_GEN, + sizeof(encIv), encIv), + WOLFSSL_SUCCESS); + ExpectBufEQ(encIv, expIv, sizeof(expIv)); + + /* Wrapping the invocation field exhausts the IV sequence. */ + XMEMSET(seqIv + 4, 0xff, sizeof(seqIv) - 4); + ExpectIntEQ(EVP_EncryptInit_ex(enc, NULL, NULL, NULL, seqIv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_GCM_SET_IV_FIXED, + -1, seqIv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_GCM_IV_GEN, + sizeof(encIv), encIv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_Cipher(enc, ct, input, sizeof(input)), + (int)sizeof(input)); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_GCM_IV_GEN, + sizeof(encIv), encIv), + WOLFSSL_FAILURE); + ExpectIntLT(EVP_Cipher(enc, ct, input, sizeof(input)), 0); + ExpectIntEQ(EVP_EncryptInit_ex(enc, NULL, NULL, NULL, seqIv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_GCM_SET_IV_FIXED, + -1, seqIv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_GCM_IV_GEN, + sizeof(encIv), encIv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptUpdate(enc, ct, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(enc, ct, &len), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_GCM_IV_GEN, + sizeof(encIv), encIv), + WOLFSSL_FAILURE); + ExpectIntEQ(EVP_EncryptUpdate(enc, ct, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(enc, ct, &len), WOLFSSL_FAILURE); + + /* Replacing a generated IV disarms its pending increment. */ + iv[0]++; + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_GCM_SET_IV_FIXED, + -1, iv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_GCM_IV_GEN, + sizeof(encIv), encIv), + WOLFSSL_SUCCESS); + iv[0]++; + ExpectIntEQ(EVP_EncryptInit_ex(enc, NULL, NULL, NULL, iv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_Cipher(enc, ct, input, sizeof(input)), + (int)sizeof(input)); + ExpectIntLT(EVP_Cipher(enc, ct, input, sizeof(input)), 0); + + /* AAD from one generated-IV record does not reach the next. */ + iv[0]++; + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_GCM_SET_IV_FIXED, + -1, iv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_GCM_IV_GEN, + sizeof(encIv), encIv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_Cipher(enc, NULL, aad, sizeof(aad)), + (int)sizeof(aad)); + ExpectIntEQ(EVP_Cipher(enc, ct, input, sizeof(input)), + (int)sizeof(input)); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_GCM_IV_GEN, + sizeof(encIv), encIv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_Cipher(enc, ct, input, sizeof(input)), + (int)sizeof(input)); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(enc, EVP_CTRL_CCM_GET_TAG, + sizeof(tag), tag), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptInit_ex(fresh, NULL, NULL, NULL, encIv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_Cipher(fresh, pt, input, sizeof(input)), + (int)sizeof(input)); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(fresh, EVP_CTRL_CCM_GET_TAG, + sizeof(refTag), refTag), WOLFSSL_SUCCESS); + ExpectBufEQ(tag, refTag, sizeof(tag)); +#endif + } + EVP_CIPHER_CTX_free(fresh); + EVP_CIPHER_CTX_free(dec); + EVP_CIPHER_CTX_free(enc); +#endif + return EXPECT_RESULT(); +} + int test_wolfssl_EVP_aes_ccm(void) { EXPECT_DECLS; @@ -2615,6 +2988,124 @@ int test_wolfssl_EVP_sm4_ctr(void) return res; } +int test_evp_cipher_sm4_gcm_message_iv(void) +{ + EXPECT_DECLS; +#if defined(OPENSSL_EXTRA) && defined(WOLFSSL_SM4_GCM) + EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new(); + EVP_CIPHER_CTX* decryptCtx = EVP_CIPHER_CTX_new(); + byte key[SM4_KEY_SIZE] = {0}; + byte iv[GCM_NONCE_MID_SZ] = {1}; + byte cycleIv[GCM_NONCE_MID_SZ] = {3}; + byte input[4] = {1, 2, 3, 4}; + byte output[sizeof(input)] = {0}; + byte tag[SM4_BLOCK_SIZE] = {0}; +#if !defined(_WIN32) && !defined(HAVE_SELFTEST) && \ + (!defined(HAVE_FIPS) || FIPS_VERSION_GE(2,0)) && !defined(WC_NO_RNG) + byte generated[GCM_NONCE_MID_SZ] = {0}; + byte firstGenerated[GCM_NONCE_MID_SZ] = {0}; +#endif + int len = 0; + + ExpectNotNull(ctx); + ExpectNotNull(decryptCtx); + if (ctx != NULL && decryptCtx != NULL) { + ExpectIntEQ(EVP_EncryptInit_ex(ctx, EVP_sm4_gcm(), NULL, + key, iv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptUpdate(ctx, output, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(ctx, output, &len), + WOLFSSL_SUCCESS); + + ExpectIntEQ(EVP_EncryptInit_ex(decryptCtx, EVP_sm4_gcm(), NULL, + key, cycleIv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(decryptCtx, output, &len), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(decryptCtx, EVP_CTRL_GCM_GET_TAG, + sizeof(tag), tag), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_DecryptInit_ex(decryptCtx, NULL, NULL, + key, cycleIv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(decryptCtx, EVP_CTRL_GCM_SET_TAG, + sizeof(tag), tag), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_DecryptFinal_ex(decryptCtx, output, &len), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptInit_ex(decryptCtx, NULL, NULL, NULL, NULL), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptUpdate(decryptCtx, output, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(decryptCtx, output, &len), + WOLFSSL_FAILURE); + + ExpectIntEQ(EVP_EncryptUpdate(ctx, output, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(ctx, output, &len), + WOLFSSL_FAILURE); + + iv[0]++; + ExpectIntEQ(EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptUpdate(ctx, output, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(ctx, output, &len), + WOLFSSL_SUCCESS); + + iv[0]++; + ExpectIntEQ(EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_Cipher(ctx, output, input, sizeof(input)), + (int)sizeof(input)); + ExpectBufNE(output, input, sizeof(input)); + ExpectIntLT(EVP_Cipher(ctx, output, input, sizeof(input)), 0); + +#if !defined(_WIN32) && !defined(HAVE_SELFTEST) && \ + (!defined(HAVE_FIPS) || FIPS_VERSION_GE(2,0)) && !defined(WC_NO_RNG) + iv[0]++; + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IV_FIXED, + 4, iv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_IV_GEN, + sizeof(generated), generated), + WOLFSSL_SUCCESS); + ExpectBufEQ(generated, iv, 4); + XMEMCPY(firstGenerated, generated, sizeof(generated)); + ExpectIntEQ(EVP_EncryptUpdate(ctx, output, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(ctx, output, &len), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_IV_GEN, + sizeof(generated), generated), + WOLFSSL_SUCCESS); + ExpectBufNE(generated, firstGenerated, sizeof(generated)); + ExpectIntEQ(EVP_EncryptUpdate(ctx, output, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(ctx, output, &len), + WOLFSSL_SUCCESS); + + iv[0]++; + ExpectIntEQ(EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IV_FIXED, + -1, iv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_IV_GEN, + sizeof(generated), generated), + WOLFSSL_SUCCESS); + XMEMCPY(firstGenerated, generated, sizeof(generated)); + ExpectIntEQ(EVP_Cipher(ctx, output, input, sizeof(input)), + (int)sizeof(input)); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_IV_GEN, + sizeof(generated), generated), + WOLFSSL_SUCCESS); + ExpectBufNE(generated, firstGenerated, sizeof(generated)); + ExpectBufEQ(generated, iv, 4); + ExpectIntEQ(EVP_Cipher(ctx, output, input, sizeof(input)), + (int)sizeof(input)); +#endif + } + EVP_CIPHER_CTX_free(decryptCtx); + EVP_CIPHER_CTX_free(ctx); +#endif + return EXPECT_RESULT(); +} + int test_wolfssl_EVP_sm4_gcm_zeroLen(void) { int res = TEST_SKIPPED; @@ -2774,6 +3265,105 @@ int test_wolfssl_EVP_sm4_gcm(void) return res; } +int test_evp_cipher_sm4_ccm_message_iv(void) +{ + EXPECT_DECLS; +#if defined(OPENSSL_EXTRA) && defined(WOLFSSL_SM4_CCM) + EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new(); + EVP_CIPHER_CTX* decryptCtx = EVP_CIPHER_CTX_new(); + byte key[SM4_KEY_SIZE] = {0}; + byte iv[GCM_NONCE_MID_SZ] = {0}; + byte cycleIv[GCM_NONCE_MID_SZ] = {3}; + byte input[4] = {1, 2, 3, 4}; + byte output[sizeof(input)] = {0}; + byte tag[SM4_BLOCK_SIZE] = {0}; +#if (defined(HAVE_AESGCM) || defined(WOLFSSL_SM4_GCM)) && \ + !defined(_WIN32) && !defined(HAVE_SELFTEST) && \ + (!defined(HAVE_FIPS) || FIPS_VERSION_GE(2,0)) + byte generated[GCM_NONCE_MID_SZ] = {0}; +#endif + int len = 0; + + iv[sizeof(iv) - 1] = 1; + ExpectNotNull(ctx); + ExpectNotNull(decryptCtx); + if (ctx != NULL && decryptCtx != NULL) { + ExpectIntEQ(EVP_EncryptInit_ex(ctx, EVP_sm4_ccm(), NULL, + key, iv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptUpdate(ctx, output, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(ctx, output, &len), + WOLFSSL_SUCCESS); + + ExpectIntEQ(EVP_EncryptInit_ex(decryptCtx, EVP_sm4_ccm(), NULL, + key, cycleIv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(decryptCtx, output, &len), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(decryptCtx, EVP_CTRL_CCM_GET_TAG, + sizeof(tag), tag), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_DecryptInit_ex(decryptCtx, NULL, NULL, + key, cycleIv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(decryptCtx, EVP_CTRL_CCM_SET_TAG, + sizeof(tag), tag), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_DecryptFinal_ex(decryptCtx, output, &len), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptInit_ex(decryptCtx, NULL, NULL, NULL, NULL), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptUpdate(decryptCtx, output, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(decryptCtx, output, &len), + WOLFSSL_FAILURE); + + ExpectIntEQ(EVP_EncryptUpdate(ctx, output, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(ctx, output, &len), + WOLFSSL_FAILURE); + ExpectIntEQ(EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, NULL), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptUpdate(ctx, output, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(ctx, output, &len), + WOLFSSL_FAILURE); + + iv[0]++; + ExpectIntEQ(EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptUpdate(ctx, output, &len, input, + sizeof(input)), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_EncryptFinal_ex(ctx, output, &len), + WOLFSSL_SUCCESS); + + iv[0]++; + ExpectIntEQ(EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv), + WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_Cipher(ctx, output, input, sizeof(input)), + (int)sizeof(input)); + ExpectBufNE(output, input, sizeof(input)); + ExpectIntLT(EVP_Cipher(ctx, output, input, sizeof(input)), 0); + ExpectIntEQ(EVP_CIPHER_CTX_reset(ctx), WOLFSSL_SUCCESS); + ExpectIntEQ(ctx->authIvUsed, 1); + iv[0]++; + ExpectIntEQ(EVP_EncryptInit_ex(ctx, EVP_sm4_ccm(), NULL, key, iv), + WOLFSSL_SUCCESS); +#if (defined(HAVE_AESGCM) || defined(WOLFSSL_SM4_GCM)) && \ + !defined(_WIN32) && !defined(HAVE_SELFTEST) && \ + (!defined(HAVE_FIPS) || FIPS_VERSION_GE(2,0)) + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IV_FIXED, + -1, iv), WOLFSSL_SUCCESS); + ExpectIntEQ(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_IV_GEN, + sizeof(generated), generated), + WOLFSSL_FAILURE); +#endif + ExpectIntEQ(EVP_Cipher(ctx, output, input, sizeof(input)), + (int)sizeof(input)); + + } + EVP_CIPHER_CTX_free(decryptCtx); + EVP_CIPHER_CTX_free(ctx); +#endif + return EXPECT_RESULT(); +} + int test_wolfssl_EVP_sm4_ccm_zeroLen(void) { int res = TEST_SKIPPED; diff --git a/tests/api/test_evp_cipher.h b/tests/api/test_evp_cipher.h index 82aaefad125..f74d00a7060 100644 --- a/tests/api/test_evp_cipher.h +++ b/tests/api/test_evp_cipher.h @@ -48,6 +48,8 @@ int test_wolfssl_EVP_aes_gcm_zeroLen(void); int test_wolfSSL_EVP_aes_256_ccm(void); int test_wolfSSL_EVP_aes_192_ccm(void); int test_wolfSSL_EVP_aes_128_ccm(void); +int test_evp_cipher_aes_ccm_message_iv(void); +int test_evp_cipher_aes_ccm_iv_lifecycle(void); int test_wolfssl_EVP_aes_ccm(void); int test_wolfssl_EVP_aes_ccm_zeroLen(void); int test_wolfssl_EVP_chacha20(void); @@ -58,8 +60,10 @@ int test_evp_cipher_aria_gcm_message_iv(void); int test_wolfssl_EVP_sm4_ecb(void); int test_wolfssl_EVP_sm4_cbc(void); int test_wolfssl_EVP_sm4_ctr(void); +int test_evp_cipher_sm4_gcm_message_iv(void); int test_wolfssl_EVP_sm4_gcm_zeroLen(void); int test_wolfssl_EVP_sm4_gcm(void); +int test_evp_cipher_sm4_ccm_message_iv(void); int test_wolfssl_EVP_sm4_ccm_zeroLen(void); int test_wolfssl_EVP_sm4_ccm(void); int test_wolfSSL_EVP_rc4(void); @@ -98,6 +102,8 @@ int test_evp_cipher_update_no_padding_buffered(void); TEST_DECL_GROUP("evp_cipher", test_wolfSSL_EVP_aes_256_ccm), \ TEST_DECL_GROUP("evp_cipher", test_wolfSSL_EVP_aes_192_ccm), \ TEST_DECL_GROUP("evp_cipher", test_wolfSSL_EVP_aes_128_ccm), \ + TEST_DECL_GROUP("evp_cipher", test_evp_cipher_aes_ccm_message_iv), \ + TEST_DECL_GROUP("evp_cipher", test_evp_cipher_aes_ccm_iv_lifecycle), \ TEST_DECL_GROUP("evp_cipher", test_wolfssl_EVP_aes_ccm), \ TEST_DECL_GROUP("evp_cipher", test_wolfssl_EVP_aes_ccm_zeroLen), \ TEST_DECL_GROUP("evp_cipher", test_wolfssl_EVP_chacha20), \ @@ -108,8 +114,10 @@ int test_evp_cipher_update_no_padding_buffered(void); TEST_DECL_GROUP("evp_cipher", test_wolfssl_EVP_sm4_ecb), \ TEST_DECL_GROUP("evp_cipher", test_wolfssl_EVP_sm4_cbc), \ TEST_DECL_GROUP("evp_cipher", test_wolfssl_EVP_sm4_ctr), \ + TEST_DECL_GROUP("evp_cipher", test_evp_cipher_sm4_gcm_message_iv), \ TEST_DECL_GROUP("evp_cipher", test_wolfssl_EVP_sm4_gcm_zeroLen), \ TEST_DECL_GROUP("evp_cipher", test_wolfssl_EVP_sm4_gcm), \ + TEST_DECL_GROUP("evp_cipher", test_evp_cipher_sm4_ccm_message_iv), \ TEST_DECL_GROUP("evp_cipher", test_wolfssl_EVP_sm4_ccm_zeroLen), \ TEST_DECL_GROUP("evp_cipher", test_wolfssl_EVP_sm4_ccm), \ TEST_DECL_GROUP("evp_cipher", test_wolfSSL_EVP_rc4), \ diff --git a/wolfcrypt/src/evp.c b/wolfcrypt/src/evp.c index 8288fa07d87..ac96cbd5050 100644 --- a/wolfcrypt/src/evp.c +++ b/wolfcrypt/src/evp.c @@ -1301,8 +1301,7 @@ static int checkPad(WOLFSSL_EVP_CIPHER_CTX *ctx, unsigned char *buff) return ctMaskSelInt(ctMaskEq(mask, 0), ctx->block_size - n, -1); } -#if (defined(HAVE_AESGCM) || defined(HAVE_AESCCM) || \ - defined(WOLFSSL_SM4_GCM) || defined(WOLFSSL_SM4_CCM)) && \ +#if (defined(HAVE_AESGCM) || defined(HAVE_ARIA)) && \ ((!defined(HAVE_FIPS) && !defined(HAVE_SELFTEST)) || FIPS_VERSION_GE(2,0)) static WC_INLINE void IncCtr(byte* ctr, word32 ctrSz) { @@ -1314,6 +1313,45 @@ static WC_INLINE void IncCtr(byte* ctr, word32 ctrSz) } #endif +#if (defined(HAVE_AESCCM) || defined(WOLFSSL_SM4_GCM)) && \ + ((!defined(HAVE_FIPS) && !defined(HAVE_SELFTEST)) || FIPS_VERSION_GE(2,0)) +#define EVP_AEAD_INVOCATION_SZ 8 + +/* Steps only the invocation field so the fixed prefix never changes. Returns + * 1 when the field wraps and the IV sequence is exhausted. */ +static int EvpAeadIncInvocation(byte* iv, int ivSz) +{ + int i; + int sz = (ivSz > EVP_AEAD_INVOCATION_SZ) ? EVP_AEAD_INVOCATION_SZ : ivSz; + byte* ctr = iv + ivSz - sz; + + for (i = sz - 1; i >= 0; i--) { + if (++ctr[i] != 0) + return 0; + } + return 1; +} +#endif + +#if (defined(HAVE_AESCCM) && ((!defined(HAVE_FIPS) && \ + !defined(HAVE_SELFTEST)) || FIPS_VERSION_GE(2,0))) || \ + defined(WOLFSSL_SM4_GCM) || defined(WOLFSSL_SM4_CCM) +/* Drops a message rejected for a consumed IV so none of it carries over. */ +static void EvpAeadDiscardMessage(WOLFSSL_EVP_CIPHER_CTX* ctx) +{ + if (ctx->authBuffer != NULL) { + ForceZero(ctx->authBuffer, (word32)ctx->authBufferLen); + } + XFREE(ctx->authBuffer, NULL, DYNAMIC_TYPE_OPENSSL); + ctx->authBuffer = NULL; + ctx->authBufferLen = 0; + XFREE(ctx->authIn, NULL, DYNAMIC_TYPE_OPENSSL); + ctx->authIn = NULL; + ctx->authInSz = 0; + ctx->authIncIv = 0; +} +#endif + int wolfSSL_EVP_CipherFinal(WOLFSSL_EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) { @@ -1417,6 +1455,12 @@ int wolfSSL_EVP_CipherFinal(WOLFSSL_EVP_CIPHER_CTX *ctx, unsigned char *out, case WC_AES_128_CCM_TYPE: case WC_AES_192_CCM_TYPE: case WC_AES_256_CCM_TYPE: + if (ctx->enc && ctx->authIvUsed) { + EvpAeadDiscardMessage(ctx); + *outl = 0; + ret = WOLFSSL_FAILURE; + break; + } if ((ctx->authBuffer && ctx->authBufferLen > 0) || (ctx->authBufferLen == 0)) { if (ctx->authBufferLen > 0 && out == NULL) { @@ -1452,18 +1496,19 @@ int wolfSSL_EVP_CipherFinal(WOLFSSL_EVP_CIPHER_CTX *ctx, unsigned char *out, ctx->authBufferLen = 0; if (ctx->authIncIv) { - IncCtr((byte*)ctx->cipher.aes.reg, ctx->cipher.aes.nonceSz); + ctx->authIvUsed = + (EvpAeadIncInvocation(ctx->iv, ctx->ivSz) != 0); ctx->authIncIv = 0; } + else { + ctx->authIvUsed = 1; + } } else { *outl = 0; } if (ret == WOLFSSL_SUCCESS) { - if (ctx->authIncIv) { - ctx->authIncIv = 0; - } - else { + if (ctx->authIvUsed) { /* Clear IV, since IV reuse is not recommended * for AES CCM. */ XMEMSET(ctx->iv, 0, WC_AES_BLOCK_SIZE); @@ -1572,6 +1617,12 @@ int wolfSSL_EVP_CipherFinal(WOLFSSL_EVP_CIPHER_CTX *ctx, unsigned char *out, #endif #ifdef WOLFSSL_SM4_GCM case WC_SM4_GCM_TYPE: + if (ctx->enc && ctx->authIvUsed) { + EvpAeadDiscardMessage(ctx); + *outl = 0; + ret = WOLFSSL_FAILURE; + break; + } if ((ctx->authBuffer && ctx->authBufferLen > 0) || (ctx->authBufferLen == 0)) { if (ctx->enc) @@ -1599,18 +1650,19 @@ int wolfSSL_EVP_CipherFinal(WOLFSSL_EVP_CIPHER_CTX *ctx, unsigned char *out, ctx->authBufferLen = 0; if (ctx->authIncIv) { - IncCtr((byte*)ctx->cipher.sm4.iv, ctx->cipher.sm4.nonceSz); + ctx->authIvUsed = + (EvpAeadIncInvocation(ctx->iv, ctx->ivSz) != 0); ctx->authIncIv = 0; } + else { + ctx->authIvUsed = 1; + } } else { *outl = 0; } if (ret == WOLFSSL_SUCCESS) { - if (ctx->authIncIv) { - ctx->authIncIv = 0; - } - else { + if (ctx->authIvUsed) { /* Clear IV, since IV reuse is not recommended for SM4 GCM. */ XMEMSET(ctx->iv, 0, SM4_BLOCK_SIZE); @@ -1623,6 +1675,12 @@ int wolfSSL_EVP_CipherFinal(WOLFSSL_EVP_CIPHER_CTX *ctx, unsigned char *out, #endif #ifdef WOLFSSL_SM4_CCM case WC_SM4_CCM_TYPE: + if (ctx->enc && ctx->authIvUsed) { + EvpAeadDiscardMessage(ctx); + *outl = 0; + ret = WOLFSSL_FAILURE; + break; + } if ((ctx->authBuffer && ctx->authBufferLen > 0) || (ctx->authBufferLen == 0)) { if (ctx->enc) @@ -1636,6 +1694,8 @@ int wolfSSL_EVP_CipherFinal(WOLFSSL_EVP_CIPHER_CTX *ctx, unsigned char *out, ctx->iv, ctx->ivSz, ctx->authTag, ctx->authTagSz, ctx->authIn, ctx->authInSz); + ctx->authIncIv = 0; + ctx->authIvUsed = 1; if (ret == 0) { ret = WOLFSSL_SUCCESS; *outl = ctx->authBufferLen; @@ -1649,23 +1709,13 @@ int wolfSSL_EVP_CipherFinal(WOLFSSL_EVP_CIPHER_CTX *ctx, unsigned char *out, ctx->authBuffer = NULL; ctx->authBufferLen = 0; - if (ctx->authIncIv) { - IncCtr((byte*)ctx->cipher.sm4.iv, ctx->cipher.sm4.nonceSz); - ctx->authIncIv = 0; - } } else { *outl = 0; } if (ret == WOLFSSL_SUCCESS) { - if (ctx->authIncIv) { - ctx->authIncIv = 0; - } - else { - /* Clear IV, since IV reuse is not recommended - * for SM4 CCM. */ - XMEMSET(ctx->iv, 0, SM4_BLOCK_SIZE); - } + /* Clear IV, since IV reuse is not recommended for SM4 CCM. */ + XMEMSET(ctx->iv, 0, SM4_BLOCK_SIZE); if (wolfSSL_StoreExternalIV(ctx) != WOLFSSL_SUCCESS) { ret = WOLFSSL_FAILURE; } @@ -6825,6 +6875,12 @@ void wolfSSL_EVP_init(void) } if (wc_RNG_GenerateBlock(&rng, ctx->iv + arg, (word32)(ctx->ivSz - arg)) == 0) { + #if defined(HAVE_AESGCM) || defined(HAVE_AESCCM) || \ + defined(HAVE_ARIA) || defined(WOLFSSL_SM4_GCM) || \ + defined(WOLFSSL_SM4_CCM) + ctx->authIvUsed = 0; + ctx->authIncIv = 0; + #endif ret = WOLFSSL_SUCCESS; } else { /* rng is freed immediately after if block so no need @@ -6862,6 +6918,10 @@ void wolfSSL_EVP_init(void) case WOLFSSL_EVP_CTRL_GCM_IV_GEN: if ((ctx->flags & WOLFSSL_EVP_CIPH_FLAG_AEAD_CIPHER) == 0) break; +#ifdef WOLFSSL_SM4_CCM + if (ctx->cipherType == WC_SM4_CCM_TYPE) + break; +#endif if (!ctx->authIvGenEnable) { WOLFSSL_MSG("Must use EVP_CTRL_AEAD_SET_IV_FIXED before " "EVP_CTRL_GCM_IV_GEN"); @@ -6875,6 +6935,19 @@ void wolfSSL_EVP_init(void) WOLFSSL_MSG("Destination buffer for IV bytes NULL."); break; } + if (ctx->authIvUsed && (FALSE + #ifdef HAVE_AESCCM + || ctx->cipherType == WC_AES_128_CCM_TYPE + || ctx->cipherType == WC_AES_192_CCM_TYPE + || ctx->cipherType == WC_AES_256_CCM_TYPE + #endif + #ifdef WOLFSSL_SM4_GCM + || ctx->cipherType == WC_SM4_GCM_TYPE + #endif + )) { + WOLFSSL_MSG("IV already used or sequence exhausted"); + break; + } if (arg <= 0 || arg > ctx->ivSz) { XMEMCPY(ptr, ctx->iv, (size_t)ctx->ivSz); } @@ -7133,6 +7206,7 @@ void wolfSSL_EVP_init(void) ctx->authInSz = 0; ctx->authIvGenEnable = 0; ctx->authIncIv = 0; + ctx->authIvUsed = 1; #endif } @@ -7519,7 +7593,9 @@ void wolfSSL_EVP_init(void) WOLFSSL_MSG("wc_AesCcmSetNonce() failed"); ret = WOLFSSL_FAILURE; } - + if (ret == WOLFSSL_SUCCESS && iv && iv != ctx->iv) { + XMEMCPY(ctx->iv, iv, (size_t)ctx->ivSz); + } /* * OpenSSL clears this flag, which permits subsequent use of * EVP_CTRL_CCM_IV_GEN, when EVP_CipherInit is called with no key. @@ -7543,6 +7619,10 @@ void wolfSSL_EVP_init(void) } else if (src != NULL && dst != NULL) { if (ctx->enc) { + if (ctx->authIvUsed) { + EvpAeadDiscardMessage(ctx); + return WC_NO_ERR_TRACE(BAD_STATE_E); + } ret = wc_AesCcmEncrypt(&ctx->cipher.aes, dst, src, len, ctx->iv, (word32)ctx->ivSz, ctx->authTag, (word32)ctx->authTagSz, ctx->authIn, @@ -7555,10 +7635,14 @@ void wolfSSL_EVP_init(void) (word32)ctx->authInSz); } if (ctx->authIncIv) { - IncCtr((byte*)ctx->cipher.aes.reg, - ctx->cipher.aes.nonceSz); + ctx->authIvUsed = + (EvpAeadIncInvocation(ctx->iv, ctx->ivSz) != 0); ctx->authIncIv = 0; } + else { + ctx->authIvUsed = 1; + } + EvpAeadDiscardMessage(ctx); } if (src == NULL) { /* @@ -7663,7 +7747,9 @@ void wolfSSL_EVP_init(void) const byte* iv, int enc) { int ret = 0; -#ifdef HAVE_ARIA +#if defined(HAVE_ARIA) || (defined(HAVE_AESCCM) && ((!defined(HAVE_FIPS) && \ + !defined(HAVE_SELFTEST)) || FIPS_VERSION_GE(2,0))) || \ + defined(WOLFSSL_SM4_GCM) || defined(WOLFSSL_SM4_CCM) int ivProvided = (iv != NULL); #endif (void)key; @@ -7838,6 +7924,12 @@ void wolfSSL_EVP_init(void) != WOLFSSL_SUCCESS) { return WOLFSSL_FAILURE; } + if (ivProvided) { + ctx->authIvUsed = 0; + ctx->authIncIv = 0; + } + else if (type != NULL) + ctx->authIvUsed = 1; } #endif /* HAVE_AESCCM && ((!HAVE_FIPS && !HAVE_SELFTEST) || * HAVE_FIPS_VERSION >= 2 */ @@ -8662,6 +8754,12 @@ void wolfSSL_EVP_init(void) if (iv != NULL) { XMEMCPY(ctx->iv, iv, (size_t)ctx->ivSz); } + if (ivProvided) { + ctx->authIvUsed = 0; + ctx->authIncIv = 0; + } + else if (type != NULL) + ctx->authIvUsed = 1; } #endif #ifdef WOLFSSL_SM4_CCM @@ -8692,6 +8790,12 @@ void wolfSSL_EVP_init(void) if (iv != NULL) { XMEMCPY(ctx->iv, iv, (size_t)ctx->ivSz); } + if (ivProvided) { + ctx->authIvUsed = 0; + ctx->authIncIv = 0; + } + else if (type != NULL) + ctx->authIvUsed = 1; } #endif #ifndef NO_DES3 @@ -9056,7 +9160,7 @@ void wolfSSL_EVP_init(void) WOLFSSL_ENTER("wolfSSL_EVP_Cipher"); - if (ctx == NULL) { + if (ctx == NULL || len > (word32)INT_MAX) { WOLFSSL_MSG("Bad argument."); return WOLFSSL_FATAL_ERROR; } @@ -9319,6 +9423,10 @@ void wolfSSL_EVP_init(void) } else if (src != NULL && dst != NULL) { if (ctx->enc) { + if (ctx->authIvUsed) { + EvpAeadDiscardMessage(ctx); + return WC_NO_ERR_TRACE(BAD_STATE_E); + } ret = wc_Sm4GcmEncrypt(&ctx->cipher.sm4, dst, src, len, ctx->iv, ctx->ivSz, ctx->authTag, ctx->authTagSz, ctx->authIn, @@ -9331,10 +9439,16 @@ void wolfSSL_EVP_init(void) ctx->authInSz); } if (ctx->authIncIv) { - IncCtr((byte*)ctx->cipher.sm4.iv, - ctx->cipher.sm4.nonceSz); + ctx->authIvUsed = + (EvpAeadIncInvocation(ctx->iv, ctx->ivSz) != 0); ctx->authIncIv = 0; } + else { + ctx->authIvUsed = 1; + } + EvpAeadDiscardMessage(ctx); + if (ret == 0) + ret = (int)len; } break; #endif @@ -9347,6 +9461,10 @@ void wolfSSL_EVP_init(void) } else if (src != NULL && dst != NULL) { if (ctx->enc) { + if (ctx->authIvUsed) { + EvpAeadDiscardMessage(ctx); + return WC_NO_ERR_TRACE(BAD_STATE_E); + } ret = wc_Sm4CcmEncrypt(&ctx->cipher.sm4, dst, src, len, ctx->iv, ctx->ivSz, ctx->authTag, ctx->authTagSz, ctx->authIn, @@ -9358,11 +9476,8 @@ void wolfSSL_EVP_init(void) ctx->authTagSz, ctx->authIn, ctx->authInSz); } - if (ctx->authIncIv) { - IncCtr((byte*)ctx->cipher.sm4.iv, - ctx->cipher.sm4.nonceSz); - ctx->authIncIv = 0; - } + ctx->authIvUsed = 1; + EvpAeadDiscardMessage(ctx); } if (src == NULL) { /*