Skip to content

Commit c36beba

Browse files
dgarskedgarske
authored
Merge pull request #10174 from SparkiDev/api_test_cipher_algs_1
API testing additions: cipher tests
2 parents bf492eb + b764aac commit c36beba

8 files changed

Lines changed: 665 additions & 32 deletions

File tree

‎tests/api.c‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -35198,6 +35198,9 @@ TEST_CASE testCases[] = {
3519835198
(!defined(HAVE_FIPS) || FIPS_VERSION_GE(5, 3)) && !defined(HAVE_SELFTEST)
3519935199
TEST_AES_EAX_DECLS,
3520035200
#endif /* WOLFSSL_AES_EAX */
35201+
#if defined(WOLFSSL_AES_SIV) && defined(WOLFSSL_AES_128)
35202+
TEST_AES_SIV_DECLS,
35203+
#endif /* WOLFSSL_AES_SIV && WOLFSSL_AES_128 */
3520135204
TEST_GMAC_DECLS,
3520235205
/* Ascon */
3520335206
TEST_ASCON_DECLS,

‎tests/api/test_aes.c‎

Lines changed: 336 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5218,10 +5218,346 @@ int test_wc_AesEaxDecryptAuth(void)
52185218
return EXPECT_RESULT();
52195219
} /* END test_wc_AesEaxDecryptAuth() */
52205220

