Skip to content

Commit 3736341

Browse files
night1ridernight1rider
committed
Extend test coverage for AES key wrap with padding
1 parent 4615932 commit 3736341

2 files changed

Lines changed: 443 additions & 0 deletions

File tree

‎tests/api/test_aes.c‎

Lines changed: 155 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -8058,6 +8058,161 @@ int test_wc_AesKeyWrap_Pad(void)
80588058
WC_NO_ERR_TRACE(BAD_KEYWRAP_IV_E));
80598059
}
80608060

8061+
#if defined(WOLFSSL_AES_128) || defined(WOLFSSL_AES_192) || \
8062+
defined(WOLFSSL_AES_256)
8063+
/* --- Extended coverage for every enabled key size (128/192/256):
8064+
* boundary-size known-answer vectors independently generated with the
8065+
* pyca/cryptography library (which reproduces the RFC 5649 Section 6
8066+
* published vectors), an exhaustive round-trip over all input sizes
8067+
* 1..64, and in-place (in==out) operation. Plaintext is 0xA0,0xA1,...
8068+
* The boundary sizes pin the single->multi-block transition (8 vs 9
8069+
* octets) and the exact-8-multiple zero-padding cases that the 7- and
8070+
* 20-octet vectors never reach. --- */
8071+
{
8072+
#ifdef WOLFSSL_AES_128
8073+
static const byte k128_1[] = {
8074+
0xdc, 0x0c, 0xed, 0x32, 0x50, 0xa4, 0x92, 0x77, 0x59, 0xb4, 0xe9, 0x28,
8075+
0x73, 0x2e, 0x16, 0x8a };
8076+
static const byte k128_8[] = {
8077+
0x23, 0xe1, 0xcd, 0x73, 0x92, 0xf0, 0xcc, 0x69, 0xdc, 0x20, 0xdf, 0x56,
8078+
0x48, 0x9f, 0xfd, 0xd7 };
8079+
static const byte k128_9[] = {
8080+
0xe6, 0xe7, 0x6a, 0xfc, 0xf1, 0xf7, 0x1f, 0x43, 0x63, 0x4b, 0x96, 0x91,
8081+
0x9c, 0x1e, 0x36, 0xa9, 0x5b, 0xf7, 0xb0, 0x26, 0x0f, 0x51, 0x9b, 0x4b };
8082+
static const byte k128_16[] = {
8083+
0xa7, 0x41, 0x46, 0x28, 0x3b, 0x00, 0x85, 0x06, 0x23, 0xd3, 0x02, 0xf4,
8084+
0x57, 0xb1, 0x8c, 0x96, 0xac, 0xe5, 0xb5, 0xd3, 0x64, 0x7c, 0xc2, 0xf1 };
8085+
static const byte k128_17[] = {
8086+
0x8d, 0x69, 0xe5, 0xc5, 0x01, 0x98, 0x70, 0xd3, 0x50, 0x37, 0x3a, 0x00,
8087+
0xa8, 0xe3, 0xa5, 0x32, 0xdf, 0xce, 0x76, 0x8a, 0x6b, 0x79, 0xef, 0x2c,
8088+
0x34, 0xcf, 0xed, 0x5c, 0xb4, 0x09, 0xff, 0xf4 };
8089+
static const byte k128_31[] = {
8090+
0x50, 0x3e, 0xc4, 0xff, 0x2e, 0xd3, 0x01, 0x14, 0xfa, 0x5a, 0x02, 0x47,
8091+
0x9f, 0x20, 0x4c, 0xb1, 0xd8, 0xcb, 0xa2, 0xa3, 0xa3, 0x7d, 0x7b, 0xa5,
8092+
0x60, 0x77, 0x01, 0x46, 0xd6, 0x03, 0x93, 0xe0, 0xf0, 0x01, 0xf7, 0x88,
8093+
0xb0, 0x4b, 0xc6, 0xb2 };
8094+
#endif
8095+
#ifdef WOLFSSL_AES_192
8096+
static const byte k192_1[] = {
8097+
0x95, 0xf7, 0xba, 0x0a, 0x72, 0x6e, 0xed, 0x9a, 0x90, 0xa9, 0x90, 0x00,
8098+
0x94, 0xc5, 0xd9, 0x2d };
8099+
static const byte k192_8[] = {
8100+
0xaa, 0x6f, 0x7d, 0x3b, 0xab, 0x34, 0x91, 0xcc, 0xd9, 0x52, 0xc9, 0x86,
8101+
0x64, 0x42, 0x8c, 0x40 };
8102+
static const byte k192_9[] = {
8103+
0x52, 0xa0, 0xf3, 0xda, 0x5a, 0x48, 0xaf, 0xe9, 0xac, 0x1e, 0x8f, 0x96,
8104+
0x84, 0x25, 0x93, 0x8e, 0xd5, 0x35, 0xaa, 0xe9, 0xbc, 0xe1, 0x0b, 0x52 };
8105+
static const byte k192_16[] = {
8106+
0xe8, 0xba, 0xab, 0xb4, 0xa1, 0xf3, 0x57, 0x6e, 0x72, 0xe4, 0x71, 0xca,
8107+
0x51, 0x2b, 0x5b, 0x64, 0xfb, 0x25, 0x25, 0x97, 0xfc, 0x80, 0x75, 0xe3 };
8108+
static const byte k192_17[] = {
8109+
0xaf, 0x1e, 0xc0, 0xdf, 0x04, 0xef, 0xde, 0xb6, 0x0d, 0xa4, 0xdf, 0xf5,
8110+
0x89, 0x84, 0x14, 0x91, 0x11, 0xdf, 0xda, 0x2d, 0xef, 0xc1, 0x30, 0x6e,
8111+
0x54, 0x46, 0x2e, 0xc3, 0xac, 0x57, 0xf7, 0x8a };
8112+
static const byte k192_31[] = {
8113+
0x1d, 0x59, 0x4c, 0x1a, 0x06, 0x03, 0x33, 0x60, 0x03, 0x12, 0x1e, 0x69,
8114+
0x81, 0xd8, 0xbe, 0xc6, 0x0a, 0xef, 0x71, 0x7f, 0x62, 0x1e, 0x95, 0xb1,
8115+
0xfb, 0x29, 0x96, 0x61, 0x39, 0x78, 0xbb, 0x5f, 0x52, 0xee, 0xc6, 0xda,
8116+
0xed, 0xd8, 0x48, 0x97 };
8117+
#endif
8118+
#ifdef WOLFSSL_AES_256
8119+
static const byte k256_1[] = {
8120+
0xcc, 0xc4, 0x9f, 0xbf, 0x20, 0xf2, 0xac, 0xe7, 0xeb, 0x31, 0xa8, 0xdd,
8121+
0xe2, 0x26, 0x50, 0x6a };
8122+
static const byte k256_8[] = {
8123+
0xea, 0x91, 0xdd, 0x60, 0xe5, 0x9b, 0xd6, 0x8b, 0xad, 0x0d, 0x6e, 0x25,
8124+
0x4b, 0x5e, 0x1c, 0x39 };
8125+
static const byte k256_9[] = {
8126+
0xc9, 0x72, 0x2a, 0x95, 0x51, 0xdf, 0xa2, 0x83, 0x2a, 0xa1, 0xca, 0xe4,
8127+
0x87, 0x82, 0x1e, 0x06, 0x99, 0x12, 0x94, 0xae, 0xbc, 0xe0, 0x98, 0x48 };
8128+
static const byte k256_16[] = {
8129+
0xb3, 0x33, 0x58, 0x13, 0x95, 0xce, 0xdf, 0x83, 0x56, 0xdc, 0x35, 0x6c,
8130+
0x1c, 0xc7, 0x9e, 0x9a, 0x88, 0x5c, 0xb4, 0x98, 0x8e, 0xd6, 0x29, 0xb8 };
8131+
static const byte k256_17[] = {
8132+
0x18, 0x58, 0x36, 0x63, 0x5d, 0xea, 0xaf, 0x4d, 0xa8, 0x27, 0x0c, 0x04,
8133+
0x89, 0x09, 0xae, 0xbf, 0xe9, 0x21, 0x11, 0x66, 0xca, 0x2f, 0xdb, 0x34,
8134+
0xa0, 0x93, 0x69, 0xfe, 0x9b, 0xb8, 0x6b, 0x04 };
8135+
static const byte k256_31[] = {
8136+
0x16, 0x44, 0xf1, 0x8b, 0x57, 0xc7, 0xb3, 0xf1, 0x85, 0x51, 0xbe, 0x73,
8137+
0xff, 0xd0, 0x9c, 0xa7, 0x42, 0xf7, 0xf1, 0x56, 0x26, 0x1d, 0x58, 0x95,
8138+
0xaa, 0xc0, 0x97, 0xc4, 0xb6, 0x4e, 0x02, 0x80, 0xfc, 0x80, 0xbd, 0xac,
8139+
0x45, 0x2c, 0x90, 0x10 };
8140+
#endif
8141+
static const word32 bsz[] = { 1, 8, 9, 16, 17, 31 };
8142+
static const word32 bes[] = { 16, 16, 24, 24, 32, 40 };
8143+
const struct { const byte* kek; word32 kekSz; const byte* exp[6]; } ek[] = {
8144+
#ifdef WOLFSSL_AES_128
8145+
{ kek128, (word32)sizeof(kek128),
8146+
{ k128_1, k128_8, k128_9, k128_16, k128_17, k128_31 } },
8147+
#endif
8148+
#ifdef WOLFSSL_AES_192
8149+
{ kek192, (word32)sizeof(kek192),
8150+
{ k192_1, k192_8, k192_9, k192_16, k192_17, k192_31 } },
8151+
#endif
8152+
#ifdef WOLFSSL_AES_256
8153+
{ kek256, (word32)sizeof(kek256),
8154+
{ k256_1, k256_8, k256_9, k256_16, k256_17, k256_31 } },
8155+
#endif
8156+
};
8157+
byte ewrap[80];
8158+
byte eback[80];
8159+
byte rpt[64];
8160+
word32 ki, bi, s, t;
8161+
8162+
for (t = 0; t < (word32)sizeof(rpt); t++)
8163+
rpt[t] = (byte)(0xA0 + t);
8164+
8165+
for (ki = 0; ki < (word32)(sizeof(ek) / sizeof(ek[0])); ki++) {
8166+
/* boundary-size known-answer + round-trip */
8167+
for (bi = 0; bi < (word32)(sizeof(bsz) / sizeof(bsz[0])); bi++) {
8168+
XMEMSET(ewrap, 0, sizeof(ewrap));
8169+
XMEMSET(eback, 0, sizeof(eback));
8170+
ExpectIntEQ(wc_AesKeyWrap_Pad(ek[ki].kek, ek[ki].kekSz,
8171+
rpt, bsz[bi], ewrap, sizeof(ewrap), NULL),
8172+
(int)bes[bi]);
8173+
ExpectBufEQ(ewrap, ek[ki].exp[bi], bes[bi]);
8174+
ExpectIntEQ(wc_AesKeyUnWrap_Pad(ek[ki].kek, ek[ki].kekSz,
8175+
ewrap, bes[bi], eback, sizeof(eback), NULL),
8176+
(int)bsz[bi]);
8177+
ExpectBufEQ(eback, rpt, bsz[bi]);
8178+
}
8179+
8180+
/* exhaustive round-trip for every input size 1..64 */
8181+
for (s = 1; s <= (word32)sizeof(rpt); s++) {
8182+
int w;
8183+
word32 expW = ((s + 7u) / 8u) * 8u + 8u;
8184+
8185+
XMEMSET(ewrap, 0, sizeof(ewrap));
8186+
XMEMSET(eback, 0, sizeof(eback));
8187+
w = wc_AesKeyWrap_Pad(ek[ki].kek, ek[ki].kekSz,
8188+
rpt, s, ewrap, sizeof(ewrap), NULL);
8189+
ExpectIntEQ(w, (int)expW);
8190+
ExpectIntEQ(wc_AesKeyUnWrap_Pad(ek[ki].kek, ek[ki].kekSz,
8191+
ewrap, (word32)w, eback, sizeof(eback), NULL),
8192+
(int)s);
8193+
ExpectBufEQ(eback, rpt, s);
8194+
}
8195+
8196+
/* in-place (in == out aliasing must be supported) */
8197+
{
8198+
byte buf[80];
8199+
int w;
8200+
8201+
XMEMSET(buf, 0, sizeof(buf));
8202+
XMEMCPY(buf, data20, sizeof(data20));
8203+
w = wc_AesKeyWrap_Pad(ek[ki].kek, ek[ki].kekSz, buf,
8204+
(word32)sizeof(data20), buf,
8205+
sizeof(buf), NULL);
8206+
ExpectIntGE(w, 0);
8207+
ExpectIntEQ(wc_AesKeyUnWrap_Pad(ek[ki].kek, ek[ki].kekSz, buf,
8208+
(word32)w, buf, sizeof(buf), NULL),
8209+
(int)sizeof(data20));
8210+
ExpectBufEQ(buf, data20, sizeof(data20));
8211+
}
8212+
}
8213+
}
8214+
#endif /* WOLFSSL_AES_128 || WOLFSSL_AES_192 || WOLFSSL_AES_256 */
8215+
80618216
return EXPECT_RESULT();
80628217
} /* END test_wc_AesKeyWrap_Pad */
80638218

0 commit comments

Comments
 (0)