diff --git a/include/sec_security.h b/include/sec_security.h index 63485dc..a9948a2 100644 --- a/include/sec_security.h +++ b/include/sec_security.h @@ -979,6 +979,10 @@ Sec_Result SecCipher_ProcessOpaqueWithMap(Sec_CipherHandle* cipherHandle, SEC_BY SEC_SIZE inputSize, SEC_BOOL lastInput, SEC_MAP* map, SEC_SIZE mapLength, Sec_OpaqueBufferHandle** opaqueBufferHandle, SEC_SIZE* bytesWritten); +Sec_Result SecCipher_ProcessOpaqueWithMapAndPattern(Sec_CipherHandle* cipherHandle, SEC_BYTE* iv, SEC_BYTE* input, + SEC_SIZE inputSize, SEC_BOOL lastInput, SEC_MAP* map, SEC_SIZE mapLength, SEC_SIZE numEncryptedBlocks, + SEC_SIZE numClearBlocks, Sec_OpaqueBufferHandle** opaqueBufferHandle, SEC_SIZE* bytesWritten); + #ifdef __cplusplus } #endif diff --git a/src/sec_adapter_cipher.c b/src/sec_adapter_cipher.c index cd9ebdf..380cc10 100644 --- a/src/sec_adapter_cipher.c +++ b/src/sec_adapter_cipher.c @@ -941,6 +941,12 @@ Sec_Result SecCipher_ProcessOpaqueWithMap(Sec_CipherHandle* cipherHandle, SEC_BY return SEC_RESULT_FAILURE; } + if (cipherHandle->algorithm != SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING && + cipherHandle->algorithm != SEC_CIPHERALGORITHM_AES_CTR) { + SEC_LOG_ERROR("Not CBC or CTR mode"); + return SEC_RESULT_INVALID_PARAMETERS; + } + Sec_Result result = SecOpaqueBuffer_Malloc(inputSize, opaqueBufferHandle); if (result != SEC_RESULT_SUCCESS) { SEC_LOG_ERROR("SecOpaqueBuffer_Malloc failed"); @@ -995,6 +1001,100 @@ Sec_Result SecCipher_ProcessOpaqueWithMap(Sec_CipherHandle* cipherHandle, SEC_BY return SEC_RESULT_SUCCESS; } +Sec_Result SecCipher_ProcessOpaqueWithMapAndPattern(Sec_CipherHandle* cipherHandle, SEC_BYTE* iv, SEC_BYTE* input, + SEC_SIZE inputSize, SEC_BOOL lastInput, SEC_MAP* map, SEC_SIZE mapLength, SEC_SIZE numEncryptedBlocks, + SEC_SIZE numClearBlocks, Sec_OpaqueBufferHandle** opaqueBufferHandle, SEC_SIZE* bytesWritten) { + + if (cipherHandle == NULL) { + SEC_LOG_ERROR("NULL cipherHandle"); + return SEC_RESULT_FAILURE; + } + + if (iv == NULL) { + SEC_LOG_ERROR("NULL iv"); + return SEC_RESULT_FAILURE; + } + + if (input == NULL) { + SEC_LOG_ERROR("NULL input"); + return SEC_RESULT_FAILURE; + } + + if (map == NULL) { + SEC_LOG_ERROR("NULL map"); + return SEC_RESULT_FAILURE; + } + + if (opaqueBufferHandle == NULL) { + SEC_LOG_ERROR("NULL outputHandle"); + return SEC_RESULT_FAILURE; + } + + if (bytesWritten == NULL) { + SEC_LOG_ERROR("NULL bytesWritten"); + return SEC_RESULT_FAILURE; + } + + if (cipherHandle->algorithm != SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING && + cipherHandle->algorithm != SEC_CIPHERALGORITHM_AES_CTR) { + SEC_LOG_ERROR("Not CBC or CTR mode"); + return SEC_RESULT_INVALID_PARAMETERS; + } + + Sec_Result result = SecOpaqueBuffer_Malloc(inputSize, opaqueBufferHandle); + if (result != SEC_RESULT_SUCCESS) { + SEC_LOG_ERROR("SecOpaqueBuffer_Malloc failed"); + return SEC_RESULT_FAILURE; + } + + sa_subsample_length* subsample_lengths = malloc(mapLength * sizeof(sa_subsample_length)); + for (size_t i = 0; i < mapLength; i++) { + subsample_lengths[i].bytes_of_clear_data = map[i].clear; + subsample_lengths[i].bytes_of_protected_data = map[i].encrypted; + } + + sa_buffer out_buffer; + out_buffer.buffer_type = SA_BUFFER_TYPE_SVP; + out_buffer.context.svp.offset = 0; + out_buffer.context.svp.buffer = get_svp_buffer(cipherHandle->processorHandle, *opaqueBufferHandle); + if (out_buffer.context.svp.buffer == INVALID_HANDLE) { + free(subsample_lengths); + SecOpaqueBuffer_Free(*opaqueBufferHandle); + *opaqueBufferHandle = NULL; + *bytesWritten = 0; + return SEC_RESULT_FAILURE; + } + + sa_buffer in_buffer; + in_buffer.buffer_type = SA_BUFFER_TYPE_CLEAR; + in_buffer.context.clear.buffer = input; + in_buffer.context.clear.length = inputSize; + in_buffer.context.clear.offset = 0; + + sa_sample sample; + sample.iv = iv; + sample.iv_length = SEC_AES_BLOCK_SIZE; + sample.crypt_byte_block = numEncryptedBlocks; + sample.skip_byte_block = numClearBlocks; + sample.subsample_count = mapLength; + sample.subsample_lengths = subsample_lengths; + sample.context = cipherHandle->cipher.context; + sample.out = &out_buffer; + sample.in = &in_buffer; + + sa_status status = sa_invoke(cipherHandle->processorHandle, SA_PROCESS_COMMON_ENCRYPTION, (size_t) 1, &sample); + free(subsample_lengths); + if (status != SA_STATUS_OK) { + SecOpaqueBuffer_Free(*opaqueBufferHandle); + *opaqueBufferHandle = NULL; + *bytesWritten = 0; + CHECK_STATUS(status) + } + + *bytesWritten = out_buffer.context.svp.offset; + return SEC_RESULT_SUCCESS; +} + Sec_Result get_cipher_algorithm(const Sec_CipherAlgorithm algorithm, SEC_BOOL is_unwrap, sa_cipher_algorithm* cipher_algorithm, void** parameters, void* iv, SEC_SIZE key_length, SEC_SIZE key_offset) { *parameters = NULL; diff --git a/test/main/cpp/cipher.cpp b/test/main/cpp/cipher.cpp index 4a82d4f..988e0a2 100644 --- a/test/main/cpp/cipher.cpp +++ b/test/main/cpp/cipher.cpp @@ -1239,6 +1239,90 @@ Sec_Result testProcessOpaqueWithMap(SEC_OBJECTID id, TestKey key, TestKc kc, Sec return result; } +Sec_Result testProcessOpaqueWithMapAndPattern(SEC_OBJECTID id, TestKey key, TestKc kc, Sec_StorageLoc loc, + Sec_CipherAlgorithm alg, SEC_SIZE subsampleCount, SEC_SIZE bytesOfClearData, SEC_SIZE numEncryptedBlocks, + SEC_SIZE numClearBlocks) { + TestCtx ctx; + + if (ctx.init() != SEC_RESULT_SUCCESS) { + SEC_LOG_ERROR("TestCtx.init failed"); + return SEC_RESULT_FAILURE; + } + + Sec_KeyHandle* keyHandle = nullptr; + if ((keyHandle = ctx.provisionKey(id, loc, key, kc)) == nullptr) { + SEC_LOG_ERROR("ctx.provisionKey failed"); + return SEC_RESULT_FAILURE; + } + + //gen iv + std::vector iv = TestCtx::random(SEC_AES_BLOCK_SIZE); + TestCtx::printHex("iv", iv); + + //gen clear input + std::vector clear = TestCtx::random(SUBSAMPLE_SIZE * subsampleCount); + TestCtx::printHex("clear", clear); + + //encrypt + std::vector encrypted; + std::vector ivCopy = iv; + + //use openssl to encrypt + std::vector temp; + for (size_t i = 0; i < subsampleCount; i++) { + temp.insert(temp.end(), + clear.begin() + static_cast(i * SUBSAMPLE_SIZE + bytesOfClearData), + clear.begin() + static_cast((i + 1) * SUBSAMPLE_SIZE)); + } + + std::vector encryptedTemp = cipherOpenSSL(key, alg, SEC_CIPHERMODE_ENCRYPT, &ivCopy[0], temp); + SEC_SIZE bytesOfProtectedData = SUBSAMPLE_SIZE - bytesOfClearData; + for (size_t i = 0; i < subsampleCount; i++) { + encrypted.insert(encrypted.end(), + clear.begin() + static_cast(i * SUBSAMPLE_SIZE), + clear.begin() + static_cast(i * SUBSAMPLE_SIZE + bytesOfClearData)); + encrypted.insert(encrypted.end(), + encryptedTemp.begin() + static_cast(i * bytesOfProtectedData), + encryptedTemp.begin() + static_cast((i + 1) * bytesOfProtectedData)); + } + + TestCtx::printHex("encrypted", encrypted); + TestCtx::printHex("iv", iv); + + Sec_CipherHandle* cipherHandle = ctx.acquireCipher(alg, SEC_CIPHERMODE_DECRYPT, keyHandle, &iv[0]); + if (cipherHandle == nullptr) { + SEC_LOG_ERROR("TestCtx::acquireCipher failed"); + return SEC_RESULT_FAILURE; + } + + auto* map = new SEC_MAP[subsampleCount]; + if (map == nullptr) { + SEC_LOG_ERROR("malloc failed"); + return SEC_RESULT_FAILURE; + } + + for (SEC_SIZE i = 0; i < subsampleCount; i++) { + map[i].clear = bytesOfClearData; + map[i].encrypted = SUBSAMPLE_SIZE - bytesOfClearData; + } + + //decrypt + std::vector decrypted; + Sec_OpaqueBufferHandle* opaqueBufferHandle; + SEC_SIZE bytesWritten = 0; + Sec_Result result = SecCipher_ProcessOpaqueWithMapAndPattern(cipherHandle, iv.data(), encrypted.data(), encrypted.size(), + SEC_TRUE, map, subsampleCount, numEncryptedBlocks, numClearBlocks, &opaqueBufferHandle, &bytesWritten); + if (result != SEC_RESULT_SUCCESS) { + delete[] map; + SEC_LOG_ERROR("SecCipher_ProcessOpaqueWithMap failed"); + return result; + } + + delete[] map; + SecOpaqueBuffer_Free(opaqueBufferHandle); + return result; +} + Sec_Result testProcessOpaqueWithMapVariable(SEC_OBJECTID id, TestKey key, TestKc kc, Sec_StorageLoc loc, Sec_CipherAlgorithm alg) { TestCtx ctx; diff --git a/test/main/cpp/cipher.h b/test/main/cpp/cipher.h index afc80ff..a3ec19f 100644 --- a/test/main/cpp/cipher.h +++ b/test/main/cpp/cipher.h @@ -78,6 +78,10 @@ Sec_Result testCtrRollover(SEC_OBJECTID id, TestKey key, TestKc kc, Sec_StorageL Sec_Result testProcessOpaqueWithMap(SEC_OBJECTID id, TestKey key, TestKc kc, Sec_StorageLoc loc, Sec_CipherAlgorithm alg, SEC_SIZE subsampleCount, SEC_SIZE bytesOfClearData); +Sec_Result testProcessOpaqueWithMapAndPattern(SEC_OBJECTID id, TestKey key, TestKc kc, Sec_StorageLoc loc, + Sec_CipherAlgorithm alg, SEC_SIZE subsampleCount, SEC_SIZE bytesOfClearData, SEC_SIZE numEncryptedBlocks, + SEC_SIZE numClearBlocks); + Sec_Result testProcessOpaqueWithMapVariable(SEC_OBJECTID id, TestKey key, TestKc kc, Sec_StorageLoc loc, Sec_CipherAlgorithm alg); diff --git a/test/main/cpp/sec_api_utest_main.cpp b/test/main/cpp/sec_api_utest_main.cpp index 5a2d6c1..bdc7f59 100644 --- a/test/main/cpp/sec_api_utest_main.cpp +++ b/test/main/cpp/sec_api_utest_main.cpp @@ -1094,6 +1094,120 @@ void runSVPTests(SuiteCtx* suite) { SEC_CIPHERALGORITHM_AES_CTR)); \ RUN_TEST(suite, testProcessOpaqueWithMapVariable(SEC_OBJECTID_USER_BASE, key, kc, loc, \ SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING)); \ +\ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 1, 0, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 1, 16, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 1, 20, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 1, 256, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 2, 0, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 2, 16, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 2, 20, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 2, 256, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 5, 0, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 5, 16, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 5, 20, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 5, 256, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 10, 0, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 10, 16, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 10, 20, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 10, 256, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 1, 0, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 1, 16, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 1, 256, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 2, 0, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 2, 16, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 2, 256, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 5, 0, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 5, 16, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 5, 256, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 10, 0, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 10, 16, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 10, 256, 1, 9)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 1, 0, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 1, 16, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 1, 20, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 1, 256, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 2, 0, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 2, 16, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 2, 20, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 2, 256, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 5, 0, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 5, 16, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 5, 20, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 5, 256, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 10, 0, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 10, 16, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 10, 20, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CTR, 10, 256, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 1, 0, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 1, 16, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 1, 256, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 2, 0, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 2, 16, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 2, 256, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 5, 0, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 5, 16, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 5, 256, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 10, 0, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 10, 16, 5, 5)); \ + RUN_TEST(suite, testProcessOpaqueWithMapAndPattern(SEC_OBJECTID_USER_BASE, key, kc, loc, \ + SEC_CIPHERALGORITHM_AES_CBC_NO_PADDING, 10, 256, 5, 5)); \ +\ } while (0) void runWrappedTests(SuiteCtx* suite) { // NOLINT