5221+
/*
5222+
* Testing AES-EAX streaming (incremental) API:
5223+
* wc_AesEaxInit, wc_AesEaxEncryptUpdate, wc_AesEaxAuthDataUpdate,
5224+
* wc_AesEaxEncryptFinal, wc_AesEaxDecryptUpdate, wc_AesEaxDecryptFinal,
5225+
* wc_AesEaxFree
5226+
*/
5227+
int test_wc_AesEaxStream(void)
5228+
{
5229+
EXPECT_DECLS;
5230+
5231+
#ifdef WOLFSSL_AES_128
5232+
/* Wycheproof AES-EAX 128-bit key vectors */
5233+
5234+
/* Vector 1: empty plaintext - AAD passed via Init */
5235+
const byte key1[] = {0x23, 0x39, 0x52, 0xde, 0xe4, 0xd5, 0xed, 0x5f,
5236+
0x9b, 0x9c, 0x6d, 0x6f, 0xf8, 0x0f, 0xf4, 0x78};
5237+
const byte nonce1[] = {0x62, 0xec, 0x67, 0xf9, 0xc3, 0xa4, 0xa4, 0x07,
5238+
0xfc, 0xb2, 0xa8, 0xc4, 0x90, 0x31, 0xa8, 0xb3};
5239+
const byte aad1[] = {0x6b, 0xfb, 0x91, 0x4f, 0xd0, 0x7e, 0xae, 0x6b};
5240+
const byte tag1[] = {0xe0, 0x37, 0x83, 0x0e, 0x83, 0x89, 0xf2, 0x7b,
5241+
0x02, 0x5a, 0x2d, 0x65, 0x27, 0xe7, 0x9d, 0x01};
5242+
5243+
/* Vector 2: 2-byte plaintext - AAD passed via EncryptUpdate */
5244+
const byte key2[] = {0x91, 0x94, 0x5d, 0x3f, 0x4d, 0xcb, 0xee, 0x0b,
5245+
0xf4, 0x5e, 0xf5, 0x22, 0x55, 0xf0, 0x95, 0xa4};
5246+
const byte nonce2[] = {0xbe, 0xca, 0xf0, 0x43, 0xb0, 0xa2, 0x3d, 0x84,
5247+
0x31, 0x94, 0xba, 0x97, 0x2c, 0x66, 0xde, 0xbd};
5248+
const byte aad2[] = {0xfa, 0x3b, 0xfd, 0x48, 0x06, 0xeb, 0x53, 0xfa};
5249+
const byte pt2[] = {0xf7, 0xfb};
5250+
const byte ct2[] = {0x19, 0xdd};
5251+
const byte tag2[] = {0x5c, 0x4c, 0x93, 0x31, 0x04, 0x9d, 0x0b, 0xda,
5252+
0xb0, 0x27, 0x74, 0x08, 0xf6, 0x79, 0x67, 0xe5};
5253+
5254+
/* Vector 3: 5-byte plaintext - multi-chunk, AAD via AuthDataUpdate */
5255+
const byte key3[] = {0x01, 0xf7, 0x4a, 0xd6, 0x40, 0x77, 0xf2, 0xe7,
5256+
0x04, 0xc0, 0xf6, 0x0a, 0xda, 0x3d, 0xd5, 0x23};
5257+
const byte nonce3[] = {0x70, 0xc3, 0xdb, 0x4f, 0x0d, 0x26, 0x36, 0x84,
5258+
0x00, 0xa1, 0x0e, 0xd0, 0x5d, 0x2b, 0xff, 0x5e};
5259+
const byte aad3[] = {0x23, 0x4a, 0x34, 0x63, 0xc1, 0x26, 0x4a, 0xc6};
5260+
const byte pt3[] = {0x1a, 0x47, 0xcb, 0x49, 0x33};
5261+
const byte ct3[] = {0xd8, 0x51, 0xd5, 0xba, 0xe0};
5262+
const byte tag3[] = {0x3a, 0x59, 0xf2, 0x38, 0xa2, 0x3e, 0x39, 0x19,
5263+
0x9d, 0xc9, 0x26, 0x66, 0x26, 0xc4, 0x0f, 0x80};
5264+
5265+
AesEax eax;
5266+
byte out[16];
5267+
byte tagBuf[WC_AES_BLOCK_SIZE];
5268+
5269+
XMEMSET(&eax, 0, sizeof(eax));
5270+
XMEMSET(out, 0, sizeof(out));
5271+
XMEMSET(tagBuf, 0, sizeof(tagBuf));
5272+
5273+
/* --- Test 1: empty plaintext, AAD passed to Init --- */
5274+
ExpectIntEQ(wc_AesEaxInit(&eax, key1, sizeof(key1),
5275+
nonce1, sizeof(nonce1),
5276+
aad1, sizeof(aad1)), 0);
5277+
ExpectIntEQ(wc_AesEaxEncryptFinal(&eax, tagBuf, sizeof(tag1)), 0);
5278+
ExpectBufEQ(tagBuf, tag1, sizeof(tag1));
5279+
ExpectIntEQ(wc_AesEaxFree(&eax), 0);
5280+
5281+
/* --- Test 1d: empty plaintext decrypt --- */
5282+
ExpectIntEQ(wc_AesEaxInit(&eax, key1, sizeof(key1),
5283+
nonce1, sizeof(nonce1),
5284+
aad1, sizeof(aad1)), 0);
5285+
ExpectIntEQ(wc_AesEaxDecryptFinal(&eax, tag1, sizeof(tag1)), 0);
5286+
ExpectIntEQ(wc_AesEaxFree(&eax), 0);
5287+
5288+
/* --- Test 2: 2-byte plaintext, single EncryptUpdate with inline AAD --- */
5289+
ExpectIntEQ(wc_AesEaxInit(&eax, key2, sizeof(key2),
5290+
nonce2, sizeof(nonce2),
5291+
NULL, 0), 0);
5292+
ExpectIntEQ(wc_AesEaxEncryptUpdate(&eax, out, pt2, sizeof(pt2),
5293+
aad2, sizeof(aad2)), 0);
5294+
ExpectBufEQ(out, ct2, sizeof(ct2));
5295+
ExpectIntEQ(wc_AesEaxEncryptFinal(&eax, tagBuf, sizeof(tag2)), 0);
5296+
ExpectBufEQ(tagBuf, tag2, sizeof(tag2));
5297+
ExpectIntEQ(wc_AesEaxFree(&eax), 0);
5298+
5299+
/* --- Test 2d: 2-byte ciphertext, single DecryptUpdate with inline AAD --- */
5300+
ExpectIntEQ(wc_AesEaxInit(&eax, key2, sizeof(key2),
5301+
nonce2, sizeof(nonce2),
5302+
NULL, 0), 0);
5303+
ExpectIntEQ(wc_AesEaxDecryptUpdate(&eax, out, ct2, sizeof(ct2),
5304+
aad2, sizeof(aad2)), 0);
5305+
ExpectBufEQ(out, pt2, sizeof(pt2));
5306+
ExpectIntEQ(wc_AesEaxDecryptFinal(&eax, tag2, sizeof(tag2)), 0);
5307+
ExpectIntEQ(wc_AesEaxFree(&eax), 0);
5308+
5309+
/* --- Test 3: 5-byte plaintext, multi-chunk encrypt with AuthDataUpdate --- */
5310+
ExpectIntEQ(wc_AesEaxInit(&eax, key3, sizeof(key3),
5311+
nonce3, sizeof(nonce3),
5312+
NULL, 0), 0);
5313+
/* Feed AAD via AuthDataUpdate split into two calls */
5314+
ExpectIntEQ(wc_AesEaxAuthDataUpdate(&eax, aad3, 4), 0);
5315+
ExpectIntEQ(wc_AesEaxAuthDataUpdate(&eax, aad3 + 4, sizeof(aad3) - 4), 0);
5316+
/* Encrypt plaintext in two chunks */
5317+
ExpectIntEQ(wc_AesEaxEncryptUpdate(&eax, out, pt3, 2, NULL, 0), 0);
5318+
ExpectBufEQ(out, ct3, 2);
5319+
ExpectIntEQ(wc_AesEaxEncryptUpdate(&eax, out + 2, pt3 + 2,
5320+
(word32)(sizeof(pt3) - 2), NULL, 0), 0);
5321+
ExpectBufEQ(out + 2, ct3 + 2, sizeof(ct3) - 2);
5322+
ExpectIntEQ(wc_AesEaxEncryptFinal(&eax, tagBuf, sizeof(tag3)), 0);
5323+
ExpectBufEQ(tagBuf, tag3, sizeof(tag3));
5324+
ExpectIntEQ(wc_AesEaxFree(&eax), 0);
5325+
5326+
/* --- Test 3d: 5-byte ciphertext, multi-chunk decrypt with AuthDataUpdate --- */
5327+
ExpectIntEQ(wc_AesEaxInit(&eax, key3, sizeof(key3),
5328+
nonce3, sizeof(nonce3),
5329+
NULL, 0), 0);
5330+
ExpectIntEQ(wc_AesEaxAuthDataUpdate(&eax, aad3, 4), 0);
5331+
ExpectIntEQ(wc_AesEaxAuthDataUpdate(&eax, aad3 + 4, sizeof(aad3) - 4), 0);
5332+
/* Decrypt ciphertext in two chunks */
5333+
ExpectIntEQ(wc_AesEaxDecryptUpdate(&eax, out, ct3, 2, NULL, 0), 0);
5334+
ExpectBufEQ(out, pt3, 2);
5335+
ExpectIntEQ(wc_AesEaxDecryptUpdate(&eax, out + 2, ct3 + 2,
5336+
(word32)(sizeof(ct3) - 2), NULL, 0), 0);
5337+
ExpectBufEQ(out + 2, pt3 + 2, sizeof(pt3) - 2);
5338+
ExpectIntEQ(wc_AesEaxDecryptFinal(&eax, tag3, sizeof(tag3)), 0);
5339+
ExpectIntEQ(wc_AesEaxFree(&eax), 0);
5340+
5341+
/* --- Bad args --- */
5342+
/* wc_AesEaxInit */
5343+
ExpectIntEQ(wc_AesEaxInit(NULL, key1, sizeof(key1),
5344+
nonce1, sizeof(nonce1), NULL, 0),
5345+
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
5346+
ExpectIntEQ(wc_AesEaxInit(&eax, NULL, sizeof(key1),
5347+
nonce1, sizeof(nonce1), NULL, 0),
5348+
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
5349+
ExpectIntEQ(wc_AesEaxInit(&eax, key1, sizeof(key1),
5350+
NULL, sizeof(nonce1), NULL, 0),
5351+
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
5352+
5353+
/* wc_AesEaxAuthDataUpdate */
5354+
ExpectIntEQ(wc_AesEaxAuthDataUpdate(NULL, aad1, sizeof(aad1)),
5355+
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
5356+
5357+
/* wc_AesEaxEncryptFinal */
5358+
ExpectIntEQ(wc_AesEaxEncryptFinal(NULL, tagBuf, WC_AES_BLOCK_SIZE),
5359+
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
5360+
5361+
/* wc_AesEaxDecryptFinal NULL eax */
5362+
ExpectIntEQ(wc_AesEaxDecryptFinal(NULL, tag1, sizeof(tag1)),
5363+
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
5364+
5365+
/* wc_AesEaxDecryptFinal authInSz > WC_AES_BLOCK_SIZE */
5366+
ExpectIntEQ(wc_AesEaxInit(&eax, key1, sizeof(key1),
5367+
nonce1, sizeof(nonce1), NULL, 0), 0);
5368+
ExpectIntEQ(wc_AesEaxDecryptFinal(&eax, tag1, WC_AES_BLOCK_SIZE + 1),
5369+
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
5370+
ExpectIntEQ(wc_AesEaxFree(&eax), 0);
5371+
5372+
/* wc_AesEaxFree NULL */
5373+
ExpectIntEQ(wc_AesEaxFree(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
5374+
5375+
#endif /* WOLFSSL_AES_128 */
5376+
5377+
return EXPECT_RESULT();
5378+
} /* END test_wc_AesEaxStream() */
5379+
52215380
#endif /* WOLFSSL_AES_EAX && WOLFSSL_AES_256
52225381
* (!HAVE_FIPS || FIPS_VERSION_GE(5, 3)) && !HAVE_SELFTEST
52235382
*/
52245383

5384+
/*----------------------------------------------------------------------------*
5385+
| AES-SIV Test
5386+
*----------------------------------------------------------------------------*/
5387+
5388+
#if defined(WOLFSSL_AES_SIV) && defined(WOLFSSL_AES_128)
5389+
5390+
/*
5391+
* Testing wc_AesSivEncrypt, wc_AesSivDecrypt,
5392+
* wc_AesSivEncrypt_ex, wc_AesSivDecrypt_ex.
5393+
* Uses RFC 5297 Example A.1 (single assoc) and A.2 (two assocs).
5394+
*/
5395+
int test_wc_AesSivEncryptDecrypt(void)
5396+
{
5397+
EXPECT_DECLS;
5398+
5399+
/* RFC 5297 Example A.1: single associated data buffer */
5400+
const byte key_a1[] = {
5401+
0xff,0xfe,0xfd,0xfc,0xfb,0xfa,0xf9,0xf8,
5402+
0xf7,0xf6,0xf5,0xf4,0xf3,0xf2,0xf1,0xf0,
5403+
0xf0,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,
5404+
0xf8,0xf9,0xfa,0xfb,0xfc,0xfd,0xfe,0xff
5405+
};
5406+
const byte assoc_a1[] = {
5407+
0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
5408+
0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,
5409+
0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27
5410+
};
5411+
const byte pt_a1[] = {
5412+
0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,
5413+
0x99,0xaa,0xbb,0xcc,0xdd,0xee
5414+
};
5415+
const byte siv_a1[] = {
5416+
0x85,0x63,0x2d,0x07,0xc6,0xe8,0xf3,0x7f,
5417+
0x95,0x0a,0xcd,0x32,0x0a,0x2e,0xcc,0x93
5418+
};
5419+
const byte ct_a1[] = {
5420+
0x40,0xc0,0x2b,0x96,0x90,0xc4,0xdc,0x04,
5421+
0xda,0xef,0x7f,0x6a,0xfe,0x5c
5422+
};
5423+
5424+
/* RFC 5297 Example A.2: two associated data buffers, no nonce */
5425+
const byte key_a2[] = {
5426+
0x7f,0x7e,0x7d,0x7c,0x7b,0x7a,0x79,0x78,
5427+
0x77,0x76,0x75,0x74,0x73,0x72,0x71,0x70,
5428+
0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,
5429+
0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f
5430+
};
5431+
const byte assoc2_1_a2[] = {
5432+
0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,
5433+
0x88,0x99,0xaa,0xbb,0xcc,0xdd,0xee,0xff,
5434+
0xde,0xad,0xda,0xda,0xde,0xad,0xda,0xda,
5435+
0xff,0xee,0xdd,0xcc,0xbb,0xaa,0x99,0x88,
5436+
0x77,0x66,0x55,0x44,0x33,0x22,0x11,0x00
5437+
};
5438+
const byte assoc2_2_a2[] = {
5439+
0x10,0x20,0x30,0x40,0x50,0x60,0x70,0x80,
5440+
0x90,0xa0
5441+
};
5442+
const byte nonce_a2[] = {
5443+
0x09,0xf9,0x11,0x02,0x9d,0x74,0xe3,0x5b,
5444+
0xd8,0x41,0x56,0xc5,0x63,0x56,0x88,0xc0
5445+
};
5446+
const byte pt_a2[] = {
5447+
0x74,0x68,0x69,0x73,0x20,0x69,0x73,0x20,
5448+
0x73,0x6f,0x6d,0x65,0x20,0x70,0x6c,0x61,
5449+
0x69,0x6e,0x74,0x65,0x78,0x74,0x20,0x74,
5450+
0x6f,0x20,0x65,0x6e,0x63,0x72,0x79,0x70,
5451+
0x74,0x20,0x75,0x73,0x69,0x6e,0x67,0x20,
5452+
0x53,0x49,0x56,0x2d,0x41,0x45,0x53
5453+
};
5454+
const byte siv_a2[] = {
5455+
0x7b,0xdb,0x6e,0x3b,0x43,0x26,0x67,0xeb,
5456+
0x06,0xf4,0xd1,0x4b,0xff,0x2f,0xbd,0x0f
5457+
};
5458+
const byte ct_a2[] = {
5459+
0xcb,0x90,0x0f,0x2f,0xdd,0xbe,0x40,0x43,
5460+
0x26,0x60,0x19,0x65,0xc8,0x89,0xbf,0x17,
5461+
0xdb,0xa7,0x7c,0xeb,0x09,0x4f,0xa6,0x63,
5462+
0xb7,0xa3,0xf7,0x48,0xba,0x8a,0xf8,0x29,
5463+
0xea,0x64,0xad,0x54,0x4a,0x27,0x2e,0x9c,
5464+
0x48,0x5b,0x62,0xa3,0xfd,0x5c,0x0d
5465+
};
5466+
5467+
byte siv[WC_AES_BLOCK_SIZE];
5468+
byte ct[sizeof(pt_a2)]; /* large enough for both tests */
5469+
byte pt[sizeof(pt_a2)];
5470+
5471+
/* --- A.1: wc_AesSivEncrypt (single assoc, no nonce) --- */
5472+
XMEMSET(siv, 0, sizeof(siv));
5473+
XMEMSET(ct, 0, sizeof(ct));
5474+
ExpectIntEQ(wc_AesSivEncrypt(key_a1, sizeof(key_a1),
5475+
assoc_a1, sizeof(assoc_a1),
5476+
NULL, 0,
5477+
pt_a1, sizeof(pt_a1),
5478+
siv, ct), 0);
5479+
ExpectBufEQ(siv, siv_a1, sizeof(siv_a1));
5480+
ExpectBufEQ(ct, ct_a1, sizeof(ct_a1));
5481+
5482+
/* --- A.1: wc_AesSivDecrypt --- */
5483+
XMEMSET(pt, 0, sizeof(pt));
5484+
XMEMCPY(siv, siv_a1, sizeof(siv_a1));
5485+
ExpectIntEQ(wc_AesSivDecrypt(key_a1, sizeof(key_a1),
5486+
assoc_a1, sizeof(assoc_a1),
5487+
NULL, 0,
5488+
ct_a1, sizeof(ct_a1),
5489+
siv, pt), 0);
5490+
ExpectBufEQ(pt, pt_a1, sizeof(pt_a1));
5491+
5492+
/* Corrupt SIV: decrypt must fail */
5493+
siv[0] ^= 0xff;
5494+
ExpectIntNE(wc_AesSivDecrypt(key_a1, sizeof(key_a1),
5495+
assoc_a1, sizeof(assoc_a1),
5496+
NULL, 0,
5497+
ct_a1, sizeof(ct_a1),
5498+
siv, pt), 0);
5499+
5500+
/* --- A.2: wc_AesSivEncrypt_ex (two assocs + nonce) --- */
5501+
{
5502+
const AesSivAssoc assocs[2] = {
5503+
{ assoc2_1_a2, sizeof(assoc2_1_a2) },
5504+
{ assoc2_2_a2, sizeof(assoc2_2_a2) }
5505+
};
5506+
XMEMSET(siv, 0, sizeof(siv));
5507+
XMEMSET(ct, 0, sizeof(ct));
5508+
ExpectIntEQ(wc_AesSivEncrypt_ex(key_a2, sizeof(key_a2),
5509+
assocs, 2,
5510+
nonce_a2, sizeof(nonce_a2),
5511+
pt_a2, sizeof(pt_a2),
5512+
siv, ct), 0);
5513+
ExpectBufEQ(siv, siv_a2, sizeof(siv_a2));
5514+
ExpectBufEQ(ct, ct_a2, sizeof(ct_a2));
5515+
5516+
/* wc_AesSivDecrypt_ex */
5517+
XMEMSET(pt, 0, sizeof(pt));
5518+
XMEMCPY(siv, siv_a2, sizeof(siv_a2));
5519+
ExpectIntEQ(wc_AesSivDecrypt_ex(key_a2, sizeof(key_a2),
5520+
assocs, 2,
5521+
nonce_a2, sizeof(nonce_a2),
5522+
ct_a2, sizeof(ct_a2),
5523+
siv, pt), 0);
5524+
ExpectBufEQ(pt, pt_a2, sizeof(pt_a2));
5525+
}
5526+
5527+
/* --- Bad args: wc_AesSivEncrypt --- */
5528+
ExpectIntNE(wc_AesSivEncrypt(NULL, sizeof(key_a1),
5529+
assoc_a1, sizeof(assoc_a1),
5530+
NULL, 0, pt_a1, sizeof(pt_a1), siv, ct), 0);
5531+
ExpectIntNE(wc_AesSivEncrypt(key_a1, 0,
5532+
assoc_a1, sizeof(assoc_a1),
5533+
NULL, 0, pt_a1, sizeof(pt_a1), siv, ct), 0);
5534+
ExpectIntNE(wc_AesSivEncrypt(key_a1, sizeof(key_a1),
5535+
assoc_a1, sizeof(assoc_a1),
5536+
NULL, 0, pt_a1, sizeof(pt_a1), NULL, ct), 0);
5537+
ExpectIntNE(wc_AesSivEncrypt(key_a1, sizeof(key_a1),
5538+
assoc_a1, sizeof(assoc_a1),
5539+
NULL, 0, pt_a1, sizeof(pt_a1), siv, NULL), 0);
5540+
5541+
/* --- Bad args: wc_AesSivDecrypt --- */
5542+
XMEMCPY(siv, siv_a1, sizeof(siv_a1));
5543+
ExpectIntNE(wc_AesSivDecrypt(NULL, sizeof(key_a1),
5544+
assoc_a1, sizeof(assoc_a1),
5545+
NULL, 0, ct_a1, sizeof(ct_a1), siv, pt), 0);
5546+
ExpectIntNE(wc_AesSivDecrypt(key_a1, 0,
5547+
assoc_a1, sizeof(assoc_a1),
5548+
NULL, 0, ct_a1, sizeof(ct_a1), siv, pt), 0);
5549+
ExpectIntNE(wc_AesSivDecrypt(key_a1, sizeof(key_a1),
5550+
assoc_a1, sizeof(assoc_a1),
5551+
NULL, 0, ct_a1, sizeof(ct_a1), NULL, pt), 0);
5552+
ExpectIntNE(wc_AesSivDecrypt(key_a1, sizeof(key_a1),
5553+
assoc_a1, sizeof(assoc_a1),
5554+
NULL, 0, ct_a1, sizeof(ct_a1), siv, NULL), 0);
5555+
5556+
return EXPECT_RESULT();
5557+
} /* END test_wc_AesSivEncryptDecrypt */
5558+
5559+
#endif /* WOLFSSL_AES_SIV && WOLFSSL_AES_128 */
5560+
52255561
/*----------------------------------------------------------------------------*
52265562
| CryptoCB AES SetKey Test
52275563
*----------------------------------------------------------------------------*/

‎tests/api/test_aes.h‎

Lines changed: 11 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -49,7 +49,11 @@ int test_wc_AesXtsEncryptDecrypt(void);
4949
int test_wc_AesEaxVectors(void);
5050
int test_wc_AesEaxEncryptAuth(void);
5151
int test_wc_AesEaxDecryptAuth(void);
52+
int test_wc_AesEaxStream(void);
5253
#endif /* WOLFSSL_AES_EAX && WOLFSSL_AES_256*/
54+
#if defined(WOLFSSL_AES_SIV) && defined(WOLFSSL_AES_128)
55+
int test_wc_AesSivEncryptDecrypt(void);
56+
#endif
5357

5458
int test_wc_GmacSetKey(void);
5559
int test_wc_GmacUpdate(void);
@@ -95,9 +99,15 @@ int test_wc_CryptoCb_AesGcm_EncryptDecrypt(void);
9599
#define TEST_AES_EAX_DECLS \
96100
TEST_DECL_GROUP("aes-eax", test_wc_AesEaxVectors), \
97101
TEST_DECL_GROUP("aes-eax", test_wc_AesEaxEncryptAuth), \
98-
TEST_DECL_GROUP("aes-eax", test_wc_AesEaxDecryptAuth)
102+
TEST_DECL_GROUP("aes-eax", test_wc_AesEaxDecryptAuth), \
103+
TEST_DECL_GROUP("aes-eax", test_wc_AesEaxStream)
99104
#endif /* WOLFSSL_AES_EAX */
100105

106+
#if defined(WOLFSSL_AES_SIV) && defined(WOLFSSL_AES_128)
107+
#define TEST_AES_SIV_DECLS \
108+
TEST_DECL_GROUP("aes-siv", test_wc_AesSivEncryptDecrypt)
109+
#endif /* WOLFSSL_AES_SIV && WOLFSSL_AES_128 */
110+
101111
#define TEST_GMAC_DECLS \
102112
TEST_DECL_GROUP("gmac", test_wc_GmacSetKey), \
103113
TEST_DECL_GROUP("gmac", test_wc_GmacUpdate)

0 commit comments

Comments
 (0)