- Fix async AES CBC IV handling for streaming CBC

- Move new async AES CBC test to wh_test_crypto.c, no longer needs to be
  sequential

Author: bigbrett

src/wh_client_crypto.c

@@ -1134,14 +1134,11 @@ int wh_Client_AesCbcResponse(whClientContext* ctx, Aes* aes, uint8_t* out,
         ret = _getCryptoResponse(dataPtr, WC_CIPHER_AES_CBC, (uint8_t**)&res);
         if (ret == WH_ERROR_OK) {
             uint8_t* res_out = (uint8_t*)(res + 1);
+            uint8_t* res_iv  = res_out + res->sz;
             memcpy(out, res_out, res->sz);
-            /* For encryption, update the IV with the last ciphertext
-             * block for CBC chaining */
-            if (res->sz >= AES_BLOCK_SIZE) {
-                uint32_t last_offset =
-                    ((res->sz / AES_BLOCK_SIZE) - 1) * AES_BLOCK_SIZE;
-                memcpy((uint8_t*)aes->reg, out + last_offset, AES_IV_SIZE);
-            }
+            /* Update the IV from the server response for CBC chaining.
+             * The server provides the updated IV after the output data. */
+            memcpy((uint8_t*)aes->reg, res_iv, AES_IV_SIZE);
             if (out_size != NULL) {
                 *out_size = res->sz;
             }

test/wh_test_clientserver.c

@@ -507,69 +507,6 @@ static int _clientServerSequentialTestConnectCb(void*           context,
                                   connected);
 }
 
-#if !defined(WOLFHSM_CFG_NO_CRYPTO)
-#ifdef HAVE_AES_CBC
-static int _testAesCbcRequestResponse(whClientContext* client,
-                                      whServerContext* server)
-{
-    Aes      aes[1];
-    uint8_t  key[AES_BLOCK_SIZE]       = {0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
-                                          0x11, 0x22, 0x33, 0x44, 0x55, 0x66,
-                                          0x77, 0x88, 0x99, 0x00};
-    uint8_t  iv[AES_BLOCK_SIZE]        = {0};
-    uint8_t  plainIn[AES_BLOCK_SIZE]   = {0x77, 0x6F, 0x6C, 0x66, 0x48, 0x53,
-                                          0x4D, 0x20, 0x41, 0x45, 0x53, 0x20,
-                                          0x74, 0x65, 0x73, 0x74};
-    uint8_t  cipherOut[AES_BLOCK_SIZE] = {0};
-    uint8_t  plainOut[AES_BLOCK_SIZE]  = {0};
-    uint32_t outSize                   = 0;
-    int      rc;
-
-    WH_TEST_PRINT("  Testing AES CBC request/response...\n");
-
-    /* Encrypt */
-    WH_TEST_RETURN_ON_FAIL(wc_AesInit(aes, NULL, INVALID_DEVID));
-    WH_TEST_RETURN_ON_FAIL(
-        wc_AesSetKey(aes, key, sizeof(key), iv, AES_ENCRYPTION));
-
-    WH_TEST_RETURN_ON_FAIL(
-        wh_Client_AesCbcRequest(client, aes, 1, plainIn, sizeof(plainIn)));
-
-    /* Response should not be ready before server processes */
-    rc = wh_Client_AesCbcResponse(client, aes, cipherOut, &outSize);
-    WH_TEST_ASSERT_RETURN(rc == WH_ERROR_NOTREADY);
-
-    /* Server processes the request */
-    WH_TEST_RETURN_ON_FAIL(wh_Server_HandleRequestMessage(server));
-
-    /* Now response should be available */
-    WH_TEST_RETURN_ON_FAIL(
-        wh_Client_AesCbcResponse(client, aes, cipherOut, &outSize));
-    WH_TEST_ASSERT_RETURN(outSize == sizeof(plainIn));
-    /* Ciphertext should differ from plaintext */
-    WH_TEST_ASSERT_RETURN(memcmp(cipherOut, plainIn, sizeof(plainIn)) != 0);
-    wc_AesFree(aes);
-
-    /* Decrypt */
-    WH_TEST_RETURN_ON_FAIL(wc_AesInit(aes, NULL, INVALID_DEVID));
-    WH_TEST_RETURN_ON_FAIL(
-        wc_AesSetKey(aes, key, sizeof(key), iv, AES_DECRYPTION));
-
-    WH_TEST_RETURN_ON_FAIL(
-        wh_Client_AesCbcRequest(client, aes, 0, cipherOut, sizeof(cipherOut)));
-    WH_TEST_RETURN_ON_FAIL(wh_Server_HandleRequestMessage(server));
-    WH_TEST_RETURN_ON_FAIL(
-        wh_Client_AesCbcResponse(client, aes, plainOut, &outSize));
-    WH_TEST_ASSERT_RETURN(outSize == sizeof(cipherOut));
-    /* Decrypted output should match original plaintext */
-    WH_TEST_ASSERT_RETURN(memcmp(plainOut, plainIn, sizeof(plainIn)) == 0);
-    wc_AesFree(aes);
-
-    return WH_ERROR_OK;
-}
-#endif /* HAVE_AES_CBC */
-#endif /* !WOLFHSM_CFG_NO_CRYPTO */
-
 static int _testOutOfBoundsNvmReads(whClientContext* client,
                                     whServerContext* server, whNvmId id)
 {
@@ -1171,11 +1108,6 @@ int whTest_ClientServerSequential(whTestNvmBackendType nvmType)
     WH_TEST_RETURN_ON_FAIL(_testDma(server, client));
 #endif /* WOLFHSM_CFG_DMA */
 
-#if !defined(WOLFHSM_CFG_NO_CRYPTO) && defined(HAVE_AES_CBC)
-    /* Test split AES CBC request/response */
-    WH_TEST_RETURN_ON_FAIL(_testAesCbcRequestResponse(client, server));
-#endif /* !WOLFHSM_CFG_NO_CRYPTO && HAVE_AES_CBC */
-
     /* Check that we are still connected */
     WH_TEST_RETURN_ON_FAIL(wh_Server_GetConnected(server, &server_connected));
     WH_TEST_ASSERT_RETURN(server_connected == WH_COMM_CONNECTED);

test/wh_test_crypto.c

@@ -3641,6 +3641,114 @@ static int whTestCrypto_Aes(whClientContext* ctx, int devId, WC_RNG* rng)
         memset(cipher, 0, sizeof(cipher));
         memset(plainOut, 0, sizeof(plainOut));
     }
+    if (ret == 0) {
+        /* test async AES CBC with incremental steps (streaming IV chaining) */
+        uint32_t outSize = 0;
+        uint32_t halfSize = sizeof(plainIn) / 2;
+
+        WH_TEST_PRINT("AES CBC ASYNC STREAMING test\n");
+        ret = wc_AesInit(aes, NULL, INVALID_DEVID);
+        if (ret != 0) {
+            WH_ERROR_PRINT("Failed to wc_AesInit %d\n", ret);
+        }
+
+        /* Encrypt first half */
+        if (ret == 0) {
+            ret = wc_AesSetKey(aes, key, sizeof(key), iv, AES_ENCRYPTION);
+            if (ret != 0) {
+                WH_ERROR_PRINT("Failed to wc_AesSetKey %d\n", ret);
+            }
+        }
+        if (ret == 0) {
+            ret = wh_Client_AesCbcRequest(ctx, aes, 1, plainIn, halfSize);
+            if (ret != 0) {
+                WH_ERROR_PRINT("Failed to AesCbcRequest enc1 %d\n", ret);
+            }
+        }
+        if (ret == 0) {
+            do {
+                ret = wh_Client_AesCbcResponse(ctx, aes, cipher, &outSize);
+            } while (ret == WH_ERROR_NOTREADY);
+            if (ret != 0) {
+                WH_ERROR_PRINT("Failed to AesCbcResponse enc1 %d\n", ret);
+            }
+        }
+
+        /* Encrypt second half (IV should chain from first half) */
+        if (ret == 0) {
+            ret = wh_Client_AesCbcRequest(ctx, aes, 1,
+                                           plainIn + halfSize, halfSize);
+            if (ret != 0) {
+                WH_ERROR_PRINT("Failed to AesCbcRequest enc2 %d\n", ret);
+            }
+        }
+        if (ret == 0) {
+            do {
+                ret = wh_Client_AesCbcResponse(ctx, aes,
+                                                cipher + halfSize, &outSize);
+            } while (ret == WH_ERROR_NOTREADY);
+            if (ret != 0) {
+                WH_ERROR_PRINT("Failed to AesCbcResponse enc2 %d\n", ret);
+            }
+        }
+
+        /* Decrypt first half */
+        if (ret == 0) {
+            ret = wc_AesSetKey(aes, key, sizeof(key), iv, AES_DECRYPTION);
+            if (ret != 0) {
+                WH_ERROR_PRINT("Failed to wc_AesSetKey dec %d\n", ret);
+            }
+        }
+        if (ret == 0) {
+            ret = wh_Client_AesCbcRequest(ctx, aes, 0, cipher, halfSize);
+            if (ret != 0) {
+                WH_ERROR_PRINT("Failed to AesCbcRequest dec1 %d\n", ret);
+            }
+        }
+        if (ret == 0) {
+            do {
+                ret = wh_Client_AesCbcResponse(ctx, aes, plainOut, &outSize);
+            } while (ret == WH_ERROR_NOTREADY);
+            if (ret != 0) {
+                WH_ERROR_PRINT("Failed to AesCbcResponse dec1 %d\n", ret);
+            }
+        }
+
+        /* Decrypt second half (IV should chain from first half) */
+        if (ret == 0) {
+            ret = wh_Client_AesCbcRequest(ctx, aes, 0,
+                                           cipher + halfSize, halfSize);
+            if (ret != 0) {
+                WH_ERROR_PRINT("Failed to AesCbcRequest dec2 %d\n", ret);
+            }
+        }
+        if (ret == 0) {
+            do {
+                ret = wh_Client_AesCbcResponse(ctx, aes,
+                                                plainOut + halfSize, &outSize);
+            } while (ret == WH_ERROR_NOTREADY);
+            if (ret != 0) {
+                WH_ERROR_PRINT("Failed to AesCbcResponse dec2 %d\n", ret);
+            }
+        }
+
+        /* Verify round-trip */
+        if (ret == 0) {
+            if (memcmp(plainIn, plainOut, sizeof(plainIn)) != 0) {
+                WH_ERROR_PRINT("Failed to match async AES-CBC streaming\n");
+                ret = -1;
+            }
+        }
+
+        (void)wc_AesFree(aes);
+        memset(cipher, 0, sizeof(cipher));
+        memset(plainOut, 0, sizeof(plainOut));
+
+        if (ret == 0) {
+            WH_TEST_PRINT("AES CBC ASYNC STREAMING DEVID=0x%X SUCCESS\n",
+                           devId);
+        }
+    }
 #endif /* HAVE_AES_CBC */
 
 #ifdef HAVE_AESGCM