diff options
Diffstat (limited to 'src/vppinfra/test')
-rw-r--r-- | src/vppinfra/test/aes_cbc.c | 187 | ||||
-rw-r--r-- | src/vppinfra/test/aes_ctr.c | 481 | ||||
-rw-r--r-- | src/vppinfra/test/aes_gcm.c | 1177 | ||||
-rw-r--r-- | src/vppinfra/test/array_mask.c | 145 | ||||
-rw-r--r-- | src/vppinfra/test/compress.c | 266 | ||||
-rw-r--r-- | src/vppinfra/test/count_equal.c | 104 | ||||
-rw-r--r-- | src/vppinfra/test/crc32c.c | 54 | ||||
-rw-r--r-- | src/vppinfra/test/index_to_ptr.c | 58 | ||||
-rw-r--r-- | src/vppinfra/test/ip_csum.c | 169 | ||||
-rw-r--r-- | src/vppinfra/test/mask_compare.c | 139 | ||||
-rw-r--r-- | src/vppinfra/test/memcpy_x86_64.c | 142 | ||||
-rw-r--r-- | src/vppinfra/test/poly1305.c | 268 | ||||
-rw-r--r-- | src/vppinfra/test/sha2.c | 322 | ||||
-rw-r--r-- | src/vppinfra/test/test.c | 259 | ||||
-rw-r--r-- | src/vppinfra/test/test.h | 125 | ||||
-rw-r--r-- | src/vppinfra/test/toeplitz.c | 514 |
16 files changed, 4410 insertions, 0 deletions
diff --git a/src/vppinfra/test/aes_cbc.c b/src/vppinfra/test/aes_cbc.c new file mode 100644 index 00000000000..be5f8fb176a --- /dev/null +++ b/src/vppinfra/test/aes_cbc.c @@ -0,0 +1,187 @@ +/* SPDX-License-Identifier: Apache-2.0 + * Copyright(c) 2021 Cisco Systems, Inc. + */ + +#if defined(__AES__) || defined(__ARM_FEATURE_CRYPTO) +#include <vppinfra/format.h> +#include <vppinfra/test/test.h> +#include <vppinfra/crypto/aes_cbc.h> + +static const u8 iv[] = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, +}; + +static const u8 plaintext[] = { + 0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96, 0xE9, 0x3D, 0x7E, 0x11, 0x73, + 0x93, 0x17, 0x2A, 0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C, 0x9E, 0xB7, + 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51, 0x30, 0xC8, 0x1C, 0x46, 0xA3, 0x5C, 0xE4, + 0x11, 0xE5, 0xFB, 0xC1, 0x19, 0x1A, 0x0A, 0x52, 0xEF, 0xF6, 0x9F, 0x24, 0x45, + 0xDF, 0x4F, 0x9B, 0x17, 0xAD, 0x2B, 0x41, 0x7B, 0xE6, 0x6C, 0x37, 0x10, +}; + +static const u8 key128[] = { 0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, + 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C }; + +static const u8 key192[24] = { + 0x8E, 0x73, 0xB0, 0xF7, 0xDA, 0x0E, 0x64, 0x52, 0xC8, 0x10, 0xF3, 0x2B, + 0x80, 0x90, 0x79, 0xE5, 0x62, 0xF8, 0xEA, 0xD2, 0x52, 0x2C, 0x6B, 0x7B, +}; + +static const u8 ciphertext128[] = { + 0x76, 0x49, 0xAB, 0xAC, 0x81, 0x19, 0xB2, 0x46, 0xCE, 0xE9, 0x8E, 0x9B, 0x12, + 0xE9, 0x19, 0x7D, 0x50, 0x86, 0xCB, 0x9B, 0x50, 0x72, 0x19, 0xEE, 0x95, 0xDB, + 0x11, 0x3A, 0x91, 0x76, 0x78, 0xB2, 0x73, 0xBE, 0xD6, 0xB8, 0xE3, 0xC1, 0x74, + 0x3B, 0x71, 0x16, 0xE6, 0x9E, 0x22, 0x22, 0x95, 0x16, 0x3F, 0xF1, 0xCA, 0xA1, + 0x68, 0x1F, 0xAC, 0x09, 0x12, 0x0E, 0xCA, 0x30, 0x75, 0x86, 0xE1, 0xA7, +}; + +static const u8 ciphertext192[64] = { + 0x4F, 0x02, 0x1D, 0xB2, 0x43, 0xBC, 0x63, 0x3D, 0x71, 0x78, 0x18, 0x3A, 0x9F, + 0xA0, 0x71, 0xE8, 0xB4, 0xD9, 0xAD, 0xA9, 0xAD, 0x7D, 0xED, 0xF4, 0xE5, 0xE7, + 0x38, 0x76, 0x3F, 0x69, 0x14, 0x5A, 0x57, 0x1B, 0x24, 0x20, 0x12, 0xFB, 0x7A, + 0xE0, 0x7F, 0xA9, 0xBA, 0xAC, 0x3D, 0xF1, 0x02, 0xE0, 0x08, 0xB0, 0xE2, 0x79, + 0x88, 0x59, 0x88, 0x81, 0xD9, 0x20, 0xA9, 0xE6, 0x4F, 0x56, 0x15, 0xCD, +}; + +static const u8 key256[32] = { + 0x60, 0x3D, 0xEB, 0x10, 0x15, 0xCA, 0x71, 0xBE, 0x2B, 0x73, 0xAE, + 0xF0, 0x85, 0x7D, 0x77, 0x81, 0x1F, 0x35, 0x2C, 0x07, 0x3B, 0x61, + 0x08, 0xD7, 0x2D, 0x98, 0x10, 0xA3, 0x09, 0x14, 0xDF, 0xF4, +}; + +static const u8 ciphertext256[64] = { + 0xF5, 0x8C, 0x4C, 0x04, 0xD6, 0xE5, 0xF1, 0xBA, 0x77, 0x9E, 0xAB, 0xFB, 0x5F, + 0x7B, 0xFB, 0xD6, 0x9C, 0xFC, 0x4E, 0x96, 0x7E, 0xDB, 0x80, 0x8D, 0x67, 0x9F, + 0x77, 0x7B, 0xC6, 0x70, 0x2C, 0x7D, 0x39, 0xF2, 0x33, 0x69, 0xA9, 0xD9, 0xBA, + 0xCF, 0xA5, 0x30, 0xE2, 0x63, 0x04, 0x23, 0x14, 0x61, 0xB2, 0xEB, 0x05, 0xE2, + 0xC3, 0x9B, 0xE9, 0xFC, 0xDA, 0x6C, 0x19, 0x07, 0x8C, 0x6A, 0x9D, 0x1B, +}; + +#define _(b) \ + static clib_error_t *test_clib_aes##b##_cbc_encrypt (clib_error_t *err) \ + { \ + aes_cbc_key_data_t k; \ + u8 data[512]; \ + clib_aes##b##_cbc_key_expand (&k, key##b); \ + clib_aes##b##_cbc_encrypt (&k, plaintext, sizeof (plaintext), iv, data); \ + if (memcmp (ciphertext##b, data, sizeof (ciphertext##b)) != 0) \ + err = \ + clib_error_return (err, "encrypted data doesn't match plaintext"); \ + return err; \ + } \ + void __test_perf_fn perftest_aes##b##_enc_var_sz (test_perf_t *tp) \ + { \ + u32 n = tp->n_ops; \ + aes_cbc_key_data_t *kd = test_mem_alloc (sizeof (*kd)); \ + u8 *dst = test_mem_alloc (n + 16); \ + u8 *src = test_mem_alloc_and_fill_inc_u8 (n + 16, 0, 0); \ + clib_aes##b##_cbc_key_expand (kd, key##b); \ + \ + test_perf_event_enable (tp); \ + clib_aes##b##_cbc_encrypt (kd, src, n, iv, dst); \ + test_perf_event_disable (tp); \ + } +_ (128) +_ (192) +_ (256) +#undef _ + +REGISTER_TEST (clib_aes128_cbc_encrypt) = { + .name = "clib_aes128_cbc_encrypt", + .fn = test_clib_aes128_cbc_encrypt, + .perf_tests = PERF_TESTS ({ .name = "variable size (per byte)", + .n_ops = 1424, + .fn = perftest_aes128_enc_var_sz }, + { .name = "variable size (per byte)", + .n_ops = 9008, + .fn = perftest_aes128_enc_var_sz }), +}; + +REGISTER_TEST (clib_aes192_cbc_encrypt) = { + .name = "clib_aes192_cbc_encrypt", + .fn = test_clib_aes192_cbc_encrypt, + .perf_tests = PERF_TESTS ({ .name = "variable size (per byte)", + .n_ops = 1424, + .fn = perftest_aes192_enc_var_sz }, + { .name = "variable size (per byte)", + .n_ops = 9008, + .fn = perftest_aes192_enc_var_sz }), +}; + +REGISTER_TEST (clib_aes256_cbc_encrypt) = { + .name = "clib_aes256_cbc_encrypt", + .fn = test_clib_aes256_cbc_encrypt, + .perf_tests = PERF_TESTS ({ .name = "variable size (per byte)", + .n_ops = 1424, + .fn = perftest_aes256_enc_var_sz }, + { .name = "variable size (per byte)", + .n_ops = 9008, + .fn = perftest_aes256_enc_var_sz }), +}; + +#define _(b) \ + static clib_error_t *test_clib_aes##b##_cbc_decrypt (clib_error_t *err) \ + { \ + aes_cbc_key_data_t k; \ + u8 data[512]; \ + clib_aes##b##_cbc_key_expand (&k, key##b); \ + clib_aes##b##_cbc_decrypt (&k, ciphertext##b, sizeof (ciphertext##b), iv, \ + data); \ + if (memcmp (plaintext, data, sizeof (plaintext)) != 0) \ + err = \ + clib_error_return (err, "decrypted data doesn't match plaintext"); \ + return err; \ + } \ + void __test_perf_fn perftest_aes##b##_dec_var_sz (test_perf_t *tp) \ + { \ + u32 n = tp->n_ops; \ + aes_cbc_key_data_t *kd = test_mem_alloc (sizeof (*kd)); \ + u8 *dst = test_mem_alloc (n + 16); \ + u8 *src = test_mem_alloc_and_fill_inc_u8 (n + 16, 0, 0); \ + clib_aes##b##_cbc_key_expand (kd, key##b); \ + \ + test_perf_event_enable (tp); \ + clib_aes##b##_cbc_decrypt (kd, src, n, iv, dst); \ + test_perf_event_disable (tp); \ + } + +_ (128) +_ (192) +_ (256) +#undef _ + +REGISTER_TEST (clib_aes128_cbc_decrypt) = { + .name = "clib_aes128_cbc_decrypt", + .fn = test_clib_aes128_cbc_decrypt, + .perf_tests = PERF_TESTS ({ .name = "variable size (per byte)", + .n_ops = 1424, + .fn = perftest_aes128_dec_var_sz }, + { .name = "variable size (per byte)", + .n_ops = 9008, + .fn = perftest_aes128_dec_var_sz }), +}; + +REGISTER_TEST (clib_aes192_cbc_decrypt) = { + .name = "clib_aes192_cbc_decrypt", + .fn = test_clib_aes192_cbc_decrypt, + .perf_tests = PERF_TESTS ({ .name = "variable size (per byte)", + .n_ops = 1424, + .fn = perftest_aes192_dec_var_sz }, + { .name = "variable size (per byte)", + .n_ops = 9008, + .fn = perftest_aes192_dec_var_sz }), +}; + +REGISTER_TEST (clib_aes256_cbc_decrypt) = { + .name = "clib_aes256_cbc_decrypt", + .fn = test_clib_aes256_cbc_decrypt, + .perf_tests = PERF_TESTS ({ .name = "variable size (per byte)", + .n_ops = 1424, + .fn = perftest_aes256_dec_var_sz }, + { .name = "variable size (per byte)", + .n_ops = 9008, + .fn = perftest_aes256_dec_var_sz }), +}; + +#endif diff --git a/src/vppinfra/test/aes_ctr.c b/src/vppinfra/test/aes_ctr.c new file mode 100644 index 00000000000..2892700fb27 --- /dev/null +++ b/src/vppinfra/test/aes_ctr.c @@ -0,0 +1,481 @@ +/* SPDX-License-Identifier: Apache-2.0 + * Copyright(c) 2024 Cisco Systems, Inc. + */ + +#if defined(__AES__) || defined(__ARM_FEATURE_CRYPTO) +#include <vppinfra/format.h> +#include <vppinfra/test/test.h> +#include <vppinfra/crypto/aes_ctr.h> + +static const struct +{ + char *name; + const u8 *pt, *key, *ct, *iv; + u32 data_len; +} test_cases128[] = { + /* test cases */ + { .name = "RFC3686 Test Vector #1", + .key = (const u8[16]){ 0xae, 0x68, 0x52, 0xf8, 0x12, 0x10, 0x67, 0xcc, + 0x4b, 0xf7, 0xa5, 0x76, 0x55, 0x77, 0xf3, 0x9e }, + .iv = (const u8[16]){ 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, + + .pt = (const u8 *) "Single block msg", + .ct = (const u8[16]){ 0xe4, 0x09, 0x5d, 0x4f, 0xb7, 0xa7, 0xb3, 0x79, 0x2d, + 0x61, 0x75, 0xa3, 0x26, 0x13, 0x11, 0xb8 }, + .data_len = 16 }, + { .name = "RFC3686 Test Vector #2", + .key = (const u8[16]){ 0x7e, 0x24, 0x06, 0x78, 0x17, 0xfa, 0xe0, 0xd7, + 0x43, 0xd6, 0xce, 0x1f, 0x32, 0x53, 0x91, 0x63 }, + .iv = (const u8[16]){ 0x00, 0x6c, 0xb6, 0xdb, 0xc0, 0x54, 0x3b, 0x59, 0xda, + 0x48, 0xd9, 0x0b, 0x00, 0x00, 0x00, 0x01 }, + .pt = (const u8[32]){ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f }, + .ct = (const u8[32]){ 0x51, 0x04, 0xa1, 0x06, 0x16, 0x8a, 0x72, 0xd9, + 0x79, 0x0d, 0x41, 0xee, 0x8e, 0xda, 0xd3, 0x88, + 0xeb, 0x2e, 0x1e, 0xfc, 0x46, 0xda, 0x57, 0xc8, + 0xfc, 0xe6, 0x30, 0xdf, 0x91, 0x41, 0xbe, 0x28 }, + .data_len = 32 }, + { .name = "RFC3686 Test Vector #3", + .key = (const u8[16]){ 0x76, 0x91, 0xbe, 0x03, 0x5e, 0x50, 0x20, 0xa8, + 0xac, 0x6e, 0x61, 0x85, 0x29, 0xf9, 0xa0, 0xdc }, + .iv = (const u8[16]){ 0x00, 0xe0, 0x01, 0x7b, 0x27, 0x77, 0x7f, 0x3f, 0x4a, + 0x17, 0x86, 0xf0, 0x00, 0x00, 0x00, 0x01 }, + .pt = + (const u8[36]){ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, + 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, + 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23 }, + .ct = + (const u8[36]){ 0xc1, 0xcf, 0x48, 0xa8, 0x9f, 0x2f, 0xfd, 0xd9, 0xcf, + 0x46, 0x52, 0xe9, 0xef, 0xdb, 0x72, 0xd7, 0x45, 0x40, + 0xa4, 0x2b, 0xde, 0x6d, 0x78, 0x36, 0xd5, 0x9a, 0x5c, + 0xea, 0xae, 0xf3, 0x10, 0x53, 0x25, 0xb2, 0x07, 0x2f }, + .data_len = 36 }, +}, test_cases192[] = { + { .name = "RFC3686 Test Vector #4", + .key = (const u8[24]){ 0x16, 0xaf, 0x5b, 0x14, 0x5f, 0xc9, 0xf5, 0x79, + 0xc1, 0x75, 0xf9, 0x3e, 0x3b, 0xfb, 0x0e, 0xed, + 0x86, 0x3d, 0x06, 0xcc, 0xfd, 0xb7, 0x85, 0x15 }, + .iv = (const u8[16]){ 0x00, 0x00, 0x00, 0x48, 0x36, 0x73, 0x3c, 0x14, 0x7d, + 0x6d, 0x93, 0xcb, 0x00, 0x00, 0x00, 0x01 }, + .pt = (const u8[16]){ 0x53, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x62, 0x6c, + 0x6f, 0x63, 0x6b, 0x20, 0x6d, 0x73, 0x67 }, + .ct = (const u8[16]){ 0x4b, 0x55, 0x38, 0x4f, 0xe2, 0x59, 0xc9, 0xc8, 0x4e, + 0x79, 0x35, 0xa0, 0x03, 0xcb, 0xe9, 0x28 }, + .data_len = 16 }, + { .name = "RFC3686 Test Vector #5", + .key = (const u8[24]){ 0x7c, 0x5c, 0xb2, 0x40, 0x1b, 0x3d, 0xc3, 0x3c, + 0x19, 0xe7, 0x34, 0x08, 0x19, 0xe0, 0xf6, 0x9c, + 0x67, 0x8c, 0x3d, 0xb8, 0xe6, 0xf6, 0xa9, 0x1a }, + .iv = (const u8[16]){ 0x00, 0x96, 0xb0, 0x3b, 0x02, 0x0c, 0x6e, 0xad, 0xc2, + 0xcb, 0x50, 0x0d, 0x00, 0x00, 0x00, 0x01 }, + .pt = (const u8[32]){ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f }, + .ct = (const u8[32]){ 0x45, 0x32, 0x43, 0xfc, 0x60, 0x9b, 0x23, 0x32, + 0x7e, 0xdf, 0xaa, 0xfa, 0x71, 0x31, 0xcd, 0x9f, + 0x84, 0x90, 0x70, 0x1c, 0x5a, 0xd4, 0xa7, 0x9c, + 0xfc, 0x1f, 0xe0, 0xff, 0x42, 0xf4, 0xfb, 0x00 }, + .data_len = 32 }, + { .name = "RFC3686 Test Vector #6", + .key = (const u8[24]){ 0x02, 0xBF, 0x39, 0x1E, 0xE8, 0xEC, 0xB1, 0x59, + 0xB9, 0x59, 0x61, 0x7B, 0x09, 0x65, 0x27, 0x9B, + 0xF5, 0x9B, 0x60, 0xA7, 0x86, 0xD3, 0xE0, 0xFE }, + .iv = (const u8[16]){ 0x00, 0x07, 0xBD, 0xFD, 0x5C, 0xBD, 0x60, 0x27, 0x8D, + 0xCC, 0x09, 0x12, 0x00, 0x00, 0x00, 0x01 }, + .pt = + (const u8[36]){ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, + 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, + 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23 }, + .ct = + (const u8[36]){ 0x96, 0x89, 0x3F, 0xC5, 0x5E, 0x5C, 0x72, 0x2F, 0x54, + 0x0B, 0x7D, 0xD1, 0xDD, 0xF7, 0xE7, 0x58, 0xD2, 0x88, + 0xBC, 0x95, 0xC6, 0x91, 0x65, 0x88, 0x45, 0x36, 0xC8, + 0x11, 0x66, 0x2F, 0x21, 0x88, 0xAB, 0xEE, 0x09, 0x35 }, + .data_len = 36 }, + +}, test_cases256[] = { + { .name = "RFC3686 Test Vector #7", + .key = (const u8[32]){ 0x77, 0x6b, 0xef, 0xf2, 0x85, 0x1d, 0xb0, 0x6f, + 0x4c, 0x8a, 0x05, 0x42, 0xc8, 0x69, 0x6f, 0x6c, + 0x6a, 0x81, 0xaf, 0x1e, 0xec, 0x96, 0xb4, 0xd3, + 0x7f, 0xc1, 0xd6, 0x89, 0xe6, 0xc1, 0xc1, 0x04 }, + .iv = (const u8[16]){ 0x00, 0x00, 0x00, 0x60, 0xdb, 0x56, 0x72, 0xc9, 0x7a, + 0xa8, 0xf0, 0xb2, 0x00, 0x00, 0x00, 0x01 }, + .pt = (const u8 *) "Single block msg", + .ct = (const u8[16]){ 0x14, 0x5a, 0xd0, 0x1d, 0xbf, 0x82, 0x4e, 0xc7, 0x56, + 0x08, 0x63, 0xdc, 0x71, 0xe3, 0xe0, 0xc0 }, + .data_len = 16 }, + { .name = "RFC3686 Test Vector #8", + .key = (const u8[32]){ 0xf6, 0xd6, 0x6d, 0x6b, 0xd5, 0x2d, 0x59, 0xbb, + 0x07, 0x96, 0x36, 0x58, 0x79, 0xef, 0xf8, 0x86, + 0xc6, 0x6d, 0xd5, 0x1a, 0x5b, 0x6a, 0x99, 0x74, + 0x4b, 0x50, 0x59, 0x0c, 0x87, 0xa2, 0x38, 0x84 }, + .iv = (const u8[16]){ 0x00, 0xfa, 0xac, 0x24, 0xc1, 0x58, 0x5e, 0xf1, 0x5a, + 0x43, 0xd8, 0x75, 0x00, 0x00, 0x00, 0x01 }, + .pt = (const u8[32]){ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f }, + .ct = (const u8[32]){ 0xf0, 0x5e, 0x23, 0x1b, 0x38, 0x94, 0x61, 0x2c, + 0x49, 0xee, 0x00, 0x0b, 0x80, 0x4e, 0xb2, 0xa9, + 0xb8, 0x30, 0x6b, 0x50, 0x8f, 0x83, 0x9d, 0x6a, + 0x55, 0x30, 0x83, 0x1d, 0x93, 0x44, 0xaf, 0x1c }, + .data_len = 32 }, + { .name = "RFC3686 Test Vector #9", + .key = (const u8[32]){ 0xff, 0x7a, 0x61, 0x7c, 0xe6, 0x91, 0x48, 0xe4, + 0xf1, 0x72, 0x6e, 0x2f, 0x43, 0x58, 0x1d, 0xe2, + 0xaa, 0x62, 0xd9, 0xf8, 0x05, 0x53, 0x2e, 0xdf, + 0xf1, 0xee, 0xd6, 0x87, 0xfb, 0x54, 0x15, 0x3d }, + .iv = (const u8[16]){ 0x00, 0x1c, 0xc5, 0xb7, 0x51, 0xa5, 0x1d, 0x70, 0xa1, + 0xc1, 0x11, 0x48, 0x00, 0x00, 0x00, 0x01 }, + .pt = + (const u8[36]){ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, + 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, + 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23 }, + .ct = + (const u8[36]){ 0xeb, 0x6c, 0x52, 0x82, 0x1d, 0x0b, 0xbb, 0xf7, 0xce, + 0x75, 0x94, 0x46, 0x2a, 0xca, 0x4f, 0xaa, 0xb4, 0x07, + 0xdf, 0x86, 0x65, 0x69, 0xfd, 0x07, 0xf4, 0x8c, 0xc0, + 0xb5, 0x83, 0xd6, 0x07, 0x1f, 0x1e, 0xc0, 0xe6, 0xb8 }, + .data_len = 36 } +}; + +#define MAX_TEST_DATA_LEN 256 + +#define INC_TEST_BYTES (256 * 16 + 1) + +static u8 inc_key128[] = { + 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, + 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c, +}; + +static u8 inc_iv[] = { + 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, + 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, +}; + +static u64 inc_ct128[] = { + 0xb77a659c70dd8dec, 0xebaf93e67e1cdbfa, 0x744766732f6e3a26, + 0xb16d4de0cc6db900, 0x6811ac5c5be10d4a, 0x6b42973b30e29d96, + 0xf1aec4c4ac0badd8, 0xc1955129e00b33ec, 0x49d7cf50bb054cf0, + 0x4deb06dcdc7a21b8, 0xa257b4190916c808, 0x44b7d421c38b934b, + 0x9e4dbb2d1aceb85b, 0x2d1c952f53c6000d, 0x7e25b633f3bceb0d, + 0xcee9f88cd3c2236d, 0x10ce6bc4a53b1d37, 0xb4783ea69ebc261d, + 0x7f732c19e5fdd3ea, 0xb253d0ebd5522c84, 0x7925888c44ef010d, + 0xba213ea62e7ec7f0, 0x239e0466520393fd, 0x8cde31681d451842, + 0x20b8270d3c5c1bc5, 0x3e56c37a1d573ebe, 0xc4fdb0bb491cf04e, + 0x29c9a4f92d7b12da, 0x50c8a51f05b6f704, 0x3cf0f4071c2098fa, + 0xb0842470bd8c6fdd, 0x86dd40fdc9640190, 0xe4a6184230ee4f6c, + 0x0e2a69261819535e, 0xbdb62571c80aaa39, 0x24a0dc5eafd33f3a, + 0x830599f37869c6ac, 0xf7049ae1b8e5c0dd, 0x7c9dd8d4405d2050, + 0x0e91382b1dace623, 0xf2b62e26f4133673, 0xa9216257693afdab, + 0x2a26df863fb6e980, 0x85e600421c395c83, 0xd5a521016a175cb3, + 0x5ef31ae51f7f2f7b, 0xc6ff491d0d6f74d4, 0x16b0e60ac13156d3, + 0xd49e0025d5ec1e4b, 0x987c4eff196cd64e, 0xa163915e80892b07, + 0x69ab0084052d574a, 0x8017caa649d22bdb, 0xf5eb130f0df2c49a, + 0xe2ced8f88537e9ea, 0xdaaff5e845cff681, 0xbd22ac46dd219c7a, + 0x1b963af4641e7cf7, 0xe70e7d5b76f88573, 0x39703f5e2db84937, + 0x8a1514af42bf3c96, 0x7f51d78b7d3971a6, 0x437a651ef9f08c08, + 0x69fd3712ccdfd843, 0xd8204939e67dad48, 0x71035fc942194251, + 0x703d964c7525bb2a, 0xe2166e50e1892d94, 0xbe8034b11f6a5a9f, + 0x954e4d74c3a9e105, 0x19e077bf00e5186a, 0x7aee46c4b5d4cbf1, + 0xfd7dedd15a3e7d35, 0x4ba1c4b76cb93f57, 0xb2e94cffbb82f098, + 0x078b04fcebc1fafc, 0x923edcc8600018b2, 0xc018169aba42ff11, + 0x0e4f91e46db01bf8, 0x7b5d2b322371e9fa, 0x8e94284632dd300b, + 0x80a3d93ce61c2f13, 0x445d2fb83ecfef73, 0xe1279d639bcd26c9, + 0xbd1865ba653ce114, 0x0316cfe3227bfb2a, 0xddc80c63d53878db, + 0xc91a2f5fedf4a51a, 0xce408a5275b0271f, 0x59a0abc34619018e, + 0xa215c590ad1afb21, 0xe3b096d42fc03598, 0x7cada064ab4f4997, + 0x699be0e57d76e47f, 0x235151411eee9cbd, 0xbbc688f0eaf896cd, + 0x4e78715341f9299d, 0x9f85d76bf99ef2a4, 0x15110ceff4a6040b, + 0x9feed36ff4566060, 0x4833ea7d66a0c572, 0x94c7edbdf2169d59, + 0xb413d116c6e771f1, 0x9a4b6e78167f4c66, 0x42d3f993c8aaee27, + 0xd16783a8c4e57558, 0xb1d7a074dd67339e, 0x97a164444f97adc2, + 0xc15a08d61628e5f3, 0x8767e41e04eb96a2, 0xbb28953ed0eae183, + 0xc0bab4e80ed8cc6e, 0x1ac34b5a5c4010f8, 0x0bc3b7d9db1775b7, + 0x565dead595b98969, 0x0fc03a3cfb656014, 0xdb9098b924a92926, + 0xe2786bc431c1f39a, 0xf8a0bf4fffb78d10, 0xd76161fe1ae71851, + 0xced33ea693cedbb4, 0xef13034da5529a1b, 0xd71081cadbbff0ac, + 0x1873eb643e857392, 0xf6f7c30284ffecb0, 0x93ded259d35eb6fe, + 0xf872980774f6e5ef, 0xd457c8ed22d5bc3f, 0x75d907e2a6bcced2, + 0xcfd3dceb8d7a79ba, 0xaeed2ff2fc0872bb, 0xb5fc72005d2eb168, + 0x850e0e0757274665, 0xab7e5da576c706ec, 0xf1df1ba9a972a4ca, + 0xe81d430b4f54adf9, 0x788f3d8655ba79bb, 0xf5990db3557bbf8c, + 0x1cacafc47729252c, 0x7581b4d6f3b83d9b, 0x94185dcdb0b0c4cd, + 0x3596e687f4b9f4ed, 0xb9462442134b804d, 0xdab188808726fec6, + 0xfe10831e8824d4c5, 0x000c641ed4c93be7, 0x2525ee781608b1ea, + 0x2b32469d51104097, 0x73a09c6ea117aea9, 0x8506dcdec8ade0be, + 0xf9f9fa553cac7285, 0x34b24f100086b974, 0xd42fa88547ade8e7, + 0xfd0bb8ce9a5f8e14, 0x15df9966c6a3e433, 0xf6696aafaae89cd6, + 0x3d521a9d1a0087e1, 0xe18ca6b8e94701f0, 0x8a4660e26a77965e, + 0xc74fcdf41bf4aa20, 0x292a356d0b670157, 0x36ff3344a9eee4ea, + 0xd76b051d6251a14b, 0xa9e09f1bacd1e30f, 0xae47cb95f95a8831, + 0x58b85ac7c98537ec, 0x9e30f1be05719bd2, 0x94772e6b56fc1380, + 0xbe94026a4a89b783, 0x7a7ffb61daa5ac60, 0x2f7beafcc5e9ac8a, + 0xfa33f37edc57e94c, 0x230c3582fb412093, 0xdeec806ecc4fa3c4, + 0xc7ff8876a31edd76, 0x6d0500f4ccd1bb20, 0xf1d0bef759b81b6c, + 0x138b1d39533379b7, 0xece52f84d9f20455, 0x3ed05e391352b9dd, + 0x95600f558d4dea51, 0x1d6b997966e35392, 0x0eeae16905b94e37, + 0x7db2acc242a56ab0, 0xaf347e5598687f51, 0xbf25013db6bddc18, + 0x6d4f106c35f9ee28, 0xc8e90bbe4283ab8c, 0x188cf978f1477dee, + 0x66376bfa3a6d8131, 0xe0ebd6632eb89b24, 0xb9e49d81e9d37f69, + 0xa5cfa3812d530e04, 0x717353523542a27f, 0x0d6669c916ab4d34, + 0x79e741ad592a7bb1, 0x63a7f35584bd3ea5, 0xc0494db2930cbc32, + 0x442bd29d7edd0e49, 0x52ec0bce733f61a0, 0x8bd199bf55bc2b4b, + 0x727ede5583bb859c, 0x9d07eda6e8220df1, 0xebdd7467d7259f15, + 0x8f6035a5dc5f53b1, 0x063a0935630b5f6f, 0xc6e983ec1f08ebe6, + 0xeedc82de2b28e651, 0xe28760013e13ae23, 0x37c078d66ad376a3, + 0xd54a72e88e80926b, 0x5822405e1d688eec, 0xa001e0b0d4a7447f, + 0xfd41f41419d8fd4d, 0x1391d37127a75095, 0x4795d7fb7ad67f17, + 0xa47c05c9b8400a0c, 0x28519cd5e98bba0c, 0x84a72dce8a27d050, + 0xcbee7b3c83d68c5f, 0xab2227b8f5203d3d, 0x3335a393d47ef9ec, + 0xd00b21a2a5dde597, 0xb13d50489ca79216, 0xde1cc721425dda94, + 0x1ddc9863b5b0b8e8, 0xb125481a01dfe1b5, 0x5b331c746c4148db, + 0x8d6729fe30d56f1d, 0xdc413723540aca6f, 0xf08fe55711f8f09b, + 0x98bcde7c09126688, 0xa38c02a0c19d08b0, 0xde8df0683372e31e, + 0x08b4727054d766a0, 0xc13b77c325ae45ed, 0x6e7fe05de6b28d5a, + 0x1794a4f149586b9a, 0x23f5881c699f81b8, 0x355c9d899c0dcfe3, + 0x4319acb92ca33a29, 0x4f3211554c2ecf79, 0x64741347e08aaa2f, + 0x32f89bf1084e0723, 0xb0d5d830b9ae58a6, 0x235170babbd5686f, + 0xaa711d0aff2e9830, 0x4f73229995f82ca2, 0x46565f056bb352ea, + 0x55283776fd729f29, 0xb027c5b67be58718, 0xfa58d8c215d52ef8, + 0xfa1a78f7c7db4b2f, 0x7b2badd9a5a7e810, 0x6c362d97ece0f08a, + 0xff8ad11e7ce377b1, 0xdf5a423e843cbfa0, 0xfa9e70edc9c12d2b, + 0xad745d9146b0b3d9, 0xfc2a590f1ce32b8c, 0x599b34c583449c39, + 0xbcab9517d2bd4eae, 0xa5a7f54890e38bc7, 0xb9700fcb336a049a, + 0xfcfcc2d65956af5f, 0x3887b5f3e5d238d6, 0x0b9bc00a60dd37c6, + 0x09f8d5b6a128fe23, 0x4b33ac26a2a59b5c, 0xfc6e3f30b4b4e108, + 0x1e53d6aa6266bee7, 0x9adf6b4cb3369643, 0xda38dfd6df234f48, + 0x845e61ddc98d3d16, 0x4a0b90d7d115d701, 0x64e1c9619aa777c3, + 0x9dd4b1df006c81f9, 0x71b2b88aea6c679e, 0xb39da7819be759ff, + 0xfdad221790b269bb, 0x741f7955b56d786c, 0x5d724fcce9250a73, + 0x3812aa144730905b, 0xb74986be047e24c4, 0xeebb8aa5ebdcc8a0, + 0x26a0ea4272d5a371, 0x2ff3733c39e92f82, 0x17880beb7b808b30, + 0xe298cf8aa284e39c, 0xd481ff1948d0eef0, 0xed53786d517a1f10, + 0x853ccfe7f1cba481, 0x9ba1707467deb6dc, 0xf1aae1c3190806b3, + 0xb017539bb50b55c4, 0x8809bcc37ac46808, 0x0ae0a3e6e9a6bba5, + 0xf7a5276c2a6df772, 0xaf095d1ceb24d931, 0xaa0f62c5eb44d3a6, + 0x5e9915d18cd09844, 0xcfff6a2edf6cd35f, 0x893ebc1038af747e, + 0xe4360da910f3853a, 0x2097129be26812d5, 0x09d1e31bd3fef181, + 0x37a585c49cff87c5, 0xd94d2b3b1cd97311, 0xa3a2d50de285388a, + 0xf627d8b7298602a0, 0x567f848218395a28, 0x9b4b416995765491, + 0x24388b443fd8730a, 0x5b3a3cc87e225bdb, 0x53a9881d098d520b, + 0xadbc31258140299f, 0x37345aad0c678a3f, 0xc0e24ea3958ef6d8, + 0x18ceff669a144d20, 0x3ce920ab86ab70c7, 0x430c240b5307c1cb, + 0x7240a314d5f7fa9c, 0x4dfaf972d1856f15, 0x76ca74db2ad10515, + 0x607ec82965c620f7, 0xc75f531d7eae4145, 0xe91c86c49c8d84a2, + 0x8becf71fe1e371a7, 0x055bb0206808c289, 0x36dbcec66eabc566, + 0x476f4f1b52c4c856, 0x78bdf9114304e28f, 0x206e8342087ca6e2, + 0xda66f574514e8795, 0x903bcf41830a763f, 0x3a8c03f8bfe8c1ae, + 0xc386671f05740107, 0xda3abc3b566c70ab, 0xe1072ad4ebd4a028, + 0xfe9a6d4c0e8a80ce, 0xeb99eb25a084c442, 0xd34f23f8f279e9f3, + 0xccb189048479b94d, 0xfc6f6d863f74a049, 0xa437f340bfdfed0e, + 0xc84ef9a7139af764, 0xbeb88737819b7d55, 0x5f06fb8f06d6372b, + 0x7ec01ec2f978b4a2, 0x1ad4f2fb9963b46f, 0xae4cdeee5c419652, + 0x51ee340ba106d1dc, 0x93544a6e274cf180, 0x0de0b1abf6e9773a, + 0xb55514c7be768e6a, 0x70a3ee12298c0688, 0x58943a332454b1ee, + 0xe9de88a863b83b29, 0xb99dbf02fc35d6c9, 0x285a09f5583ac480, + 0xd0bf2b79a453c915, 0xb6e140e86dcb97d5, 0x8de0ab74f93a8de1, + 0x70f9bb989ce46c09, 0xd7ea17d64158d923, 0x308e3f8a527d0ff7, + 0xa0fffd413b3a872f, 0xcd35b4b30dfb6587, 0x7ef3ab8b9bd5fbcf, + 0x6149f604d9f355f7, 0x130d9020814780cd, 0x45cb969837f9a147, + 0x88dc31c106a2345e, 0x690da693a3472e6d, 0xe1dc49aaab6d8504, + 0x7749dc54f0a8f838, 0x358a1197921ed6e3, 0x50ae914d7b26c811, + 0x6e0f79b3af64d1ad, 0xec45b7e54c408577, 0x94809242f830a52f, + 0x88e8c0701fd8cd25, 0x21f562f903b85ca7, 0x3f8f1d2cfd57d394, + 0x1f0db9fb1767b393, 0x0504a2b6a6b967d3, 0xf18209ff9dee356b, + 0x4e74343f94f09cff, 0x53107e4bd79b52c1, 0x9c4ab4cdba0f0c2f, + 0xfd085f652a3c3f14, 0xcbd20129e019e573, 0x92d2e7681d64d41b, + 0xfa6c6c50db35a8fd, 0x7dc5177e0cc57261, 0xae3586379eed9e9d, + 0x4ba340964a014d54, 0x57147f7d60a4a5ee, 0x423255e50fec612e, + 0x1c1158e2a2afbace, 0x5e0dd39d591b341f, 0x4e0fff62124939a6, + 0x12e0413146fa5c8d, 0x3a6e0c37d48699a0, 0x9774260521aa490f, + 0xbd0f8ecc2b447c99, 0x556d41deab48dad8, 0x08bd36a5be98bc97, + 0x8bf0c22eb1cb99a0, 0x959954221670e572, 0x05143412beae5a0c, + 0x37246cbdf96ede32, 0xeb05ce52c11ab210, 0xd4e9c130ccd17048, + 0x42cc9b6177b7547b, 0x96d603334e7a85c7, 0x850365d5d2f5adcb, + 0xcfa11346e834516c, 0xfb9e30870be0c7bb, 0xc4d137ab85224e7a, + 0xc7f20e98475c4ab3, 0xaf464d45151fec79, 0xe4ad336a38569bcd, + 0xabd20fbf84b809bd, 0xb3643ed21050862a, 0xfb29924632f30a27, + 0x3f4fd0809492521f, 0xcc9635ff080ba76d, 0xeb679199764753a7, + 0x9df2de103f532b81, 0x83784f41703f0a31, 0x70ba6c249783efba, + 0x93cf542badd6d441, 0x8290f3e7b7fcc9a6, 0xb55485e8fadf4677, + 0xf29c554f7e99c1de, 0x277a3a2d674f10e9, 0xe9a5460c4d87bd2a, + 0x0d8489866023402a, 0x6bd7d212c07df415, 0x8d6194cb592bebc3, + 0xa9747f53b4cd4192, 0x56bd4c4c6373dcb9, 0x3385c9e222966cb2, + 0x234bda6863a4f7fd, 0xebc79b310f06f538, 0x3b7556403468fc38, + 0x9ac05c55de908490, 0x381dba9f8e05fd0e, 0x5e92d1853484e36a, + 0x030782801735585f, 0xd8c76845c71a4482, 0xea03ea2ec2406c9b, + 0xe2498a52f95cd21e, 0xd4ffe046d9393212, 0x93565efec984c6c9, + 0x154c50d8c6e11dc9, 0x3cd889f3188c18cc, 0xb5a46a6cba1287ca, + 0xbc203b6c8f21bb66, 0xfedf97cba4c35dea, 0x0c82b3d9520de017, + 0xdb2674b14ddb4d95, 0x44c8e1ca851db784, 0x5596d3e27d211d55, + 0x9dbe804695d2270d, 0xbd54af74b050b82a, 0xe4ea34515f120cea, + 0xaa2564472972ab58, 0xf97af0d678dfd0cb, 0xdebdbc18d6c71bd1, + 0x78423e11438fcb21, 0xf6f749d4f30510d4, 0x68de10085ea4c2ea, + 0x6b3ff4773ccb4ec1, 0x33206eb82742f50e, 0x3046468ab04a0778, + 0xd7168cc59b78654c, 0xcb5800e03e2f90d9, 0x4f8fdaa4a3b0b5ff, + 0xe0eeff2c2ff94e64, 0x7f2578708dafae2e, 0x6feab0ef729b4300, + 0xf1de49e2796cfdf5, 0x90711a9f7886a0d0, 0xf4b39401ae61d28a, + 0x3f26008ddcbc47e9, 0xfab0a15c25a8511d, 0x2664fc987e7fdd17, + 0x51125228da560a04, 0x93a545c6207a3d67, 0x7c8e4446a408cc25, + 0xf9b10a00083f429e, 0x48704b0fc020d66c, 0x1e1a8c7a3d66eae0, + 0x9bde8e4692e41915, 0x7144aad3cf672129, 0xbab5e713e8f5b335, + 0x2d2c0b70c55d7d11, 0xed928a6e1b388ab0, 0xf121a4a71653448f, + 0x0dd175d00c20e9ed, 0xe68066507fb5dcb1, 0x92384f914830a50e, + 0xb4d4c84f220aed3d, 0xa13e4d6ea70cc5f0, 0xfdbe2223195bfa82, + 0xe97bb465c3ca2099, 0x0078ec86e8daa6c0, 0x634c3a1311b805c4, + 0xac04a89119ae79a7, 0x690e7049d8e8762f, 0x0000000000000086, + 0x0000000000000000, +}; + +#define perftest_aesXXX_var_sz(a) \ + void __test_perf_fn perftest_aes##a##_var_sz (test_perf_t *tp) \ + { \ + u32 n = tp->n_ops; \ + aes_ctr_key_data_t *kd = test_mem_alloc (sizeof (*kd)); \ + u8 *dst = test_mem_alloc (n + 16); \ + u8 *src = test_mem_alloc_and_fill_inc_u8 (n + 16, 0, 0); \ + u8 *key = test_mem_alloc_and_fill_inc_u8 (32, 192, 0); \ + u8 *iv = test_mem_alloc_and_fill_inc_u8 (16, 128, 0); \ + \ + clib_aes_ctr_key_expand (kd, key, AES_KEY_##a); \ + \ + test_perf_event_enable (tp); \ + clib_aes##a##_ctr (kd, src, n, iv, dst); \ + test_perf_event_disable (tp); \ + } + +static clib_error_t * +test_clib_aes128_ctr (clib_error_t *err) +{ + aes_ctr_key_data_t kd; + aes_ctr_ctx_t ctx; + u8 pt[INC_TEST_BYTES]; + u8 ct[INC_TEST_BYTES]; + + FOREACH_ARRAY_ELT (tc, test_cases128) + { + clib_aes_ctr_key_expand (&kd, tc->key, AES_KEY_128); + clib_aes128_ctr (&kd, tc->pt, tc->data_len, tc->iv, ct); + + if (tc->data_len && memcmp (tc->ct, ct, tc->data_len) != 0) + return clib_error_return (err, "%s: invalid ciphertext", tc->name); + } + + for (int i = 0; i < sizeof (pt); i++) + pt[i] = i; + + clib_aes_ctr_key_expand (&kd, inc_key128, AES_KEY_128); + clib_aes128_ctr (&kd, pt, INC_TEST_BYTES, inc_iv, ct); + for (int i = 0; i < sizeof (pt); i++) + if (((u8 *) inc_ct128)[i] != ct[i]) + return clib_error_return (err, "incremental test failed (byte %u)", i); + + clib_aes_ctr_init (&ctx, &kd, inc_iv, AES_KEY_128); + for (u32 off = 0, chunk_size = 1; off < INC_TEST_BYTES; + off += chunk_size, chunk_size = clib_min (((chunk_size + 1) * 2 - 1), + INC_TEST_BYTES - off)) + clib_aes_ctr_transform (&ctx, pt + off, ct + off, chunk_size, AES_KEY_128); + + for (int i = 0; i < sizeof (pt); i++) + if (((u8 *) inc_ct128)[i] != ct[i]) + return clib_error_return ( + err, "incremental multiseg test failed (byte %u)", i); + + return err; +} + +perftest_aesXXX_var_sz (128); +REGISTER_TEST (clib_aes128_ctr) = { + .name = "clib_aes128_ctr", + .fn = test_clib_aes128_ctr, + .perf_tests = PERF_TESTS ({ .name = "variable size (per byte)", + .n_ops = 1424, + .fn = perftest_aes128_var_sz }, + { .name = "variable size (per byte)", + .n_ops = 1 << 20, + .fn = perftest_aes128_var_sz }), +}; + +static clib_error_t * +test_clib_aes192_ctr (clib_error_t *err) +{ + aes_ctr_key_data_t kd; + u8 ct[MAX_TEST_DATA_LEN]; + + FOREACH_ARRAY_ELT (tc, test_cases192) + { + clib_aes_ctr_key_expand (&kd, tc->key, AES_KEY_192); + clib_aes192_ctr (&kd, tc->pt, tc->data_len, tc->iv, ct); + + if (tc->data_len && memcmp (tc->ct, ct, tc->data_len) != 0) + return clib_error_return (err, "%s: invalid ciphertext", tc->name); + } + + return err; +} + +perftest_aesXXX_var_sz (192); +REGISTER_TEST (clib_aes192_ctr) = { + .name = "clib_aes192_ctr", + .fn = test_clib_aes192_ctr, + .perf_tests = PERF_TESTS ({ .name = "variable size (per byte)", + .n_ops = 1424, + .fn = perftest_aes192_var_sz }, + { .name = "variable size (per byte)", + .n_ops = 1 << 20, + .fn = perftest_aes192_var_sz }), +}; + +static clib_error_t * +test_clib_aes256_ctr (clib_error_t *err) +{ + aes_ctr_key_data_t kd; + u8 ct[MAX_TEST_DATA_LEN]; + + FOREACH_ARRAY_ELT (tc, test_cases256) + { + aes_ctr_ctx_t ctx; + u32 sz = tc->data_len / 3; + + clib_aes_ctr_key_expand (&kd, tc->key, AES_KEY_256); + clib_aes256_ctr (&kd, tc->pt, tc->data_len, tc->iv, ct); + + if (tc->data_len && memcmp (tc->ct, ct, tc->data_len) != 0) + return clib_error_return (err, "%s: invalid ciphertext", tc->name); + clib_memset (ct, 0, tc->data_len); + + clib_aes_ctr_init (&ctx, &kd, tc->iv, AES_KEY_256); + clib_aes_ctr_transform (&ctx, tc->pt, ct, sz, AES_KEY_256); + clib_aes_ctr_transform (&ctx, tc->pt + sz, ct + sz, sz, AES_KEY_256); + clib_aes_ctr_transform (&ctx, tc->pt + 2 * sz, ct + 2 * sz, + tc->data_len - 2 * sz, AES_KEY_256); + if (tc->data_len && memcmp (tc->ct, ct, tc->data_len) != 0) + return clib_error_return (err, "%s: invalid ciphertext (multiseg)", + tc->name); + } + + return err; +} + +perftest_aesXXX_var_sz (256); +REGISTER_TEST (clib_aes256_ctr) = { + .name = "clib_aes256_ctr", + .fn = test_clib_aes256_ctr, + .perf_tests = PERF_TESTS ({ .name = "variable size (per byte)", + .n_ops = 1424, + .fn = perftest_aes256_var_sz }, + { .name = "variable size (per byte)", + .n_ops = 1 << 20, + .fn = perftest_aes256_var_sz }), +}; + +#endif diff --git a/src/vppinfra/test/aes_gcm.c b/src/vppinfra/test/aes_gcm.c new file mode 100644 index 00000000000..caa36b0f710 --- /dev/null +++ b/src/vppinfra/test/aes_gcm.c @@ -0,0 +1,1177 @@ +/* SPDX-License-Identifier: Apache-2.0 + * Copyright(c) 2021 Cisco Systems, Inc. + */ + +#if (defined(__AES__) && defined(__PCLMUL__)) || defined(__ARM_FEATURE_CRYPTO) +#include <vppinfra/format.h> +#include <vppinfra/test/test.h> +#include <vppinfra/crypto/aes_gcm.h> + +static const u8 tc1_key128[16] = { + 0, +}; + +static const u8 tc1_iv[12] = { + 0, +}; + +static const u8 tc1_tag128[] = { 0x58, 0xe2, 0xfc, 0xce, 0xfa, 0x7e, + 0x30, 0x61, 0x36, 0x7f, 0x1d, 0x57, + 0xa4, 0xe7, 0x45, 0x5a }; +static const u8 tc1_key256[32] = { + 0, +}; + +static const u8 tc1_tag256[] = { + 0x53, 0x0f, 0x8a, 0xfb, 0xc7, 0x45, 0x36, 0xb9, + 0xa9, 0x63, 0xb4, 0xf1, 0xc4, 0xcb, 0x73, 0x8b, +}; + +static const u8 tc2_ciphertext256[] = { 0xce, 0xa7, 0x40, 0x3d, 0x4d, 0x60, + 0x6b, 0x6e, 0x07, 0x4e, 0xc5, 0xd3, + 0xba, 0xf3, 0x9d, 0x18 }; + +static const u8 tc2_tag256[] = { 0xd0, 0xd1, 0xc8, 0xa7, 0x99, 0x99, + 0x6b, 0xf0, 0x26, 0x5b, 0x98, 0xb5, + 0xd4, 0x8a, 0xb9, 0x19 }; + +static const u8 tc2_plaintext[16] = { + 0, +}; + +static const u8 tc2_tag128[] = { 0xab, 0x6e, 0x47, 0xd4, 0x2c, 0xec, + 0x13, 0xbd, 0xf5, 0x3a, 0x67, 0xb2, + 0x12, 0x57, 0xbd, 0xdf }; + +static const u8 tc2_ciphertext128[] = { 0x03, 0x88, 0xda, 0xce, 0x60, 0xb6, + 0xa3, 0x92, 0xf3, 0x28, 0xc2, 0xb9, + 0x71, 0xb2, 0xfe, 0x78 }; + +static const u8 tc3_key128[] = { 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, + 0x73, 0x1c, 0x6d, 0x6a, 0x8f, 0x94, + 0x67, 0x30, 0x83, 0x08 }; + +static const u8 tc3_iv[] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, + 0xdb, 0xad, 0xde, 0xca, 0xf8, 0x88 }; + +static const u8 tc3_plaintext[] = { + 0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5, 0xa5, 0x59, 0x09, 0xc5, 0xaf, + 0xf5, 0x26, 0x9a, 0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda, 0x2e, 0x4c, + 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72, 0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, + 0x53, 0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25, 0xb1, 0x6a, 0xed, 0xf5, + 0xaa, 0x0d, 0xe6, 0x57, 0xba, 0x63, 0x7b, 0x39, 0x1a, 0xaf, 0xd2, 0x55 +}; + +static const u8 tc3_ciphertext128[] = { + 0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24, 0x4b, 0x72, 0x21, 0xb7, 0x84, + 0xd0, 0xd4, 0x9c, 0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, 0xa4, 0xe0, 0x35, 0xc1, + 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e, 0x21, 0xd5, 0x14, 0xb2, 0x54, 0x66, 0x93, + 0x1c, 0x7d, 0x8f, 0x6a, 0x5a, 0xac, 0x84, 0xaa, 0x05, 0x1b, 0xa3, 0x0b, 0x39, + 0x6a, 0x0a, 0xac, 0x97, 0x3d, 0x58, 0xe0, 0x91, 0x47, 0x3f, 0x59, 0x85 +}; + +static const u8 tc3_tag128[] = { 0x4d, 0x5c, 0x2a, 0xf3, 0x27, 0xcd, + 0x64, 0xa6, 0x2c, 0xf3, 0x5a, 0xbd, + 0x2b, 0xa6, 0xfa, 0xb4 }; + +static const u8 tc3_key256[] = { 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, + 0x1c, 0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, + 0x83, 0x08, 0xfe, 0xff, 0xe9, 0x92, 0x86, + 0x65, 0x73, 0x1c, 0x6d, 0x6a, 0x8f, 0x94, + 0x67, 0x30, 0x83, 0x08 }; + +static const u8 tc3_ciphertext256[] = { + 0x52, 0x2d, 0xc1, 0xf0, 0x99, 0x56, 0x7d, 0x07, 0xf4, 0x7f, 0x37, 0xa3, 0x2a, + 0x84, 0x42, 0x7d, 0x64, 0x3a, 0x8c, 0xdc, 0xbf, 0xe5, 0xc0, 0xc9, 0x75, 0x98, + 0xa2, 0xbd, 0x25, 0x55, 0xd1, 0xaa, 0x8c, 0xb0, 0x8e, 0x48, 0x59, 0x0d, 0xbb, + 0x3d, 0xa7, 0xb0, 0x8b, 0x10, 0x56, 0x82, 0x88, 0x38, 0xc5, 0xf6, 0x1e, 0x63, + 0x93, 0xba, 0x7a, 0x0a, 0xbc, 0xc9, 0xf6, 0x62, 0x89, 0x80, 0x15, 0xad +}; + +static const u8 tc3_tag256[] = { 0xb0, 0x94, 0xda, 0xc5, 0xd9, 0x34, + 0x71, 0xbd, 0xec, 0x1a, 0x50, 0x22, + 0x70, 0xe3, 0xcc, 0x6c }; + +static const u8 tc4_plaintext[] = { + 0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5, 0xa5, 0x59, 0x09, 0xc5, + 0xaf, 0xf5, 0x26, 0x9a, 0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda, + 0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72, 0x1c, 0x3c, 0x0c, 0x95, + 0x95, 0x68, 0x09, 0x53, 0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25, + 0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57, 0xba, 0x63, 0x7b, 0x39, +}; + +static const u8 tc4_aad[] = { 0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, + 0xef, 0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, + 0xbe, 0xef, 0xab, 0xad, 0xda, 0xd2 }; + +static const u8 tc4_ciphertext128[] = { + 0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24, 0x4b, 0x72, 0x21, 0xb7, + 0x84, 0xd0, 0xd4, 0x9c, 0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, 0xa4, 0xe0, + 0x35, 0xc1, 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e, 0x21, 0xd5, 0x14, 0xb2, + 0x54, 0x66, 0x93, 0x1c, 0x7d, 0x8f, 0x6a, 0x5a, 0xac, 0x84, 0xaa, 0x05, + 0x1b, 0xa3, 0x0b, 0x39, 0x6a, 0x0a, 0xac, 0x97, 0x3d, 0x58, 0xe0, 0x91 +}; + +static const u8 tc4_tag128[] = { 0x5b, 0xc9, 0x4f, 0xbc, 0x32, 0x21, + 0xa5, 0xdb, 0x94, 0xfa, 0xe9, 0x5a, + 0xe7, 0x12, 0x1a, 0x47 }; + +static const u8 tc4_ciphertext256[] = { + 0x52, 0x2d, 0xc1, 0xf0, 0x99, 0x56, 0x7d, 0x07, 0xf4, 0x7f, 0x37, 0xa3, + 0x2a, 0x84, 0x42, 0x7d, 0x64, 0x3a, 0x8c, 0xdc, 0xbf, 0xe5, 0xc0, 0xc9, + 0x75, 0x98, 0xa2, 0xbd, 0x25, 0x55, 0xd1, 0xaa, 0x8c, 0xb0, 0x8e, 0x48, + 0x59, 0x0d, 0xbb, 0x3d, 0xa7, 0xb0, 0x8b, 0x10, 0x56, 0x82, 0x88, 0x38, + 0xc5, 0xf6, 0x1e, 0x63, 0x93, 0xba, 0x7a, 0x0a, 0xbc, 0xc9, 0xf6, 0x62 +}; + +static const u8 tc4_tag256[] = { 0x76, 0xfc, 0x6e, 0xce, 0x0f, 0x4e, + 0x17, 0x68, 0xcd, 0xdf, 0x88, 0x53, + 0xbb, 0x2d, 0x55, 0x1b }; + +static const u8 inc_key[] = { 0x97, 0x3e, 0x43, 0x70, 0x84, 0x71, 0xd4, 0xe2, + 0x45, 0xd1, 0xcb, 0x79, 0xe8, 0xd7, 0x5f, 0x3b, + 0x97, 0x3e, 0x43, 0x70, 0x84, 0x71, 0xd4, 0xe2, + 0x45, 0xd1, 0xcb, 0x79, 0xe8, 0xd7, 0x5f, 0x3b }; +static const u8 inc_iv[] = { 0xe2, 0xe4, 0x3f, 0x29, 0xfe, 0xd4, + 0xbc, 0x31, 0x56, 0xa7, 0x97, 0xf5 }; + +static const struct +{ + const u16 n_bytes; + const u64 tag_gcm_128[2]; + const u64 tag_gcm_256[2]; + const u64 tag_gmac_128[2]; + const u64 tag_gmac_256[2]; + const u8 tag256[16]; +} inc_test_cases[] = { + { + .n_bytes = 0, + .tag_gcm_128 = { 0x95f4b8cc824294eb, 0xbf964ccf94b47f96 }, + .tag_gcm_256 = { 0x206b456eaa81a3c8, 0xa308160d180e080d }, + .tag_gmac_128 = { 0x95f4b8cc824294eb, 0xbf964ccf94b47f96 }, + .tag_gmac_256 = { 0x206b456eaa81a3c8, 0xa308160d180e080d }, + }, + { + .n_bytes = 1, + .tag_gcm_128 = { 0xe89aa5be94fa1db4, 0x70d82ed02542a560 }, + .tag_gcm_256 = { 0xcb0659b38e60d3a7, 0x9758b874959187ff }, + .tag_gmac_128 = { 0xf9be1e7db073c565, 0x3b8a0ecc7a91f09d }, + .tag_gmac_256 = { 0x1e302e97ab394130, 0xef29621c33bdb710 }, + }, + { + .n_bytes = 7, + .tag_gcm_128 = { 0xf4af7cbe57bd2078, 0x063dd60abbe51049 }, + .tag_gcm_256 = { 0x7d231388fe8a19be, 0x59be3e7205269abd }, + .tag_gmac_128 = { 0x27d0a47980eed1c6, 0xe6163485e73d02b3 }, + .tag_gmac_256 = { 0x61ce281b47729f6c, 0x128a6bc0880e5d84 }, + }, + { + .n_bytes = 8, + .tag_gcm_128 = { 0xf45b40961422abc4, 0x0a932b98c4999694 }, + .tag_gcm_256 = { 0xf7f945beed586ee2, 0x67239433a7bd3f23 }, + .tag_gmac_128 = { 0x3a25d38572abe3b1, 0x220798aca96d594a }, + .tag_gmac_256 = { 0x2e0e6d58d1ab41ca, 0x09bbc83e3b7b5e11 }, + }, + { + .n_bytes = 9, + .tag_gcm_128 = { 0x791b0a879d236364, 0xde9553e3ed1b763f }, + .tag_gcm_256 = { 0x24c13ed7b46813cd, 0xe646ce24ea4b281e }, + .tag_gmac_128 = { 0x0e521672b23a4fc7, 0x16f129224dec5fd8 }, + .tag_gmac_256 = { 0x8b9c603789c34043, 0x0a8b626928c9fb6f }, + }, + { + .n_bytes = 15, + .tag_gcm_128 = { 0xb277ef05e2be1cc0, 0x2922fba5e321c81e }, + .tag_gcm_256 = { 0xc3ca9f633fa803dc, 0x96e60b0c3347d744 }, + .tag_gmac_128 = { 0xab99e6327c8e1493, 0x09a9a153045ba43f }, + .tag_gmac_256 = { 0xfc9ec2d6a1ad492b, 0xf0b0ba877663732d }, + }, + { + .n_bytes = 16, + .tag_gcm_128 = { 0x3e3438e8f932ebe3, 0x958e270d56ae588e }, + .tag_gcm_256 = { 0x6ac53524effc8171, 0xccab3a16a0b5813c }, + .tag_gmac_128 = { 0x0eb4a09c6c7db16b, 0x1cdb5573a27a2e4a }, + .tag_gmac_256 = { 0x71752018b31eae33, 0xdc4bd36d44b9fd5d }, + }, + { + .n_bytes = 31, + .tag_gcm_128 = { 0x1f4d4a7a056e4bca, 0x97ac76121dccb4e0 }, + .tag_gcm_256 = { 0x609aea9aec919ab6, 0x1eba3c4998e7abb9 }, + .tag_gmac_128 = { 0x289280f9e8879c68, 0xe6b0e36afc0d2ae1 }, + .tag_gmac_256 = { 0x0b3f61762ba4ed43, 0x293f596a76d63b37 }, + }, + { + .n_bytes = 32, + .tag_gcm_128 = { 0xc4b64505d045818f, 0x72bfd499f0f983b4 }, + .tag_gcm_256 = { 0x3f003fb179b2c480, 0x883876d4904700c2 }, + .tag_gmac_128 = { 0x3dd10ab954d807f0, 0x5ae32ee41675051e }, + .tag_gmac_256 = { 0x1a80ab830fc736c0, 0x51db27630adae337 }, + }, + { + .n_bytes = 47, + .tag_gcm_128 = { 0x3aedb0c6c14f2ea1, 0xe4626626bae641cd }, + .tag_gcm_256 = { 0x9c91b87dfd302880, 0x05bb594dde5abb9c }, + .tag_gmac_128 = { 0xe0fe54f2bdadeba8, 0x6f8f40edb569701f }, + .tag_gmac_256 = { 0x26c5632c7abbdb3f, 0xc18ccc24df8bb239 }, + }, + { + .n_bytes = 48, + .tag_gcm_128 = { 0xdbceb2aed0dbbe27, 0xfef0013e8ebe6ef1 }, + .tag_gcm_256 = { 0x98ad025f30b58ffa, 0xabc8a99857034e42 }, + .tag_gmac_128 = { 0x269518e8584b7f6c, 0x1c9f41410a81799c }, + .tag_gmac_256 = { 0x144807ce7aa8eb61, 0x611a8355b4377dc6 }, + }, + { + .n_bytes = 63, + .tag_gcm_128 = { 0x1769ccf523a2046e, 0x7328e18749a559b4 }, + .tag_gcm_256 = { 0xcdf2f28efa9689ce, 0x636676f6aedea9de }, + .tag_gmac_128 = { 0x4d47537060defce8, 0x0d4819c20ba8e889 }, + .tag_gmac_256 = { 0x7b60615e7bfc9a7a, 0x610633296eb30b94 }, + }, + { + .n_bytes = 64, + .tag_gcm_128 = { 0xa5602f73865b6a77, 0x78317e461ff9b560 }, + .tag_gcm_256 = { 0x5c17a6dcd1f23b65, 0x25331c378256a93e }, + .tag_gmac_128 = { 0x39d941ed85d81ab0, 0xe358a61078628d63 }, + .tag_gmac_256 = { 0x5276fbdd333f380d, 0xb0dc63e68f137e74 }, + }, + { + .n_bytes = 79, + .tag_gcm_128 = { 0x5d32cd75f2e82d84, 0xbc15801c1fe285bd }, + .tag_gcm_256 = { 0xb2b2855f4b1ecf70, 0xa524adc1609c757b }, + .tag_gmac_128 = { 0xa147493f08a8738e, 0xbf07da9f4a88944f }, + .tag_gmac_256 = { 0xfee15e0d4b936bc7, 0x1dc88398c6b168bc }, + }, + { + .n_bytes = 80, + .tag_gcm_128 = { 0xa303b7247b9b00df, 0xe72d6d7063d48b72 }, + .tag_gcm_256 = { 0x7abfffc9ecfa00ec, 0x9c5ffcd753ee4568 }, + .tag_gmac_128 = { 0xc3e61bf9f370b40e, 0x66b1c4a6df3b19d7 }, + .tag_gmac_256 = { 0x0cc7b09a7d602352, 0x29e8a64447a764d2 }, + }, + { + .n_bytes = 95, + .tag_gcm_128 = { 0xf0fb35c36eac3025, 0xa13463307fc48907 }, + .tag_gcm_256 = { 0x283a73a05bd0e3c2, 0x794a181dd07a0fb7 }, + .tag_gmac_128 = { 0x26f3546060d9f958, 0xc1367fca8869ab40 }, + .tag_gmac_256 = { 0xa046e1705100c711, 0xbcf9d6a06f360260 }, + }, + { + .n_bytes = 96, + .tag_gcm_128 = { 0x974bb3c1c258bfb5, 0xcf057344bccb0596 }, + .tag_gcm_256 = { 0x18920d75fcfb702e, 0x18e5f14ba429b7be }, + .tag_gmac_128 = { 0xf43cca4837ad00b8, 0xb1a1585d51838352 }, + .tag_gmac_256 = { 0xce3427dc5123b31f, 0xdcc6e49fa0f6587e }, + }, + { + .n_bytes = 111, + .tag_gcm_128 = { 0x5d73baa8eef0ced3, 0x79339e31d5d813de }, + .tag_gcm_256 = { 0x4cefa311c9c39a86, 0xe809ee78930ef736 }, + .tag_gmac_128 = { 0x452003e6d535a523, 0x723f08581012c62e }, + .tag_gmac_256 = { 0x6ce2e1661db942ca, 0xccd700c9c6d03cfd }, + }, + { + .n_bytes = 112, + .tag_gcm_128 = { 0x189aa61ce15a0d11, 0xc907e6bccbdbb8f9 }, + .tag_gcm_256 = { 0xa41c96c843b791b4, 0x0f9f60953f03e5fc }, + .tag_gmac_128 = { 0x44c75b94dbf8539f, 0xcdebe3ed9c68c840 }, + .tag_gmac_256 = { 0x21a289dd39eadd19, 0x749a038e1ea0711c }, + }, + { + .n_bytes = 127, + .tag_gcm_128 = { 0xc6ea87bfe82d73f6, 0x9d85dbf8072bb051 }, + .tag_gcm_256 = { 0xd5e436b2ddfac9fa, 0x54d7d13fa214703a }, + .tag_gmac_128 = { 0xdc5374b7d7d221c4, 0xa8cf4e11958b9dff }, + .tag_gmac_256 = { 0xc7ad0bba9de54f6a, 0x38ed037fe0924dee }, + }, + { + .n_bytes = 128, + .tag_gcm_128 = { 0x357d4954b7c2b440, 0xb3b07ce0cd143149 }, + .tag_gcm_256 = { 0x5555d09cb247322d, 0xeb9d1cea38b68951 }, + .tag_gmac_128 = { 0x6a77579181663dde, 0xe359157bd4246d3f }, + .tag_gmac_256 = { 0x9fe930d50d661e37, 0xba4a0f3c3a6b63cf }, + }, + { + .n_bytes = 143, + .tag_gcm_128 = { 0x358f897d4783966f, 0x6fa44993a9ed54c4 }, + .tag_gcm_256 = { 0x60e91f959f2ccdbe, 0x116c56fdaa107deb }, + .tag_gmac_128 = { 0x121d26aba8aaee0d, 0xc37cda9c43f51008 }, + .tag_gmac_256 = { 0x06918b1cd20e0abc, 0x42938b1d8e745dcd }, + }, + { + .n_bytes = 144, + .tag_gcm_128 = { 0x8a9efe3df387e069, 0xc0a3f2f7547c704b }, + .tag_gcm_256 = { 0x217d59f53bfbc314, 0x2d8f088d05532b0d }, + .tag_gmac_128 = { 0x382949d56e0e8f05, 0x4e87fb8f83f095a7 }, + .tag_gmac_256 = { 0x75e07060883db37d, 0x5fde7b9bda37d680 }, + }, + { + .n_bytes = 159, + .tag_gcm_128 = { 0x297252081cc8db1e, 0x6357143fa7f756c8 }, + .tag_gcm_256 = { 0x7e8fca9d1b17e003, 0x7bf7dad063b9a5c9 }, + .tag_gmac_128 = { 0x5d0524b130e97547, 0xd6befd8591072437 }, + .tag_gmac_256 = { 0xf5f631d391b635fc, 0xe8f7b6808544f312 }, + }, + { + .n_bytes = 160, + .tag_gcm_128 = { 0x90e034ee0f08a871, 0x002f483eefa24ec9 }, + .tag_gcm_256 = { 0xed24df02e455d6d3, 0x7a7d318ed132cb7f }, + .tag_gmac_128 = { 0xc75f87215ae12a2f, 0xf264e5381d5b0412 }, + .tag_gmac_256 = { 0x1ad3e294fd55b0a6, 0xa1a551e59fd12e2f }, + }, + { + .n_bytes = 175, + .tag_gcm_128 = { 0x8f663955c8e4249e, 0xd9d8d8d7352b18d9 }, + .tag_gcm_256 = { 0xd9af34eae74a35e1, 0xc22e74b34267e5df }, + .tag_gmac_128 = { 0xb54a2e8b186a55db, 0x980f586c6da8afce }, + .tag_gmac_256 = { 0x9cceb31baad18ff1, 0xce97588909ece8af }, + }, + { + .n_bytes = 176, + .tag_gcm_128 = { 0x258ec0df82f003bd, 0x571496e92c966695 }, + .tag_gcm_256 = { 0xa1925cda1fa1dd2c, 0x914038618faecf99 }, + .tag_gmac_128 = { 0xfc384b412bdb05ef, 0x73968cf3b464a997 }, + .tag_gmac_256 = { 0x50d9ce4be242e176, 0x5fb78e9404c9226d }, + }, + { + .n_bytes = 191, + .tag_gcm_128 = { 0x796a90a3edaab614, 0x4bf34c2c6333c736 }, + .tag_gcm_256 = { 0x4ffd3a84b346c6d5, 0x9d4c84c7ac5a191c }, + .tag_gmac_128 = { 0x16c11c6bfad5973e, 0xa0825b9c827137c8 }, + .tag_gmac_256 = { 0x82c144c209c22758, 0x7428b4ac38a65c56 }, + }, + { + .n_bytes = 192, + .tag_gcm_128 = { 0x2a44492af2e06a75, 0xbe4eab62aacfc2d3 }, + .tag_gcm_256 = { 0xb7d4971a8061092d, 0x94da543669369e41 }, + .tag_gmac_128 = { 0xed462726c984b596, 0xd61b317d979f5df8 }, + .tag_gmac_256 = { 0x554dc7f30981dbf6, 0x94447d0fbf9f2c8b }, + }, + { + .n_bytes = 207, + .tag_gcm_128 = { 0xcfac9f67252713c8, 0xd638cf6b74c6acf6 }, + .tag_gcm_256 = { 0x57a4a9d299663925, 0xa802f8453e8bcc5b }, + .tag_gmac_128 = { 0xef03f3cdcb0ea819, 0xeea8f0f7f805c306 }, + .tag_gmac_256 = { 0x3d8cd7d92cf0a212, 0x12c1ddddab7e752c }, + }, + { + .n_bytes = 208, + .tag_gcm_128 = { 0x5467633795b92cf5, 0x6b45fb93e19f9341 }, + .tag_gcm_256 = { 0xaeced4090d4d20bc, 0xd20161cd2617613e }, + .tag_gmac_128 = { 0x02bb88dbe681ab69, 0xaf973bfd0b924144 }, + .tag_gmac_256 = { 0x313020fc5283b45e, 0x1757616d4cf17c7f }, + }, + { + .n_bytes = 223, + .tag_gcm_128 = { 0x2f9c725903c07adf, 0xe01712c7d6d5055d }, + .tag_gcm_256 = { 0xeae53a9b0d03a4f9, 0x42b2375d569d384e }, + .tag_gmac_128 = { 0x6ea092dd400ec00d, 0x23237fa0bd0c1977 }, + .tag_gmac_256 = { 0xa02e0f41f12f0053, 0xfba53430aa616219 }, + }, + { + .n_bytes = 224, + .tag_gcm_128 = { 0x73e40772334901a9, 0xddf6075b357cb307 }, + .tag_gcm_256 = { 0x2eb3450f9462c968, 0xa9fb95f281c117e9 }, + .tag_gmac_128 = { 0x33762525c12dfd1d, 0xcb3d8d0402c23ebf }, + .tag_gmac_256 = { 0x30c6d05fb98c2a84, 0xaa2c9f6303383d3a }, + }, + { + .n_bytes = 239, + .tag_gcm_128 = { 0x184d15fd2e2c63a6, 0x3dfe238b88dd2924 }, + .tag_gcm_256 = { 0x18deafee39975b36, 0xc07761cf4fc16c06 }, + .tag_gmac_128 = { 0x10a48f2bc4e64f87, 0x85eec49ae83d4256 }, + .tag_gmac_256 = { 0x5ac87f47f32770eb, 0x31706ca888dd6d44 }, + }, + { + .n_bytes = 240, + .tag_gcm_128 = { 0x153134f11cfa06ec, 0xd987642cc3688a34 }, + .tag_gcm_256 = { 0x3eb66b6dc0bba824, 0x274c4648d515c844 }, + .tag_gmac_128 = { 0x9e5afe891c7c7dcb, 0xa2b3fa1c026343e2 }, + .tag_gmac_256 = { 0xe9120e4e9ff4b1e1, 0xb88bf68336342598 }, + }, + { + .n_bytes = 255, + .tag_gcm_128 = { 0x2b5e78936d1ace73, 0x15b766bfee18d348 }, + .tag_gcm_256 = { 0xeb3741a345395c97, 0x02e11e0478e4cc5a }, + .tag_gmac_128 = { 0xf7daf525751192df, 0x1b1641c3362905ac }, + .tag_gmac_256 = { 0x0b16a2bb842caaca, 0x996732fedaa6b829 }, + }, + { + .n_bytes = 256, + .tag_gcm_128 = { 0x6d4507e0c354e80a, 0x2345eccddd0bd71e }, + .tag_gcm_256 = { 0xa582b8122d699b63, 0xb16db944f6b073f3 }, + .tag_gmac_128 = { 0xc58bb57544c07b40, 0x1a8dd3d8124cdf39 }, + .tag_gmac_256 = { 0xb0f6db0da52e1dc2, 0xbd3a86a577ed208a }, + }, + { + .n_bytes = 319, + .tag_gcm_128 = { 0x2cd41fdf6f659a6b, 0x2486849d7666d76e }, + .tag_gcm_256 = { 0xb7e416c8a716cb4d, 0xc7abe0d755b48845 }, + .tag_gmac_128 = { 0xad83725394d4a36b, 0x5fdd42e941cad49b }, + .tag_gmac_256 = { 0xbb0b73609b90f7eb, 0xe4d382b8b9b7d43e }, + }, + { + .n_bytes = 320, + .tag_gcm_128 = { 0x064cfe34b7d9f89c, 0xb6c7263f66c89b47 }, + .tag_gcm_256 = { 0x1254c9ae84d8ff50, 0x9faeab423099dc9a }, + .tag_gmac_128 = { 0xd91d60ce71d24533, 0xb1cdfd3b3200b171 }, + .tag_gmac_256 = { 0x921de9e3d353559c, 0x3509d2775817a1de }, + }, + { + .n_bytes = 383, + .tag_gcm_128 = { 0x14788c7531d682e1, 0x8af79effe807a4dc }, + .tag_gcm_256 = { 0x947754a0844b4a4d, 0x9eb3849d93d5048e }, + .tag_gmac_128 = { 0xfa84d3a18ea6f895, 0x9a45c729797a8ac4 }, + .tag_gmac_256 = { 0xe8e61e134e40359a, 0xe8e404d4b523607c }, + }, + { + .n_bytes = 384, + .tag_gcm_128 = { 0xfba3fcfd9022e9a7, 0x257ba59f12055d70 }, + .tag_gcm_256 = { 0x7c6ca4e7fba2bc35, 0x1c590be09b3d549b }, + .tag_gmac_128 = { 0x4ca0f087d812e48f, 0xd1d39c4338d57a04 }, + .tag_gmac_256 = { 0xb0a2257cdec364c7, 0x6a4308976fda4e5d }, + }, + { + .n_bytes = 447, + .tag_gcm_128 = { 0x8fde1490c60f09bf, 0xd2932f04c202c5e4 }, + .tag_gcm_256 = { 0x1845a80cbdcf2e62, 0xc7c49c9864bca732 }, + .tag_gmac_128 = { 0x35aa90d2deb41b9c, 0x516ab85a3f17b71e }, + .tag_gmac_256 = { 0x1db78f8b7b34d9e7, 0xd168177351e601fe }, + }, + { + .n_bytes = 448, + .tag_gcm_128 = { 0xd0a7b75f734a1a7c, 0xc7689b7c571a09bf }, + .tag_gcm_256 = { 0xef3a9118c347118d, 0x282a7736060d7bb5 }, + .tag_gmac_128 = { 0xce2dab9fede53934, 0x27f3d2bb2af9dd2e }, + .tag_gmac_256 = { 0xca3b0cba7b772549, 0x3104ded0d6df7123 }, + }, + { + .n_bytes = 511, + .tag_gcm_128 = { 0x6fb5d366fa97b2d2, 0xed2d955fcc78e556 }, + .tag_gcm_256 = { 0xc2bc52eca9348b7c, 0x0ec18a2eb637446f }, + .tag_gmac_128 = { 0xe3012a4897edd5b5, 0xfe18c3ec617a7e88 }, + .tag_gmac_256 = { 0x00e050eecf184591, 0xba24484f84867f4f }, + }, + { + .n_bytes = 512, + .tag_gcm_128 = { 0x25138f7fe88b54bd, 0xcc078b619c0e83a2 }, + .tag_gcm_256 = { 0x63313c5ebe68fa92, 0xccc78784896cdcc3 }, + .tag_gmac_128 = { 0xc688fe54c5595ec0, 0x5b8a687343c3ef03 }, + .tag_gmac_256 = { 0x807c9f8e1c198242, 0xb1e0befc0b9b8193 }, + }, + { + .n_bytes = 575, + .tag_gcm_128 = { 0x0ce8e0b7332a7076, 0xe4aa7ab60dd0946a }, + .tag_gcm_256 = { 0x585cff3cf78504d4, 0x45f3a9532ea40e8b }, + .tag_gmac_128 = { 0xc06ca34dbad542b4, 0x840508722ff031dc }, + .tag_gmac_256 = { 0xa46e22748f195488, 0x43817a5d4d17408a }, + }, + { + .n_bytes = 576, + .tag_gcm_128 = { 0x45360be81e8323bd, 0x10892d9804b75bb5 }, + .tag_gcm_256 = { 0x66208ae5d809036e, 0x603d0af49475de88 }, + .tag_gmac_128 = { 0xb4f2b1d05fd3a4ec, 0x6a15b7a05c3a5436 }, + .tag_gmac_256 = { 0x8d78b8f7c7daf6ff, 0x925b2a92acb7356a }, + }, + { + .n_bytes = 577, + .tag_gcm_128 = { 0xc7e5cd17251fd138, 0xecfb0e05110303df }, + .tag_gcm_256 = { 0x2939d12c85ea8cf8, 0xea063fba37c92eb5 }, + .tag_gmac_128 = { 0x1fa02b370bec64a0, 0x8c759ca95a8cea85 }, + .tag_gmac_256 = { 0x6a602c2b1fff6617, 0x17e06d829bd24a8d }, + }, + { + .n_bytes = 639, + .tag_gcm_128 = { 0xc679ef7a01e8f14c, 0x281e3b9a9f715cb9 }, + .tag_gcm_256 = { 0x13abd2d67e162f98, 0xf637d467046af949 }, + .tag_gmac_128 = { 0x05037392550b7ae2, 0x5095b4629ba46d40 }, + .tag_gmac_256 = { 0xd8e8045772299aa7, 0x564d72fb58ea9808 }, + }, + { + .n_bytes = 640, + .tag_gcm_128 = { 0xff1a2c922cdd1336, 0xcaa02eab8691bf51 }, + .tag_gcm_256 = { 0xd57e16f169d79da5, 0x3e2b47264f8efe9c }, + .tag_gmac_128 = { 0xb32750b403bf66f8, 0x1b03ef08da0b9d80 }, + .tag_gmac_256 = { 0x80ac3f38e2aacbfa, 0xd4ea7eb88213b629 }, + }, + { + .n_bytes = 703, + .tag_gcm_128 = { 0xefd0804f0155b8f1, 0xb1849ed867269569 }, + .tag_gcm_256 = { 0xf66c5ecbd1a06fa4, 0x55ef36f3fdbe763a }, + .tag_gmac_128 = { 0x725813463d977e5b, 0xd52aaabb923cfabb }, + .tag_gmac_256 = { 0x4add8f86736adc52, 0xf6dabb4596975fd7 }, + }, + { + .n_bytes = 704, + .tag_gcm_128 = { 0x583b29260ea8e49f, 0xfaa93b0db98f9274 }, + .tag_gcm_256 = { 0x0b777f2cd9e2f0ef, 0x01510fc85a99382e }, + .tag_gmac_128 = { 0x89df280b0ec65cf3, 0xa3b3c05a87d2908b }, + .tag_gmac_256 = { 0x9d510cb7732920fc, 0x16b672e611ae2f0a }, + }, + { + .n_bytes = 767, + .tag_gcm_128 = { 0x671ec58ab6d4a210, 0x0845fbe603169eff }, + .tag_gcm_256 = { 0xb3913f7eb9bbdbbb, 0x4cb17aa290f6ab11 }, + .tag_gmac_128 = { 0x3036046580a81443, 0xe18d34bb706e632b }, + .tag_gmac_256 = { 0x4e82bc959349466c, 0x01210641d62bbdda }, + }, + { + .n_bytes = 768, + .tag_gcm_128 = { 0x66993b5de915fc6e, 0x4aaf0b8441040267 }, + .tag_gcm_256 = { 0x958ed0a6c1bf11e0, 0xc29d9f4a8ce8bdc6 }, + .tag_gmac_128 = { 0x02674435b179fddc, 0xe016a6a0540bb9be }, + .tag_gmac_256 = { 0xf562c523b24bf164, 0x257cb21a7b602579 }, + }, + { + .n_bytes = 831, + .tag_gcm_128 = { 0x4914f7980699f93c, 0xc2e44fdba6a839e7 }, + .tag_gcm_256 = { 0xa8fab43ecd572a25, 0x3cd465e491195b81 }, + .tag_gmac_128 = { 0xa6d725516e956d5d, 0x630768e80ac3de3d }, + .tag_gmac_256 = { 0xb4746cdde367c9e2, 0x3ea53280901a0375 }, + }, + { + .n_bytes = 832, + .tag_gcm_128 = { 0xac9a519f06fb8c70, 0xdc1a6544ed2cfcf7 }, + .tag_gcm_256 = { 0x54877a7ccd02c592, 0x1a09a4474d903b56 }, + .tag_gmac_128 = { 0xd24937cc8b938b05, 0x8d17d73a7909bbd7 }, + .tag_gmac_256 = { 0x9d62f65eaba46b95, 0xef7f624f71ba7695 }, + }, + { + .n_bytes = 895, + .tag_gcm_128 = { 0x3d365bf4d44c1071, 0x07ac3129079f2013 }, + .tag_gcm_256 = { 0x608543d4fe6526a1, 0xc78a987b87c8d96c }, + .tag_gmac_128 = { 0xc71cf903f7a557c5, 0x06788583ad2122a5 }, + .tag_gmac_256 = { 0x7cdaa511565b289a, 0xf818a4c85a8bd575 }, + }, + { + .n_bytes = 896, + .tag_gcm_128 = { 0x97000fafd1359a0b, 0xfc226d534866b495 }, + .tag_gcm_256 = { 0x1850ee7af3133326, 0xf198d539eee4b1f5 }, + .tag_gmac_128 = { 0x7138da25a1114bdf, 0x4deedee9ec8ed265 }, + .tag_gmac_256 = { 0x249e9e7ec6d879c7, 0x7abfa88b8072fb54 }, + }, + { + .n_bytes = 959, + .tag_gcm_128 = { 0x17200025564902f2, 0x3f2c3b711ba4086d }, + .tag_gcm_256 = { 0x3d0bf3e8b24e296d, 0x42fe0f54e33deb6d }, + .tag_gmac_128 = { 0x8baae9b6f3bd797a, 0x177e0b6c577f2436 }, + .tag_gmac_256 = { 0x853f961c965f472c, 0x8adc4113b3cf933a }, + }, + { + .n_bytes = 960, + .tag_gcm_128 = { 0x2a30ca7325e7a81b, 0xacbc71832bdceb63 }, + .tag_gcm_256 = { 0x037786319dc22ed7, 0x6730acf359ec3b6e }, + .tag_gmac_128 = { 0x702dd2fbc0ec5bd2, 0x61e7618d42914e06 }, + .tag_gmac_256 = { 0x52b3152d961cbb82, 0x6ab088b034f6e3e7 }, + }, + { + .n_bytes = 1023, + .tag_gcm_128 = { 0x8e8789e6c4c90855, 0x4ec5503d7f953df6 }, + .tag_gcm_256 = { 0xdb0afebe6c085f53, 0x4eb6f07b63b8a020 }, + .tag_gmac_128 = { 0x6e9b48e5ad508180, 0xdc86430db2bad514 }, + .tag_gmac_256 = { 0xbb52b4fbf236b741, 0x47ae63bc836dfba3 }, + }, + { + .n_bytes = 1024, + .tag_gcm_128 = { 0x94e1ccbea0f24089, 0xf51b53b600363bd2 }, + .tag_gcm_256 = { 0x70f3eb3d562f0b34, 0xffd09e1a25d5bef3 }, + .tag_gmac_128 = { 0x65a2b560392ecee3, 0x30079a9a9dbbd3a3 }, + .tag_gmac_256 = { 0x4d361736c43090e6, 0x135810df49dcc981 }, + }, + { + .n_bytes = 1025, + .tag_gcm_128 = { 0x830a99737df5a71a, 0xd9ea6e87c63d3aae }, + .tag_gcm_256 = { 0xa3fc30e0254a5ee2, 0x52e59adc9a75be40 }, + .tag_gmac_128 = { 0xb217556427fc09ab, 0xc32fd72ec886730d }, + .tag_gmac_256 = { 0xeab5a9a02cb0869e, 0xd59e51684bc2839c }, + }, + { + .n_bytes = 1039, + .tag_gcm_128 = { 0x238f229130e92934, 0x52752fc860bca067 }, + .tag_gcm_256 = { 0xae2754bcaed68191, 0xe0770d1e9a7a67f3 }, + .tag_gmac_128 = { 0xe030ad2beb01d85d, 0xf10c78b1b64c27af }, + .tag_gmac_256 = { 0x081b45e126248e85, 0xca0789f30e1c47a1 }, + }, + { + .n_bytes = 1040, + .tag_gcm_128 = { 0x4eebcf7391d66c6f, 0x107d8bef4a93d9c6 }, + .tag_gcm_256 = { 0xbeb02ae5466964f3, 0x8eb90364c5f9e4cb }, + .tag_gmac_128 = { 0x451deb85fbf27da5, 0xe47e8c91106dadda }, + .tag_gmac_256 = { 0x85f0a72f3497699d, 0xe6fce0193cc6c9d1 }, + }, + { + .n_bytes = 1041, + .tag_gcm_128 = { 0xbbddfb0304411d71, 0xe573f63553d7ede4 }, + .tag_gcm_256 = { 0x68e42d2959af0b24, 0x35ac8e73c749e7f4 }, + .tag_gmac_128 = { 0x98d022b9896b68f8, 0x98dfde2a17b2869b }, + .tag_gmac_256 = { 0xb8dac6add35d0d9b, 0x1c55973c6dd769af }, + }, + { + .n_bytes = 1536, + .tag_gcm_128 = { 0x7d8933fd922418bd, 0xc88c2f289c5d3d83 }, + .tag_gcm_256 = { 0x966c103eb6ee69f2, 0x2f6b070b5c0fc66f }, + .tag_gmac_128 = { 0x3b70f6154246e758, 0xd485c0edf236b6e2 }, + .tag_gmac_256 = { 0xfefe1832387b9768, 0xc876712098256ca3 }, + }, + { + .n_bytes = 2047, + .tag_gcm_128 = { 0x15c6bbcb0d835fd4, 0xc33afd1328c1deb1 }, + .tag_gcm_256 = { 0xcde3edeea228ada6, 0x8276721a8662e708 }, + .tag_gmac_128 = { 0xb556b0e42419759e, 0x23b0365cf956a3ad }, + .tag_gmac_256 = { 0x8df762cbbe4b2a04, 0x6841bc61e5702419 }, + }, + { + .n_bytes = 2048, + .tag_gcm_128 = { 0xc5ddbeb8765e3aac, 0x1bad7349fd9f2b50 }, + .tag_gcm_256 = { 0xa2a623dde251a98d, 0xaf905fbd16f6a7d9 }, + .tag_gmac_128 = { 0xe20f1e533df2b3d0, 0x5d170bdbcc278a63 }, + .tag_gmac_256 = { 0x9663185c4342cd4a, 0x82d3c5a3a4998fc6 }, + }, + { + .n_bytes = 2064, + .tag_gcm_128 = { 0x12b76ea0a6ee9cbc, 0xdaecfae7c815aa58 }, + .tag_gcm_256 = { 0xb5bb2f76028713dd, 0xc8f3a1448b3bd050 }, + .tag_gmac_128 = { 0x019445c168c42f9b, 0xdf33e251bd9a27fe }, + .tag_gmac_256 = { 0xbbabd0cefc4d6a42, 0xb138675ca66ba54f }, + }, + { + .n_bytes = 2065, + .tag_gcm_128 = { 0x8758c5168ffc3fd7, 0x554f1df7cfa3b976 }, + .tag_gcm_256 = { 0xc9808cf0fd21aede, 0xe26921f3fd308006 }, + .tag_gmac_128 = { 0x44a57e7a32031596, 0x75476d5542faa57b }, + .tag_gmac_256 = { 0xea0e81807fa79a4a, 0x889cca80746fb8d5 }, + }, + { + .n_bytes = 4095, + .tag_gcm_128 = { 0x06db87757f541dc9, 0x823c619c6b88ef80 }, + .tag_gcm_256 = { 0xdf0861a56a7fe7b0, 0xe077a5c735cc21b2 }, + .tag_gmac_128 = { 0x43cb482bea0449e9, 0x70d668af983c9a6c }, + .tag_gmac_256 = { 0x5fc304ad7be1d19a, 0x81bf2f4111de0b06 }, + }, + { + .n_bytes = 4096, + .tag_gcm_128 = { 0xe4afdad642876152, 0xf78cfcfcb92520b6 }, + .tag_gcm_256 = { 0x7552cda8d91bdab1, 0x4bf57b7567d59e89 }, + .tag_gmac_128 = { 0xac5240f8e9c49cfc, 0x2a3c9d0999aded50 }, + .tag_gmac_256 = { 0x9fb6cd8f10f7b6c5, 0x16e442c147869222 }, + }, + { + .n_bytes = 4112, + .tag_gcm_128 = { 0x2a34db8f06bcf0ee, 0x7a4a2456fa340c33 }, + .tag_gcm_256 = { 0x4b6c0c5b5c943f5e, 0x6d1669e849ce061a }, + .tag_gmac_128 = { 0x143bfc9ab07d9bb5, 0xf0aa7510a9039349 }, + .tag_gmac_256 = { 0x8a97bdd033775ba0, 0x5901a5160739be25 }, + }, + { + .n_bytes = 4113, + .tag_gcm_128 = { 0x296acfcbcbf529af, 0xe3e2cfb1bc5855c8 }, + .tag_gcm_256 = { 0x181f6f9068ea477e, 0x1e05bfd01ee3e173 }, + .tag_gmac_128 = { 0x0d81fcb0829e3c8b, 0x68016225b5fa7745 }, + .tag_gmac_256 = { 0xa2421ac50d65c6b5, 0x84bd16fa55486af8 }, + }, + { + .n_bytes = 16382, + .tag_gcm_128 = { 0xd39fd367e00a103d, 0xf873a278b32d207f }, + .tag_gcm_256 = { 0xa8da09a851ae6c88, 0x2ef17f0da7f191f1 }, + .tag_gmac_128 = { 0xd4a22896f44c1c14, 0x69a5d02715c90ea4 }, + .tag_gmac_256 = { 0x64788ca5e11722b6, 0x63d74a4b24538762 }, + }, + { + .n_bytes = 16383, + .tag_gcm_128 = { 0x2162b91aad49eebc, 0x28c7efe93e639c75 }, + .tag_gcm_256 = { 0xc5baee5e40004087, 0xf6b26211facc66a5 }, + .tag_gmac_128 = { 0x3ec003d690d3d846, 0x204baef851d8ad7d }, + .tag_gmac_256 = { 0xdb51d6f5dddf16bb, 0x529f3825cf78dbd5 }, + }, + { + .n_bytes = 16384, + .tag_gcm_128 = { 0x2272e778c4c5c9ef, 0x84c50021e75ddbab }, + .tag_gcm_256 = { 0x6c32f1c5666b1f4c, 0x91142a86ae5241b2 }, + .tag_gmac_128 = { 0x43dadd5ecee9674b, 0xa30fea9ae8091c6c }, + .tag_gmac_256 = { 0xc360b76ac1887181, 0xcb732f29ea86edeb }, + }, + { + .n_bytes = 16385, + .tag_gcm_128 = { 0xe2a47837578b4056, 0xf96e7233cbeb1ce1 }, + .tag_gcm_256 = { 0xfa3aa4ebe36fb390, 0x6a2cf1671f4f1a01 }, + .tag_gmac_128 = { 0xfd0b7312c4975687, 0xdd3096b1c850e80a }, + .tag_gmac_256 = { 0xaf2cae4642a5536a, 0xb27aff5cc8bd354c }, + }, + { + .n_bytes = 16386, + .tag_gcm_128 = { 0xe1b4c0e5825304ae, 0x48c5dd82aa114320 }, + .tag_gcm_256 = { 0x76c3612118f47fa8, 0xdd0a47b132ecad3a }, + .tag_gmac_128 = { 0x346bc841a7f5b642, 0x6fb1b96391c66b40 }, + .tag_gmac_256 = { 0x2f1a1b6a000e18b2, 0xf7cba25e02551d43 }, + }, +}; + +#define MAX_TEST_DATA_LEN 32768 + +static const struct +{ + char *name; + const u8 *pt, *key128, *key256, *ct128, *ct256, *tag128, *tag256, *aad, *iv; + u32 data_len, tag128_len, tag256_len, aad_len; +} test_cases[] = { + /* test cases */ + { + .name = "GCM Spec. TC1", + .iv = tc1_iv, + .key128 = tc1_key128, + .key256 = tc1_key256, + .tag128 = tc1_tag128, + .tag128_len = sizeof (tc1_tag128), + .tag256 = tc1_tag256, + .tag256_len = sizeof (tc1_tag256), + }, + { + .name = "GCM Spec. TC2", + .pt = tc2_plaintext, + .data_len = sizeof (tc2_plaintext), + .iv = tc1_iv, + .key128 = tc1_key128, + .key256 = tc1_key256, + .ct128 = tc2_ciphertext128, + .ct256 = tc2_ciphertext256, + .tag128 = tc2_tag128, + .tag128_len = sizeof (tc2_tag128), + .tag256 = tc2_tag256, + .tag256_len = sizeof (tc2_tag256), + }, + { + .name = "GCM Spec. TC3", + .pt = tc3_plaintext, + .data_len = sizeof (tc3_plaintext), + .iv = tc3_iv, + .key128 = tc3_key128, + .key256 = tc3_key256, + .ct128 = tc3_ciphertext128, + .ct256 = tc3_ciphertext256, + .tag128 = tc3_tag128, + .tag128_len = sizeof (tc3_tag128), + .tag256 = tc3_tag256, + .tag256_len = sizeof (tc3_tag256), + }, + { + .name = "GCM Spec. TC4", + .pt = tc4_plaintext, + .data_len = sizeof (tc4_plaintext), + .aad = tc4_aad, + .aad_len = sizeof (tc4_aad), + .iv = tc3_iv, + .key128 = tc3_key128, + .key256 = tc3_key256, + .ct128 = tc4_ciphertext128, + .ct256 = tc4_ciphertext256, + .tag128 = tc4_tag128, + .tag128_len = sizeof (tc4_tag128), + .tag256 = tc4_tag256, + .tag256_len = sizeof (tc4_tag256), + } +}; + +#define perftest_aesXXX_enc_var_sz(a) \ + void __test_perf_fn perftest_aes##a##_enc_var_sz (test_perf_t *tp) \ + { \ + u32 n = tp->n_ops; \ + aes_gcm_key_data_t *kd = test_mem_alloc (sizeof (*kd)); \ + u8 *dst = test_mem_alloc (n + 16); \ + u8 *src = test_mem_alloc_and_fill_inc_u8 (n + 16, 0, 0); \ + u8 *tag = test_mem_alloc (16); \ + u8 *key = test_mem_alloc_and_fill_inc_u8 (32, 192, 0); \ + u8 *iv = test_mem_alloc_and_fill_inc_u8 (16, 128, 0); \ + \ + clib_aes_gcm_key_expand (kd, key, AES_KEY_##a); \ + \ + test_perf_event_enable (tp); \ + clib_aes##a##_gcm_enc (kd, src, n, 0, 0, iv, 16, dst, tag); \ + test_perf_event_disable (tp); \ + } + +#define perftest_aesXXX_dec_var_sz(a) \ + void __test_perf_fn perftest_aes##a##_dec_var_sz (test_perf_t *tp) \ + { \ + u32 n = tp->n_ops; \ + aes_gcm_key_data_t *kd = test_mem_alloc (sizeof (*kd)); \ + u8 *dst = test_mem_alloc (n + 16); \ + u8 *src = test_mem_alloc_and_fill_inc_u8 (n + 16, 0, 0); \ + u8 *tag = test_mem_alloc (16); \ + u8 *key = test_mem_alloc_and_fill_inc_u8 (32, 192, 0); \ + u8 *iv = test_mem_alloc_and_fill_inc_u8 (16, 128, 0); \ + int *rv = test_mem_alloc (16); \ + \ + clib_aes_gcm_key_expand (kd, key, AES_KEY_##a); \ + \ + test_perf_event_enable (tp); \ + rv[0] = clib_aes##a##_gcm_dec (kd, src, n, 0, 0, iv, tag, 16, dst); \ + test_perf_event_disable (tp); \ + } + +static clib_error_t * +test_clib_aes128_gcm_enc (clib_error_t *err) +{ + aes_gcm_key_data_t kd; + u8 pt[MAX_TEST_DATA_LEN]; + u8 ct[MAX_TEST_DATA_LEN]; + u8 tag[16]; + + FOREACH_ARRAY_ELT (tc, test_cases) + { + clib_aes_gcm_key_expand (&kd, tc->key128, AES_KEY_128); + clib_aes128_gcm_enc (&kd, tc->pt, tc->data_len, tc->aad, tc->aad_len, + tc->iv, tc->tag128_len, ct, tag); + + if (memcmp (tc->tag128, tag, tc->tag128_len) != 0) + return clib_error_return (err, "%s: invalid tag", tc->name); + + if (tc->data_len && memcmp (tc->ct128, ct, tc->data_len) != 0) + return clib_error_return (err, "%s: invalid ciphertext", tc->name); + } + + for (int i = 0; i < sizeof (pt); i++) + pt[i] = i; + + clib_aes_gcm_key_expand (&kd, inc_key, AES_KEY_128); + FOREACH_ARRAY_ELT (tc, inc_test_cases) + { + clib_aes128_gcm_enc (&kd, pt, tc->n_bytes, 0, 0, inc_iv, 16, ct, tag); + + if (memcmp (tc->tag_gcm_128, tag, 16) != 0) + return clib_error_return (err, "incremental %u bytes: invalid tag", + tc->n_bytes); + } + + return err; +} + +perftest_aesXXX_enc_var_sz (128); + +REGISTER_TEST (clib_aes128_gcm_enc) = { + .name = "clib_aes128_gcm_enc", + .fn = test_clib_aes128_gcm_enc, + .perf_tests = PERF_TESTS ({ .name = "variable size (per byte)", + .n_ops = 1424, + .fn = perftest_aes128_enc_var_sz }, + { .name = "variable size (per byte)", + .n_ops = 1 << 20, + .fn = perftest_aes128_enc_var_sz }), +}; + +static clib_error_t * +test_clib_aes256_gcm_enc (clib_error_t *err) +{ + aes_gcm_key_data_t kd; + u8 pt[MAX_TEST_DATA_LEN]; + u8 ct[MAX_TEST_DATA_LEN]; + u8 tag[16]; + + FOREACH_ARRAY_ELT (tc, test_cases) + { + clib_aes_gcm_key_expand (&kd, tc->key256, AES_KEY_256); + clib_aes256_gcm_enc (&kd, tc->pt, tc->data_len, tc->aad, tc->aad_len, + tc->iv, tc->tag256_len, ct, tag); + + if (memcmp (tc->tag256, tag, tc->tag256_len) != 0) + return clib_error_return (err, "%s: invalid tag", tc->name); + + if (tc->data_len && memcmp (tc->ct256, ct, tc->data_len) != 0) + return clib_error_return (err, "%s: invalid ciphertext", tc->name); + } + + for (int i = 0; i < sizeof (pt); i++) + pt[i] = i; + + clib_aes_gcm_key_expand (&kd, inc_key, AES_KEY_256); + FOREACH_ARRAY_ELT (tc, inc_test_cases) + { + clib_aes256_gcm_enc (&kd, pt, tc->n_bytes, 0, 0, inc_iv, 16, ct, tag); + + if (memcmp (tc->tag_gcm_256, tag, 16) != 0) + return clib_error_return (err, "incremental %u bytes: invalid tag", + tc->n_bytes); + } + + return err; +} + +perftest_aesXXX_enc_var_sz (256); +REGISTER_TEST (clib_aes256_gcm_enc) = { + .name = "clib_aes256_gcm_enc", + .fn = test_clib_aes256_gcm_enc, + .perf_tests = PERF_TESTS ({ .name = "variable size (per byte)", + .n_ops = 1424, + .fn = perftest_aes256_enc_var_sz }, + { .name = "variable size (per byte)", + .n_ops = 1 << 20, + .fn = perftest_aes256_enc_var_sz }), +}; + +static clib_error_t * +test_clib_aes128_gcm_dec (clib_error_t *err) +{ + aes_gcm_key_data_t kd; + u8 pt[MAX_TEST_DATA_LEN]; + u8 ct[MAX_TEST_DATA_LEN]; + u8 tag[16]; + int rv; + + FOREACH_ARRAY_ELT (tc, test_cases) + { + clib_aes_gcm_key_expand (&kd, tc->key128, AES_KEY_128); + rv = clib_aes128_gcm_dec (&kd, tc->ct128, tc->data_len, tc->aad, + tc->aad_len, tc->iv, tc->tag128, + tc->tag128_len, pt); + + if (!rv) + return clib_error_return (err, "%s: invalid tag", tc->name); + + if (tc->data_len && memcmp (tc->pt, pt, tc->data_len) != 0) + return clib_error_return (err, "%s: invalid ciphertext", tc->name); + } + + for (int i = 0; i < sizeof (pt); i++) + pt[i] = i; + + clib_aes_gcm_key_expand (&kd, inc_key, AES_KEY_128); + clib_aes128_gcm_enc (&kd, pt, sizeof (ct), 0, 0, inc_iv, 16, ct, tag); + + FOREACH_ARRAY_ELT (tc, inc_test_cases) + { + if (!clib_aes128_gcm_dec (&kd, ct, tc->n_bytes, 0, 0, inc_iv, + (u8 *) tc->tag_gcm_128, 16, pt)) + return clib_error_return (err, "incremental %u bytes: invalid tag", + tc->n_bytes); + } + + return err; +} + +perftest_aesXXX_dec_var_sz (128); + +REGISTER_TEST (clib_aes128_gcm_dec) = { + .name = "clib_aes128_gcm_dec", + .fn = test_clib_aes128_gcm_dec, + .perf_tests = PERF_TESTS ({ .name = "variable size (per byte)", + .n_ops = 1424, + .fn = perftest_aes128_dec_var_sz }, + { .name = "variable size (per byte)", + .n_ops = 1 << 20, + .fn = perftest_aes128_dec_var_sz }), +}; + +static clib_error_t * +test_clib_aes256_gcm_dec (clib_error_t *err) +{ + aes_gcm_key_data_t kd; + u8 pt[MAX_TEST_DATA_LEN]; + u8 ct[MAX_TEST_DATA_LEN]; + u8 tag[16]; + int rv; + + FOREACH_ARRAY_ELT (tc, test_cases) + { + clib_aes_gcm_key_expand (&kd, tc->key256, AES_KEY_256); + rv = clib_aes256_gcm_dec (&kd, tc->ct256, tc->data_len, tc->aad, + tc->aad_len, tc->iv, tc->tag256, + tc->tag256_len, pt); + + if (!rv) + return clib_error_return (err, "%s: invalid tag", tc->name); + + if (tc->data_len && memcmp (tc->pt, pt, tc->data_len) != 0) + return clib_error_return (err, "%s: invalid ciphertext", tc->name); + } + + for (int i = 0; i < sizeof (pt); i++) + pt[i] = i; + + clib_aes_gcm_key_expand (&kd, inc_key, AES_KEY_128); + clib_aes128_gcm_enc (&kd, pt, sizeof (ct), 0, 0, inc_iv, 16, ct, tag); + + FOREACH_ARRAY_ELT (tc, inc_test_cases) + { + if (!clib_aes128_gcm_dec (&kd, ct, tc->n_bytes, 0, 0, inc_iv, + (u8 *) tc->tag_gcm_128, 16, pt)) + return clib_error_return (err, "incremental %u bytes: invalid tag", + tc->n_bytes); + } + + return err; +} + +perftest_aesXXX_dec_var_sz (256); +REGISTER_TEST (clib_aes256_gcm_dec) = { + .name = "clib_aes256_gcm_dec", + .fn = test_clib_aes256_gcm_dec, + .perf_tests = PERF_TESTS ({ .name = "variable size (per byte)", + .n_ops = 1424, + .fn = perftest_aes256_dec_var_sz }, + { .name = "variable size (per byte)", + .n_ops = 1 << 20, + .fn = perftest_aes256_dec_var_sz }), +}; + +static const u8 gmac1_key[] = { + 0x77, 0xbe, 0x63, 0x70, 0x89, 0x71, 0xc4, 0xe2, + 0x40, 0xd1, 0xcb, 0x79, 0xe8, 0xd7, 0x7f, 0xeb +}; +static const u8 gmac1_iv[] = { 0xe0, 0xe0, 0x0f, 0x19, 0xfe, 0xd7, + 0xba, 0x01, 0x36, 0xa7, 0x97, 0xf3 }; +static const u8 gmac1_aad[] = { + 0x7a, 0x43, 0xec, 0x1d, 0x9c, 0x0a, 0x5a, 0x78, + 0xa0, 0xb1, 0x65, 0x33, 0xa6, 0x21, 0x3c, 0xab +}; +static const u8 gmac1_tag[] = { + 0x20, 0x9f, 0xcc, 0x8d, 0x36, 0x75, 0xed, 0x93, + 0x8e, 0x9c, 0x71, 0x66, 0x70, 0x9d, 0xd9, 0x46 +}; + +static const u8 gmac2_key[] = { + 0x20, 0xb5, 0xb6, 0xb8, 0x54, 0xe1, 0x87, 0xb0, + 0x58, 0xa8, 0x4d, 0x57, 0xbc, 0x15, 0x38, 0xb6 +}; + +static const u8 gmac2_iv[] = { 0x94, 0xc1, 0x93, 0x5a, 0xfc, 0x06, + 0x1c, 0xbf, 0x25, 0x4b, 0x93, 0x6f }; + +static const u8 gmac2_aad[] = { + 0xca, 0x41, 0x8e, 0x71, 0xdb, 0xf8, 0x10, 0x03, 0x81, 0x74, 0xea, 0xa3, 0x71, + 0x9b, 0x3f, 0xcb, 0x80, 0x53, 0x1c, 0x71, 0x10, 0xad, 0x91, 0x92, 0xd1, 0x05, + 0xee, 0xaa, 0xfa, 0x15, 0xb8, 0x19, 0xac, 0x00, 0x56, 0x68, 0x75, 0x2b, 0x34, + 0x4e, 0xd1, 0xb2, 0x2f, 0xaf, 0x77, 0x04, 0x8b, 0xaf, 0x03, 0xdb, 0xdd, 0xb3, + 0xb4, 0x7d, 0x6b, 0x00, 0xe9, 0x5c, 0x4f, 0x00, 0x5e, 0x0c, 0xc9, 0xb7, 0x62, + 0x7c, 0xca, 0xfd, 0x3f, 0x21, 0xb3, 0x31, 0x2a, 0xa8, 0xd9, 0x1d, 0x3f, 0xa0, + 0x89, 0x3f, 0xe5, 0xbf, 0xf7, 0xd4, 0x4c, 0xa4, 0x6f, 0x23, 0xaf, 0xe0 +}; + +static const u8 gmac2_tag[] = { + 0xb3, 0x72, 0x86, 0xeb, 0xaf, 0x4a, 0x54, 0xe0, + 0xff, 0xc2, 0xa1, 0xde, 0xaf, 0xc9, 0xf6, 0xdb +}; + +static const struct +{ + char *name; + const u8 *key128, *key256, *tag128, *tag256, *aad, *iv; + u32 tag128_len, tag256_len, aad_len; +} gmac_test_cases[] = { + /* test cases */ + { + .name = "GMAC1", + .iv = gmac1_iv, + .key128 = gmac1_key, + .tag128 = gmac1_tag, + .tag128_len = sizeof (gmac1_tag), + .aad = gmac1_aad, + .aad_len = sizeof (gmac1_aad), + }, + { + .name = "GMAC2", + .iv = gmac2_iv, + .key128 = gmac2_key, + .tag128 = gmac2_tag, + .tag128_len = sizeof (gmac2_tag), + .aad = gmac2_aad, + .aad_len = sizeof (gmac2_aad), + }, +}; + +static clib_error_t * +test_clib_aes128_gmac (clib_error_t *err) +{ + u8 data[MAX_TEST_DATA_LEN]; + aes_gcm_key_data_t kd; + u8 tag[16]; + + FOREACH_ARRAY_ELT (tc, gmac_test_cases) + { + clib_aes_gcm_key_expand (&kd, tc->key128, AES_KEY_128); + clib_aes128_gmac (&kd, tc->aad, tc->aad_len, tc->iv, tc->tag128_len, + tag); + + if (memcmp (tc->tag128, tag, tc->tag128_len) != 0) + return clib_error_return (err, "%s: invalid tag", tc->name); + } + + for (int i = 0; i < sizeof (data); i++) + data[i] = i; + + clib_aes_gcm_key_expand (&kd, inc_key, AES_KEY_128); + FOREACH_ARRAY_ELT (tc, inc_test_cases) + { + clib_aes128_gmac (&kd, data, tc->n_bytes, inc_iv, 16, tag); + + if (memcmp (tc->tag_gmac_128, tag, 16) != 0) + return clib_error_return (err, "incremental %u bytes: invalid tag", + tc->n_bytes); + } + + return err; +} + +void __test_perf_fn +perftest_gmac256_fixed_512byte (test_perf_t *tp) +{ + uword n = tp->n_ops; + aes_gcm_key_data_t *kd = test_mem_alloc (sizeof (aes_gcm_key_data_t)); + u8 *ivs = test_mem_alloc_and_fill_inc_u8 (n * 12, 0, 0); + u8 *tags = test_mem_alloc_and_fill_inc_u8 (8 + n * 16, 0, 0); + u8 *data = test_mem_alloc_and_fill_inc_u8 (512, 0, 0); + + test_perf_event_enable (tp); + clib_aes_gcm_key_expand (kd, inc_key, AES_KEY_128); + + for (int i = 0; i < n; i++) + clib_aes128_gmac (kd, data, 512, ivs + n * 12, 16, tags + n * 16); + test_perf_event_disable (tp); +} + +REGISTER_TEST (clib_aes128_gmac) = { + .name = "clib_aes128_gmac", + .fn = test_clib_aes128_gmac, + .perf_tests = PERF_TESTS ({ .name = "fixed (512 byte)", + .n_ops = 256, + .fn = perftest_gmac256_fixed_512byte }), +}; + +static clib_error_t * +test_clib_aes256_gmac (clib_error_t *err) +{ + u8 data[MAX_TEST_DATA_LEN]; + aes_gcm_key_data_t kd; + u8 tag[16]; + +#if 0 + FOREACH_ARRAY_ELT (tc, gmac_test_cases) + { + clib_aes_gcm_key_expand (&kd, tc->key256, AES_KEY_256); + clib_aes256_gmac (&kd, tc->aad, tc->aad_len, tc->iv, tc->tag256_len, + tag); + + if (memcmp (tc->tag256, tag, tc->tag256_len) != 0) + return clib_error_return (err, "%s: invalid tag", tc->name); + } +#endif + + for (int i = 0; i < sizeof (data); i++) + data[i] = i; + + clib_aes_gcm_key_expand (&kd, inc_key, AES_KEY_256); + FOREACH_ARRAY_ELT (tc, inc_test_cases) + { + clib_aes256_gmac (&kd, data, tc->n_bytes, inc_iv, 16, tag); + + if (memcmp (tc->tag_gmac_256, tag, 16) != 0) + return clib_error_return (err, "incremental %u bytes: invalid tag", + tc->n_bytes); + } + + return err; +} + +REGISTER_TEST (clib_aes256_gmac) = { + .name = "clib_aes256_gmac", + .fn = test_clib_aes256_gmac, +}; +#endif diff --git a/src/vppinfra/test/array_mask.c b/src/vppinfra/test/array_mask.c new file mode 100644 index 00000000000..4d8fc7c59e2 --- /dev/null +++ b/src/vppinfra/test/array_mask.c @@ -0,0 +1,145 @@ +/* SPDX-License-Identifier: Apache-2.0 + * Copyright(c) 2021 Cisco Systems, Inc. + */ + +#include <vppinfra/format.h> +#include <vppinfra/test/test.h> +#include <vppinfra/vector/array_mask.h> + +__test_funct_fn void +clib_array_mask_u32_wrapper (u32 *src, u32 mask, u32 n_elts) +{ + clib_array_mask_u32 (src, mask, n_elts); +} + +typedef struct +{ + u32 mask; + u32 expected[256]; +} array_mask_test_t; + +static array_mask_test_t tests[] = { + /* mask values 0x1, output array of alternating 0 1 0 1 .. */ + { .mask = 1, + .expected = { 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 } }, + /* mask values 0xFFFFFFFF, output array of 0, 1, 2, .., 255 */ + { .mask = ~0U, + .expected = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, + 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255 } }, + /* mask values 0xF, output array of 0, .., 15, 0, .., 15, 0, .., 15 */ + { .mask = 15, + .expected = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } }, + /* mask values 0x1, output array of 1, 0, 1, 0,.. */ + { .mask = 1, .expected = { 1, 0, 1, 0, 1, 0, 1, 0, 1, 0 } }, +}; + +static clib_error_t * +test_clib_array_mask_u32 (clib_error_t *err) +{ + u32 i, j, len; + for (i = 0; i < ARRAY_LEN (tests) - 1; i++) + { + u32 src[256]; + for (j = 0; j < ARRAY_LEN (src); j++) + src[j] = j; + + array_mask_test_t *t = tests + i; + clib_array_mask_u32_wrapper (src, t->mask, ARRAY_LEN (src)); + for (j = 0; j < ARRAY_LEN (src); j++) + { + if (src[j] != t->expected[j]) + return clib_error_return (err, + "testcase %u failed at " + "(src[%u] = 0x%x, expected 0x%x)", + i, j, src[j], t->expected[j]); + } + } + + for (i = 0; i < ARRAY_LEN (tests) - 1; i++) + { + for (len = 1; len <= 256; len++) + { + u32 src[len]; + for (j = 0; j < ARRAY_LEN (src); j++) + src[j] = j; + + array_mask_test_t *t = tests + i; + clib_array_mask_u32_wrapper (src, t->mask, ARRAY_LEN (src)); + for (j = 0; j < ARRAY_LEN (src); j++) + { + if (src[j] != t->expected[j]) + return clib_error_return (err, + "testcase %u failed at " + "(src[%u] = 0x%x, expected 0x%x)", + i, j, src[j], t->expected[j]); + } + } + } + + u32 src[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; + array_mask_test_t *t = tests + i; + + clib_array_mask_u32_wrapper (src, t->mask, ARRAY_LEN (src)); + for (j = 0; j < ARRAY_LEN (src); j++) + { + if (src[j] != t->expected[j]) + return clib_error_return (err, + "testcase %u failed at " + "(src[%u] = 0x%x, expected 0x%x)", + i, j, src[j], t->expected[j]); + } + + return err; +} + +REGISTER_TEST (clib_array_mask_u32) = { + .name = "clib_array_mask_u32", + .fn = test_clib_array_mask_u32, +}; diff --git a/src/vppinfra/test/compress.c b/src/vppinfra/test/compress.c new file mode 100644 index 00000000000..083065f9bda --- /dev/null +++ b/src/vppinfra/test/compress.c @@ -0,0 +1,266 @@ +/* SPDX-License-Identifier: Apache-2.0 + * Copyright(c) 2021 Cisco Systems, Inc. + */ + +#include <vppinfra/format.h> +#include <vppinfra/test/test.h> +#include <vppinfra/vector/compress.h> + +__test_funct_fn u32 +clib_compress_u64_wrapper (u64 *dst, u64 *src, u64 *mask, u32 n_elts) +{ + return clib_compress_u64 (dst, src, mask, n_elts); +} + +__test_funct_fn u32 +clib_compress_u32_wrapper (u32 *dst, u32 *src, u64 *mask, u32 n_elts) +{ + return clib_compress_u32 (dst, src, mask, n_elts); +} + +__test_funct_fn u32 +clib_compress_u16_wrapper (u16 *dst, u16 *src, u64 *mask, u32 n_elts) +{ + return clib_compress_u16 (dst, src, mask, n_elts); +} + +__test_funct_fn u32 +clib_compress_u8_wrapper (u8 *dst, u8 *src, u64 *mask, u32 n_elts) +{ + return clib_compress_u8 (dst, src, mask, n_elts); +} + +typedef struct +{ + u64 mask[10]; + u32 n_elts; +} compress_test_t; + +static compress_test_t tests[] = { + { .mask = { 1 }, .n_elts = 1 }, + { .mask = { 2 }, .n_elts = 2 }, + { .mask = { 3 }, .n_elts = 2 }, + { .mask = { 0, 1 }, .n_elts = 66 }, + { .mask = { 0, 2 }, .n_elts = 69 }, + { .mask = { 0, 3 }, .n_elts = 66 }, + { .mask = { ~0ULL, ~0ULL, ~0ULL, ~0ULL }, .n_elts = 62 }, + { .mask = { ~0ULL, ~0ULL, ~0ULL, ~0ULL }, .n_elts = 255 }, + { .mask = { ~0ULL, 1, 1, ~0ULL }, .n_elts = 256 }, +}; + +static clib_error_t * +test_clib_compress_u64 (clib_error_t *err) +{ + u32 i, j; + + for (i = 0; i < ARRAY_LEN (tests); i++) + { + compress_test_t *t = tests + i; + u64 src[t->n_elts]; +#ifdef CLIB_SANITIZE_ADDR + u64 dst[t->n_elts]; +#else /* CLIB_SANITIZE_ADDR */ + u64 dst[513]; +#endif /* CLIB_SANITIZE_ADDR */ + u64 *dp = dst; + u32 r; + for (j = 0; j < t->n_elts; j++) + src[j] = j; + + for (j = 0; j < ARRAY_LEN (dst); j++) + dst[j] = 0xa5a5a5a5a5a5a5a5; + + r = clib_compress_u64_wrapper (dst, src, t->mask, t->n_elts); + + for (j = 0; j < t->n_elts; j++) + { + if ((t->mask[j >> 6] & (1ULL << (j & 0x3f))) == 0) + continue; + if (dp[0] != src[j]) + return clib_error_return (err, + "wrong data in testcase %u at " + "(dst[%u] = 0x%lx, src[%u] = 0x%lx)", + i, dp - dst, dp[0], j, src[j]); + dp++; + } + +#ifndef CLIB_SANITIZE_ADDR + if (dst[dp - dst + 1] != 0xa5a5a5a5a5a5a5a5) + return clib_error_return (err, "buffer overrun in testcase %u", i); +#endif /* CLIB_SANITIZE_ADDR */ + + if (dp - dst != r) + return clib_error_return (err, "wrong number of elts in testcase %u", + i); + } + + return err; +} + +static clib_error_t * +test_clib_compress_u32 (clib_error_t *err) +{ + u32 i, j; + + for (i = 0; i < ARRAY_LEN (tests); i++) + { + compress_test_t *t = tests + i; + u32 src[t->n_elts]; +#ifdef CLIB_SANITIZE_ADDR + u32 dst[t->n_elts]; +#else /* CLIB_SANITIZE_ADDR */ + u32 dst[513]; +#endif /* CLIB_SANITIZE_ADDR */ + u32 *dp = dst; + u32 r; + for (j = 0; j < t->n_elts; j++) + src[j] = j; + + for (j = 0; j < ARRAY_LEN (dst); j++) + dst[j] = 0xa5a5a5a5; + + r = clib_compress_u32_wrapper (dst, src, t->mask, t->n_elts); + + for (j = 0; j < t->n_elts; j++) + { + if ((t->mask[j >> 6] & (1ULL << (j & 0x3f))) == 0) + continue; + + if (dp[0] != src[j]) + return clib_error_return (err, + "wrong data in testcase %u at " + "(dst[%u] = 0x%x, src[%u] = 0x%x)", + i, dp - dst, dp[0], j, src[j]); + dp++; + } + +#ifndef CLIB_SANITIZE_ADDR + if (dst[dp - dst + 1] != 0xa5a5a5a5) + return clib_error_return (err, "buffer overrun in testcase %u", i); +#endif /* CLIB_SANITIZE_ADDR */ + + if (dp - dst != r) + return clib_error_return (err, "wrong number of elts in testcase %u", + i); + } + + return err; +} + +static clib_error_t * +test_clib_compress_u16 (clib_error_t *err) +{ + u32 i, j; + + for (i = 0; i < ARRAY_LEN (tests); i++) + { + compress_test_t *t = tests + i; + u16 src[t->n_elts]; +#ifdef CLIB_SANITIZE_ADDR + u16 dst[t->n_elts]; +#else /* CLIB_SANITIZE_ADDR */ + u16 dst[513]; +#endif /* CLIB_SANITIZE_ADDR */ + u16 *dp = dst; + u32 r; + for (j = 0; j < t->n_elts; j++) + src[j] = j; + + for (j = 0; j < ARRAY_LEN (dst); j++) + dst[j] = 0xa5a5; + + r = clib_compress_u16_wrapper (dst, src, t->mask, t->n_elts); + + for (j = 0; j < t->n_elts; j++) + { + if ((t->mask[j >> 6] & (1ULL << (j & 0x3f))) == 0) + continue; + if (dp[0] != src[j]) + return clib_error_return (err, + "wrong data in testcase %u at " + "(dst[%u] = 0x%x, src[%u] = 0x%x)", + i, dp - dst, dp[0], j, src[j]); + dp++; + } + +#ifndef CLIB_SANITIZE_ADDR + if (dst[dp - dst + 1] != 0xa5a5) + return clib_error_return (err, "buffer overrun in testcase %u", i); +#endif /* CLIB_SANITIZE_ADDR */ + + if (dp - dst != r) + return clib_error_return (err, "wrong number of elts in testcase %u", + i); + } + + return err; +} + +static clib_error_t * +test_clib_compress_u8 (clib_error_t *err) +{ + u32 i, j; + + for (i = 0; i < ARRAY_LEN (tests); i++) + { + compress_test_t *t = tests + i; + u8 src[t->n_elts]; +#ifdef CLIB_SANITIZE_ADDR + u8 dst[t->n_elts]; +#else /* CLIB_SANITIZE_ADDR */ + u8 dst[513]; +#endif /* CLIB_SANITIZE_ADDR */ + u8 *dp = dst; + u32 r; + for (j = 0; j < t->n_elts; j++) + src[j] = j; + + for (j = 0; j < ARRAY_LEN (dst); j++) + dst[j] = 0xa5; + + r = clib_compress_u8_wrapper (dst, src, t->mask, t->n_elts); + + for (j = 0; j < t->n_elts; j++) + { + if ((t->mask[j >> 6] & (1ULL << (j & 0x3f))) == 0) + continue; + if (dp[0] != src[j]) + return clib_error_return (err, + "wrong data in testcase %u at " + "(dst[%u] = 0x%x, src[%u] = 0x%x)", + i, dp - dst, dp[0], j, src[j]); + dp++; + } + +#ifndef CLIB_SANITIZE_ADDR + if (dst[dp - dst + 1] != 0xa5) + return clib_error_return (err, "buffer overrun in testcase %u", i); +#endif /* CLIB_SANITIZE_ADDR */ + + if (dp - dst != r) + return clib_error_return (err, "wrong number of elts in testcase %u", + i); + } + + return err; +} + +REGISTER_TEST (clib_compress_u64) = { + .name = "clib_compress_u64", + .fn = test_clib_compress_u64, +}; + +REGISTER_TEST (clib_compress_u32) = { + .name = "clib_compress_u32", + .fn = test_clib_compress_u32, +}; + +REGISTER_TEST (clib_compress_u16) = { + .name = "clib_compress_u16", + .fn = test_clib_compress_u16, +}; + +REGISTER_TEST (clib_compress_u8) = { + .name = "clib_compress_u8", + .fn = test_clib_compress_u8, +}; diff --git a/src/vppinfra/test/count_equal.c b/src/vppinfra/test/count_equal.c new file mode 100644 index 00000000000..942c2203d3d --- /dev/null +++ b/src/vppinfra/test/count_equal.c @@ -0,0 +1,104 @@ +/* SPDX-License-Identifier: Apache-2.0 + * Copyright(c) 2021 Cisco Systems, Inc. + */ + +#include <vppinfra/format.h> +#include <vppinfra/test/test.h> +#include <vppinfra/vector/count_equal.h> + +#define foreach_clib_count_equal(type) \ + typedef uword (wrapper_fn_##type) (type * a, uword maxcount); \ + \ + __test_funct_fn uword clib_count_equal_##type##_wrapper (type *a, \ + uword maxcount) \ + { \ + return clib_count_equal_##type (a, maxcount); \ + } \ + \ + static wrapper_fn_##type *wfn_##type = &clib_count_equal_##type##_wrapper; \ + static clib_error_t *test_clib_count_equal_##type (clib_error_t *err) \ + { \ + u32 ps = clib_mem_get_log2_page_size (); \ + void *map; \ + \ + u16 lengths[] = { \ + 1, 2, 3, 5, 7, 9, 15, 16, 17, 31, 32, 33, 255, 256, 257 \ + }; \ + type *data; \ + \ + map = clib_mem_vm_map (0, 2ULL << ps, ps, "test"); \ + if (map == CLIB_MEM_VM_MAP_FAILED) \ + return clib_error_return (err, "clib_mem_vm_map failed"); \ + \ + data = ((type *) (map + (1ULL << ps))); \ + data[-1] = 0xfe; \ + \ + mprotect (data, 1ULL < ps, PROT_NONE); \ + \ + for (u8 d = 0; d < 255; d++) \ + { \ + for (int i = 1; i <= (1 << ps) / sizeof (data[0]); i++) \ + data[-i] = d; \ + for (int i = 0; i < ARRAY_LEN (lengths); i++) \ + { \ + uword rv, len = lengths[i]; \ + \ + if ((rv = wfn_##type (data - len, len)) != len) \ + { \ + err = clib_error_return ( \ + err, "testcase 1 failed for len %u data %u(rv %u)", len, d, \ + rv); \ + goto done; \ + } \ + \ + data[-1] = d + 1; \ + if (len > 1 && ((rv = wfn_##type (data - len, len)) != len - 1)) \ + { \ + err = clib_error_return ( \ + err, "testcase 2 failed for len %u data %u (rv %u)", len, \ + d, rv); \ + goto done; \ + } \ + data[-1] = d; \ + \ + data[-2] = d + 1; \ + if (len > 2 && ((rv = wfn_##type (data - len, len)) != len - 2)) \ + { \ + err = clib_error_return ( \ + err, "testcase 3 failed for len %u data %u (rv %u)", len, \ + d, rv); \ + goto done; \ + } \ + data[-2] = d; \ + } \ + } \ + \ + done: \ + clib_mem_vm_unmap (map); \ + return err; \ + } + +foreach_clib_count_equal (u8); +foreach_clib_count_equal (u16); +foreach_clib_count_equal (u32); +foreach_clib_count_equal (u64); + +REGISTER_TEST (clib_count_equal_u8) = { + .name = "clib_count_equal_u8", + .fn = test_clib_count_equal_u8, +}; + +REGISTER_TEST (clib_count_equal_u16) = { + .name = "clib_count_equal_u16", + .fn = test_clib_count_equal_u16, +}; + +REGISTER_TEST (clib_count_equal_u32) = { + .name = "clib_count_equal_u32", + .fn = test_clib_count_equal_u32, +}; + +REGISTER_TEST (clib_count_equal_u64) = { + .name = "clib_count_equal_u64", + .fn = test_clib_count_equal_u64, +}; diff --git a/src/vppinfra/test/crc32c.c b/src/vppinfra/test/crc32c.c new file mode 100644 index 00000000000..8c0c691e2e8 --- /dev/null +++ b/src/vppinfra/test/crc32c.c @@ -0,0 +1,54 @@ +/* SPDX-License-Identifier: Apache-2.0 + * Copyright(c) 2021 Cisco Systems, Inc. + */ + +#include <vppinfra/format.h> +#include <vppinfra/test/test.h> +#include <vppinfra/crc32.h> + +#ifndef CLIB_MARCH_VARIANT +char *crc32c_test_string = + "The quick brown fox jumped over the lazy dog and stumbled."; +u32 crc32c_test_values_data[] = { + 0x00000000, 0x96bf4dcc, 0x65479df4, 0x60a63889, 0xda99c852, 0x3337e4e2, + 0x4651af18, 0x83b586a1, 0x2235e3b5, 0x7f896b6f, 0x1f17a8f3, 0x60dc68bc, + 0x6f95458b, 0x24c5aa40, 0xe40de8f0, 0x3e344ed8, 0x798903f4, 0x73ea05e3, + 0xcfc61ead, 0xe6ed33a9, 0xfaa20d87, 0x5ce246c4, 0x4022138c, 0x111b090a, + 0x1a6b673c, 0x298d6a78, 0x5d3485d5, 0xc6c24fec, 0x91600ac3, 0x877506df, + 0xd9702ff7, 0xb7de5f4b, 0xf8f8e606, 0x905bdc1c, 0xb69298ce, 0x3b748c05, + 0x1577ee4e, 0xc19389c7, 0x842bc1c7, 0x0db915db, 0x437d7c44, 0xa61f7901, + 0x54919807, 0xeb4b5a35, 0xb0f5e17e, 0xfded9015, 0xb6ff2e82, 0xaec598e4, + 0x8258fee0, 0xc30f7e3a, 0x390ac90e, 0x1a4376fc, 0xfa5ea3c2, 0xfca2d721, + 0x52d74c9f, 0xe06c4bcd, 0x28728122, 0x67f288d5, 0 +}; +u32 *crc32c_test_values = crc32c_test_values_data; + +#else +extern char *crc32c_test_string; +extern u32 *crc32c_test_values; +#endif + +static clib_error_t * +test_clib_crc32c (clib_error_t *err) +{ + int max_len = strlen (crc32c_test_string); + int i; + for (i = 0; i < max_len; i++) + { + u32 expected_crc32c = crc32c_test_values[i]; + u32 calculated_crc32 = clib_crc32c ((u8 *) crc32c_test_string, i); + if (expected_crc32c != calculated_crc32) + { + return clib_error_return ( + err, + "Bad CRC32C for test case %d: expected 0x%08x, calculated: 0x%08x", + i, expected_crc32c, calculated_crc32); + } + } + return err; +} + +REGISTER_TEST (clib_crc32c) = { + .name = "clib_crc32c", + .fn = test_clib_crc32c, +}; diff --git a/src/vppinfra/test/index_to_ptr.c b/src/vppinfra/test/index_to_ptr.c new file mode 100644 index 00000000000..06b621c10ff --- /dev/null +++ b/src/vppinfra/test/index_to_ptr.c @@ -0,0 +1,58 @@ +/* SPDX-License-Identifier: Apache-2.0 + * Copyright(c) 2021 Cisco Systems, Inc. + */ + +#include <vppinfra/format.h> +#include <vppinfra/test/test.h> +#include <vppinfra/vector/index_to_ptr.h> + +typedef void (wrapper_fn) (u32 *indices, void *base, u8 shift, void **ptrs, + u32 n_elts); + +__test_funct_fn void +clib_index_to_ptr_u32_wrapper (u32 *indices, void *base, u8 shift, void **ptrs, + u32 n_elts) +{ + clib_index_to_ptr_u32 (indices, base, shift, ptrs, n_elts); +} + +static wrapper_fn *wfn = &clib_index_to_ptr_u32_wrapper; + +static clib_error_t * +test_clib_index_to_ptr_u32 (clib_error_t *err) +{ + void *_ptrs[512 + 128], **ptrs = _ptrs + 64; + u32 _indices[512 + 128], *indices = _indices + 64; + u16 lengths[] = { 1, 3, 5, 7, 9, 15, 16, 17, 31, 32, + 33, 40, 41, 42, 63, 64, 65, 511, 512 }; + + for (int i = 0; i < ARRAY_LEN (_indices); i++) + _indices[i] = i; + + for (int i = 0; i < ARRAY_LEN (lengths); i++) + { + u16 len = lengths[i]; + u8 shift = 6; + void *base = (void *) 0x100000000 + i; + + for (int j = -64; j < len + 64; j++) + ptrs[j] = (void *) 0xfefefefefefefefe; + + wfn (indices, base, shift, ptrs, len); + for (int j = 0; j < len; j++) + { + void *expected = base + ((u64) indices[j] << shift); + if (ptrs[j] != expected) + return clib_error_return (err, + "testcase failed for length %u " + "(offset %u, expected %p, found %p)", + len, j, expected, ptrs[j]); + } + } + return err; +} + +REGISTER_TEST (clib_index_to_ptr_u32) = { + .name = "clib_index_to_ptr_u32", + .fn = test_clib_index_to_ptr_u32, +}; diff --git a/src/vppinfra/test/ip_csum.c b/src/vppinfra/test/ip_csum.c new file mode 100644 index 00000000000..b8508ee449d --- /dev/null +++ b/src/vppinfra/test/ip_csum.c @@ -0,0 +1,169 @@ +/* SPDX-License-Identifier: Apache-2.0 + * Copyright(c) 2021 Cisco Systems, Inc. + */ + +#include <vppinfra/format.h> +#include <vppinfra/test/test.h> +#include <vppinfra/vector/ip_csum.h> + +typedef struct +{ + struct + { + u8 *src; + u32 count; + } chunk[5]; + u16 result; +} ip_csum_test_t; + +static u8 test1[] = { 0x45, 0x00, 0x00, 0x73, 0x00, 0x00, 0x40, + 0x00, 0x40, 0x11, 0x00, 0x00, 0xc0, 0xa8, + 0x00, 0x01, 0xc0, 0xa8, 0x00, 0xc7, 0x00 }; +#define TEST_LEN(x) (ARRAY_LEN (x) - 1) + +static ip_csum_test_t tests[] = { { + .chunk[0].src = test1, + .chunk[0].count = TEST_LEN (test1), + .result = 0x61b8, + }, + { + .chunk[0].src = test1, + .chunk[0].count = 1, + .chunk[1].src = test1 + 1, + .chunk[1].count = 2, + .chunk[2].src = test1 + 3, + .chunk[2].count = 3, + .chunk[3].src = test1 + 6, + .chunk[3].count = 4, + .chunk[4].src = test1 + 10, + .chunk[4].count = TEST_LEN (test1) - 10, + .result = 0x61b8, + }, + { + .chunk[0].count = 1, + .result = 0xff0f, + }, + { + .chunk[0].count = 2, + .result = 0x080f, + }, + { + .chunk[0].count = 3, + .result = 0x0711, + }, + { + .chunk[0].count = 4, + .result = 0x1210, + }, + { + .chunk[0].count = 63, + .result = 0xda01, + }, + { + .chunk[0].count = 64, + .result = 0xe100, + }, + { + .chunk[0].count = 65, + .result = 0xe010, + }, + { + .chunk[0].count = 65535, + .result = 0xfc84, + }, + { + .chunk[0].count = 65536, + .result = 0xffff, + } }; + +static clib_error_t * +test_clib_ip_csum (clib_error_t *err) +{ + u8 *buf; + buf = test_mem_alloc (65536); + for (int i = 0; i < 65536; i++) + buf[i] = 0xf0 + ((i * 7) & 0xf); + + for (int i = 0; i < ARRAY_LEN (tests); i++) + { + clib_ip_csum_t c = {}; + ip_csum_test_t *t = tests + i; + u16 rv; + + for (int j = 0; j < ARRAY_LEN (((ip_csum_test_t *) 0)->chunk); j++) + if (t->chunk[j].count > 0) + { + if (t->chunk[j].src == 0) + clib_ip_csum_chunk (&c, buf, t->chunk[j].count); + else + clib_ip_csum_chunk (&c, t->chunk[j].src, t->chunk[j].count); + } + rv = clib_ip_csum_fold (&c); + + if (rv != tests[i].result) + { + err = clib_error_return (err, + "bad checksum in test case %u (expected " + "0x%04x, calculated 0x%04x)", + i, tests[i].result, rv); + goto done; + } + } +done: + return err; +} + +void __test_perf_fn +perftest_ip4_hdr (test_perf_t *tp) +{ + u32 n = tp->n_ops; + u8 *data = test_mem_alloc_and_splat (20, n, (void *) &test1); + u16 *res = test_mem_alloc (n * sizeof (u16)); + + test_perf_event_enable (tp); + for (int i = 0; i < n; i++) + res[i] = clib_ip_csum (data + i * 20, 20); + test_perf_event_disable (tp); +} + +void __test_perf_fn +perftest_tcp_payload (test_perf_t *tp) +{ + u32 n = tp->n_ops; + volatile uword *lenp = &tp->arg0; + u8 *data = test_mem_alloc_and_splat (20, n, (void *) &test1); + u16 *res = test_mem_alloc (n * sizeof (u16)); + + test_perf_event_enable (tp); + for (int i = 0; i < n; i++) + res[i] = clib_ip_csum (data + i * lenp[0], lenp[0]); + test_perf_event_disable (tp); +} + +void __test_perf_fn +perftest_byte (test_perf_t *tp) +{ + volatile uword *np = &tp->n_ops; + u8 *data = test_mem_alloc_and_fill_inc_u8 (*np, 0, 0); + u16 *res = test_mem_alloc (sizeof (u16)); + + test_perf_event_enable (tp); + res[0] = clib_ip_csum (data, np[0]); + test_perf_event_disable (tp); +} + +REGISTER_TEST (clib_ip_csum) = { + .name = "clib_ip_csum", + .fn = test_clib_ip_csum, + .perf_tests = PERF_TESTS ( + { .name = "fixed size (per IPv4 Header)", + .n_ops = 1024, + .fn = perftest_ip4_hdr }, + { .name = "fixed size (per 1460 byte block)", + .n_ops = 16, + .arg0 = 1460, + .fn = perftest_tcp_payload }, + { .name = "variable size (per byte)", .n_ops = 16384, .fn = perftest_byte } + + ), +}; diff --git a/src/vppinfra/test/mask_compare.c b/src/vppinfra/test/mask_compare.c new file mode 100644 index 00000000000..738b0082dd7 --- /dev/null +++ b/src/vppinfra/test/mask_compare.c @@ -0,0 +1,139 @@ +/* SPDX-License-Identifier: Apache-2.0 + * Copyright(c) 2021 Cisco Systems, Inc. + */ + +#include <vppinfra/format.h> +#include <vppinfra/test/test.h> +#include <vppinfra/vector/mask_compare.h> + +__test_funct_fn void +clib_mask_compare_u16_wrapper (u16 v, u16 *a, u64 *mask, u32 n_elts) +{ + clib_mask_compare_u16 (v, a, mask, n_elts); +} + +__test_funct_fn void +clib_mask_compare_u32_wrapper (u32 v, u32 *a, u64 *mask, u32 n_elts) +{ + clib_mask_compare_u32 (v, a, mask, n_elts); +} + +__test_funct_fn void +clib_mask_compare_u64_wrapper (u64 v, u64 *a, u64 *mask, u64 n_elts) +{ + clib_mask_compare_u64 (v, a, mask, n_elts); +} + +static clib_error_t * +test_clib_mask_compare_u16 (clib_error_t *err) +{ + u16 array[513]; + u64 mask[10]; + u32 i, j; + + for (i = 0; i < ARRAY_LEN (array); i++) + array[i] = i; + + for (i = 0; i < ARRAY_LEN (array); i++) + { + for (j = 0; j < ARRAY_LEN (mask); j++) + mask[j] = 0xa5a5a5a5a5a5a5a5; + + clib_mask_compare_u16_wrapper (i, array, mask, i + 1); + + for (j = 0; j < (i >> 6); j++) + { + if (mask[j]) + return clib_error_return (err, "mask at position %u not zero", j); + } + if (mask[j] != 1ULL << (i & 0x3f)) + return clib_error_return (err, + "mask at position %u is %lx, expected %lx", + j, mask[j], 1ULL << (i % 64)); + + if (mask[j + 1] != 0xa5a5a5a5a5a5a5a5) + return clib_error_return (err, "mask overrun at position %u", j + 1); + } + return err; +} + +REGISTER_TEST (clib_mask_compare_u16) = { + .name = "clib_mask_compare_u16", + .fn = test_clib_mask_compare_u16, +}; + +static clib_error_t * +test_clib_mask_compare_u32 (clib_error_t *err) +{ + u32 array[513]; + u64 mask[10]; + u32 i, j; + + for (i = 0; i < ARRAY_LEN (array); i++) + array[i] = i; + + for (i = 0; i < ARRAY_LEN (array); i++) + { + for (j = 0; j < ARRAY_LEN (mask); j++) + mask[j] = 0xa5a5a5a5a5a5a5a5; + + clib_mask_compare_u32_wrapper (i, array, mask, i + 1); + + for (j = 0; j < (i >> 6); j++) + { + if (mask[j]) + return clib_error_return (err, "mask at position %u not zero", j); + } + if (mask[j] != 1ULL << (i & 0x3f)) + return clib_error_return (err, + "mask at position %u is %lx, expected %lx", + j, mask[j], 1ULL << (i % 64)); + + if (mask[j + 1] != 0xa5a5a5a5a5a5a5a5) + return clib_error_return (err, "mask overrun at position %u", j + 1); + } + return err; +} + +REGISTER_TEST (clib_mask_compare_u32) = { + .name = "clib_mask_compare_u32", + .fn = test_clib_mask_compare_u32, +}; + +static clib_error_t * +test_clib_mask_compare_u64 (clib_error_t *err) +{ + u64 array[513]; + u64 mask[10]; + u32 i, j; + + for (i = 0; i < ARRAY_LEN (array); i++) + array[i] = i; + + for (i = 0; i < ARRAY_LEN (array); i++) + { + for (j = 0; j < ARRAY_LEN (mask); j++) + mask[j] = 0xa5a5a5a5a5a5a5a5; + + clib_mask_compare_u64_wrapper (i, array, mask, i + 1); + + for (j = 0; j < (i >> 6); j++) + { + if (mask[j]) + return clib_error_return (err, "mask at position %u not zero", j); + } + if (mask[j] != 1ULL << (i & 0x3f)) + return clib_error_return (err, + "mask at position %u is %lx, expected %lx", + j, mask[j], 1ULL << (i % 64)); + + if (mask[j + 1] != 0xa5a5a5a5a5a5a5a5) + return clib_error_return (err, "mask overrun at position %u", j + 1); + } + return err; +} + +REGISTER_TEST (clib_mask_compare_u64) = { + .name = "clib_mask_compare_u64", + .fn = test_clib_mask_compare_u64, +}; diff --git a/src/vppinfra/test/memcpy_x86_64.c b/src/vppinfra/test/memcpy_x86_64.c new file mode 100644 index 00000000000..41855c39241 --- /dev/null +++ b/src/vppinfra/test/memcpy_x86_64.c @@ -0,0 +1,142 @@ +/* SPDX-License-Identifier: Apache-2.0 + * Copyright(c) 2021 Cisco Systems, Inc. + */ + +#ifdef __x86_64__ + +#include <vppinfra/format.h> +#include <vppinfra/test/test.h> +#include <vppinfra/memcpy_x86_64.h> + +__test_funct_fn void +wrapper (u8 *dst, u8 *src, uword n) +{ + clib_memcpy_x86_64 (dst, src, n); +} + +/* clang-format off */ +#define foreach_const_n \ + _(1) _(2) _(3) _(4) _(5) _(6) _(7) _(8) _(9) _(10) _(11) _(12) _(13) _(14) \ + _(15) _(16) _(17) _(18) _(19) _(20) _(21) _(22) _(23) _(24) _(25) _(26) \ + _(27) _(28) _(29) _(30) _(31) _(32) _(33) _(34) _(35) _(36) _(37) _(38) \ + _(39) _(40) _(41) _(42) _(43) _(44) _(45) _(46) _(47) _(48) _(49) _(50) \ + _(51) _(52) _(53) _(54) _(55) _(56) _(57) _(58) _(59) _(60) _(61) _(62) \ + _(63) _(64) _(65) _(66) _(67) _(68) _(69) _(70) _(71) _(72) _(73) _(74) \ + _(75) _(76) _(77) _(78) _(79) _(80) _(81) _(82) _(83) _(84) _(85) _(86) \ + _(87) _(88) _(89) _(90) _(91) _(92) _(93) _(94) _(95) _(96) _(97) _(98) \ + _(99) _(100) _(101) _(102) _(103) _(104) _(105) _(106) _(107) _(108) \ + _(109) _(110) _(111) _(112) _(113) _(114) _(115) _(116) _(117) _(118) \ + _(119) _(120) _(121) _(122) _(123) _(124) _(125) _(126) _(127) _(128) \ + _(129) _(130) _(131) _(132) _(133) _(134) _(135) _(136) _(137) _(138) \ + _(139) _(140) _(141) _(142) _(143) _(144) _(145) _(146) _(147) _(148) \ + _(149) _(150) _(151) _(152) _(153) _(154) _(155) _(156) _(157) _(158) \ + _(159) _(160) _(161) _(162) _(163) _(164) _(165) _(166) _(167) _(168) \ + _(169) _(170) _(171) _(172) _(173) _(174) _(175) _(176) _(177) _(178) \ + _(179) _(180) _(181) _(182) _(183) _(184) _(185) _(186) _(187) _(188) \ + _(189) _(190) _(191) _(192) _(193) _(194) _(195) _(196) _(197) _(198) \ + _(199) _(200) _(201) _(202) _(203) _(204) _(205) _(206) _(207) _(208) \ + _(209) _(210) _(211) _(212) _(213) _(214) _(215) _(216) _(217) _(218) \ + _(219) _(220) _(221) _(222) _(223) _(224) _(225) _(226) _(227) _(228) \ + _(229) _(230) _(231) _(232) _(233) _(234) _(235) _(236) _(237) _(238) \ + _(239) _(240) _(241) _(242) _(243) _(244) _(245) _(246) _(247) _(248) \ + _(249) _(250) _(251) _(252) _(253) _(254) _(255) +/* clang-format on */ + +#define _(n) \ + static __clib_noinline void wrapper##n (u8 *dst, u8 *src) \ + { \ + clib_memcpy_x86_64 (dst, src, n); \ + } + +foreach_const_n; +#undef _ + +typedef void (const_fp_t) (u8 *dst, u8 *src); +typedef struct +{ + u16 len; + const_fp_t *fp; +} counst_test_t; + +static counst_test_t const_tests[] = { +#define _(n) { .fp = wrapper##n, .len = n }, + foreach_const_n +#undef _ +}; + +#define MAX_LEN 1024 + +static clib_error_t * +validate_one (clib_error_t *err, u8 *d, u8 *s, u16 n, u8 off, int is_const) +{ + for (int i = 0; i < n; i++) + if (d[i] != s[i]) + return clib_error_return (err, + "memcpy error at position %d " + "(n = %u, off = %u, expected 0x%02x " + "found 0x%02x%s)", + i, n, off, s[i], d[i], + is_const ? ", const" : ""); + for (int i = -64; i < 0; i++) + if (d[i] != 0xfe) + return clib_error_return (err, + "buffer underrun at position %d " + "(n = %u, off = %u, expected 0xfe " + "found 0x%02x%s)", + i, n, off, d[i], is_const ? ", const" : ""); + for (int i = n; i < n + 64; i++) + if (d[i] != 0xfe) + return clib_error_return (err, + "buffer overrun at position %d " + "(n = %u, off = %u, expected 0xfe " + "found 0x%02x%s)", + i, n, off, d[i], is_const ? ", const" : ""); + return err; +} + +static clib_error_t * +test_clib_memcpy_x86_64 (clib_error_t *err) +{ + u8 src[MAX_LEN + 192]; + u8 dst[MAX_LEN + 192]; + + for (int i = 0; i < ARRAY_LEN (src); i++) + src[i] = i & 0x7f; + + for (int j = 0; j < ARRAY_LEN (const_tests); j++) + { + u8 *d = dst + 64; + u8 *s = src + 64; + u16 n = const_tests[j].len; + + for (int i = 0; i < 128 + n; i++) + dst[i] = 0xfe; + const_tests[j].fp (d, s); + if ((err = validate_one (err, d, s, n, 0, /* is_const */ 1))) + return err; + } + + for (u16 n = 1; n <= MAX_LEN; n++) + { + for (int off = 0; off < 64; off += 7) + { + u8 *d = dst + 64 + off; + u8 *s = src + 64; + + for (int i = 0; i < 128 + n + off; i++) + dst[i] = 0xfe; + + wrapper (d, s, n); + + if ((err = validate_one (err, d, s, n, off, /* is_const */ 0))) + return err; + } + } + return err; +} + +REGISTER_TEST (clib_memcpy_x86_64) = { + .name = "clib_memcpy_x86_64", + .fn = test_clib_memcpy_x86_64, +}; +#endif diff --git a/src/vppinfra/test/poly1305.c b/src/vppinfra/test/poly1305.c new file mode 100644 index 00000000000..34551f84047 --- /dev/null +++ b/src/vppinfra/test/poly1305.c @@ -0,0 +1,268 @@ +/* SPDX-License-Identifier: Apache-2.0 + * Copyright(c) 2023 Cisco Systems, Inc. + */ + +#include <vppinfra/format.h> +#include <vppinfra/test/test.h> +#include <vppinfra/crypto/poly1305.h> + +static const u8 text1[375] = { + 0x41, 0x6e, 0x79, 0x20, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, + 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x49, 0x45, 0x54, 0x46, + 0x20, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, + 0x6f, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6c, 0x6c, 0x20, + 0x6f, 0x72, 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, + 0x20, 0x49, 0x45, 0x54, 0x46, 0x20, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, + 0x74, 0x2d, 0x44, 0x72, 0x61, 0x66, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x52, 0x46, + 0x43, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x73, 0x74, 0x61, + 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6d, 0x61, 0x64, 0x65, 0x20, 0x77, + 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x78, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x49, 0x45, + 0x54, 0x46, 0x20, 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x20, 0x69, + 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20, + 0x61, 0x6e, 0x20, 0x22, 0x49, 0x45, 0x54, 0x46, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2e, 0x20, 0x53, 0x75, + 0x63, 0x68, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, + 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x6f, 0x72, 0x61, 0x6c, + 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x69, + 0x6e, 0x20, 0x49, 0x45, 0x54, 0x46, 0x20, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, + 0x6e, 0x73, 0x2c, 0x20, 0x61, 0x73, 0x20, 0x77, 0x65, 0x6c, 0x6c, 0x20, 0x61, + 0x73, 0x20, 0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x20, 0x61, 0x6e, 0x64, + 0x20, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x20, 0x63, + 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x20, 0x6d, 0x61, 0x64, 0x65, 0x20, 0x61, 0x74, 0x20, 0x61, 0x6e, 0x79, 0x20, + 0x74, 0x69, 0x6d, 0x65, 0x20, 0x6f, 0x72, 0x20, 0x70, 0x6c, 0x61, 0x63, 0x65, + 0x2c, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, + 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f +}; + +const static struct +{ + char *name; + u32 len; + const u8 key[32]; + const u8 *msg; + const u8 out[16]; +} test_cases[] = { + { + .name = "test1", + .len = 34, + .out = { 0xa8, 0x06, 0x1d, 0xc1, 0x30, 0x51, 0x36, 0xc6, 0xc2, 0x2b, 0x8b, + 0xaf, 0x0c, 0x01, 0x27, 0xa9 }, + .key = { 0x85, 0xd6, 0xbe, 0x78, 0x57, 0x55, 0x6d, 0x33, 0x7f, 0x44, 0x52, + 0xfe, 0x42, 0xd5, 0x06, 0xa8, 0x01, 0x03, 0x80, 0x8a, 0xfb, 0x0d, + 0xb2, 0xfd, 0x4a, 0xbf, 0xf6, 0xaf, 0x41, 0x49, 0xf5, 0x1b }, + .msg = (u8[34]){ 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x67, 0x72, 0x61, + 0x70, 0x68, 0x69, 0x63, 0x20, 0x46, 0x6f, 0x72, 0x75, + 0x6d, 0x20, 0x52, 0x65, 0x73, 0x65, 0x61, 0x72, 0x63, + 0x68, 0x20, 0x47, 0x72, 0x6f, 0x75, 0x70 }, + }, + { + .name = "RFC8439 A3 TV1", + .len = 64, + .out = {}, + .key = {}, + .msg = (u8[64]){}, + }, + { + .name = "RFC8439 A3 TV2", + .len = sizeof (text1), + .out = { 0x36, 0xe5, 0xf6, 0xb5, 0xc5, 0xe0, 0x60, 0x70, 0xf0, 0xef, 0xca, + 0x96, 0x22, 0x7a, 0x86, 0x3e }, + .key = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0xe5, 0xf6, 0xb5, 0xc5, 0xe0, + 0x60, 0x70, 0xf0, 0xef, 0xca, 0x96, 0x22, 0x7a, 0x86, 0x3e }, + .msg = text1, + }, + { + .name = "RFC8439 A3 TV3", + .len = sizeof (text1), + .out = { 0xf3, 0x47, 0x7e, 0x7c, 0xd9, 0x54, 0x17, 0xaf, 0x89, 0xa6, 0xb8, + 0x79, 0x4c, 0x31, 0x0c, 0xf0 + + }, + .key = { 0x36, 0xe5, 0xf6, 0xb5, 0xc5, 0xe0, 0x60, 0x70, 0xf0, 0xef, 0xca, + 0x96, 0x22, 0x7a, 0x86, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, + + .msg = text1, + }, + { + .name = "RFC8439 A3 TV4", + .len = 127, + .key = { 0x1c, 0x92, 0x40, 0xa5, 0xeb, 0x55, 0xd3, 0x8a, 0xf3, 0x33, 0x88, + 0x86, 0x04, 0xf6, 0xb5, 0xf0, 0x47, 0x39, 0x17, 0xc1, 0x40, 0x2b, + 0x80, 0x09, 0x9d, 0xca, 0x5c, 0xbc, 0x20, 0x70, 0x75, 0xc0 }, + .msg = + (u8[127]){ + 0x27, 0x54, 0x77, 0x61, 0x73, 0x20, 0x62, 0x72, 0x69, 0x6c, 0x6c, 0x69, + 0x67, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x6c, 0x69, 0x74, 0x68, 0x79, 0x20, 0x74, 0x6f, 0x76, 0x65, 0x73, 0x0a, + 0x44, 0x69, 0x64, 0x20, 0x67, 0x79, 0x72, 0x65, 0x20, 0x61, 0x6e, 0x64, + 0x20, 0x67, 0x69, 0x6d, 0x62, 0x6c, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x77, 0x61, 0x62, 0x65, 0x3a, 0x0a, 0x41, 0x6c, 0x6c, + 0x20, 0x6d, 0x69, 0x6d, 0x73, 0x79, 0x20, 0x77, 0x65, 0x72, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x62, 0x6f, 0x72, 0x6f, 0x67, 0x6f, 0x76, 0x65, + 0x73, 0x2c, 0x0a, 0x41, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, + 0x6f, 0x6d, 0x65, 0x20, 0x72, 0x61, 0x74, 0x68, 0x73, 0x20, 0x6f, 0x75, + 0x74, 0x67, 0x72, 0x61, 0x62, 0x65, 0x2e }, + .out = { 0x45, 0x41, 0x66, 0x9a, 0x7e, 0xaa, 0xee, 0x61, 0xe7, 0x08, 0xdc, + 0x7c, 0xbc, 0xc5, 0xeb, 0x62 }, + }, + { + /* Test Vector #5: + * If one uses 130-bit partial reduction, does the code handle the case + * where partially reduced final result is not fully reduced? */ + .name = "RFC8439 A3 TV5", + .len = 16, + .key = { 2 }, + .msg = (u8[16]){ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }, + .out = { 3 }, + }, + { + /* Test Vector #6: + * What happens if addition of s overflows modulo 2^128? */ + .name = "RFC8439 A3 TV6", + .len = 16, + .key = { 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }, + .msg = (u8[16]){ 2 }, + .out = { 3 }, + }, + { + /* Test Vector #7: + * What happens if data limb is all ones and there is carry from lower + * limb? */ + .name = "RFC8439 A3 TV7", + .len = 48, + .key = { 1 }, + .msg = + (u8[48]){ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, + .out = { 5 }, + }, + { + /* Test Vector #8: + * What happens if final result from polynomial part is exactly 2^130-5? */ + .name = "RFC8439 A3 TV8", + .len = 48, + .key = { 1 }, + .msg = + (u8[48]){ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 }, + .out = { 0 }, + }, + { + /* Test Vector #9: + * What happens if final result from polynomial part is exactly 2^130-6? */ + .name = "RFC8439 A3 TV9", + .len = 16, + .key = { 2 }, + .msg = (u8[16]){ 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }, + .out = { 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff }, + }, + { + /* Test Vector #10: + * What happens if 5*H+L-type reduction produces 131-bit intermediate + * result? */ + .name = "RFC8439 A3 TV10", + .len = 64, + .key = { [0] = 1, [8] = 4 }, + .msg = + (u8[64]){ 0xE3, 0x35, 0x94, 0xD7, 0x50, 0x5E, 0x43, 0xB9, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x94, 0xD7, 0x50, + 0x5E, 0x43, 0x79, 0xCD, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00 }, + .out = { 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00 }, + }, + { + /* Test Vector #11: + * What happens if 5*H+L-type reduction produces 131-bit final result? */ + .name = "RFC8439 A3 TV11", + .len = 48, + .key = { [0] = 1, [8] = 4 }, + .msg = + (u8[48]){ 0xE3, 0x35, 0x94, 0xD7, 0x50, 0x5E, 0x43, 0xB9, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x94, 0xD7, 0x50, + 0x5E, 0x43, 0x79, 0xCD, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, + .out = { 0x13 }, + } +}; + +static clib_error_t * +test_clib_poly1305 (clib_error_t *err) +{ + u8 out[16] = {}; + + FOREACH_ARRAY_ELT (tc, test_cases) + { + clib_poly1305 (tc->key, tc->msg, tc->len, out); + if (memcmp (out, tc->out, 16) != 0) + err = clib_error_return ( + err, + "\ntest: %s" + "\nkey: %U" + "\ndata: %U" + "\nexp out: %U" + "\ncalc out: %U\n", + tc->name, format_hexdump, tc->key, 32, format_hexdump, tc->msg, + tc->len, format_hexdump, tc->out, 16, format_hexdump, out, 16); + } + return err; +} + +void __test_perf_fn +perftest_64byte (test_perf_t *tp) +{ + u32 n = tp->n_ops; + u8 *m = test_mem_alloc_and_fill_inc_u8 (n * 64, 0, 0); + u8 *k = test_mem_alloc_and_fill_inc_u8 (n * 32, 0, 0); + u8 *t = test_mem_alloc (n * 16); + + test_perf_event_enable (tp); + for (int i = 0; i < n; i++, t += 16, k += 32, m += 64) + clib_poly1305 (k, m, 64, t); + test_perf_event_disable (tp); +} + +void __test_perf_fn +perftest_byte (test_perf_t *tp) +{ + u32 n = tp->n_ops; + + u8 *m = test_mem_alloc_and_fill_inc_u8 (n, 0, 0); + u8 *k = test_mem_alloc_and_fill_inc_u8 (32, 0, 0); + u8 *t = test_mem_alloc (16); + + test_perf_event_enable (tp); + clib_poly1305 (k, m, n, t); + test_perf_event_disable (tp); +} + +REGISTER_TEST (clib_poly1305) = { + .name = "clib_poly1305", + .fn = test_clib_poly1305, + .perf_tests = PERF_TESTS ( + { .name = "fixed size (64 bytes)", .n_ops = 1024, .fn = perftest_64byte }, + { .name = "variable size (per byte)", + .n_ops = 16384, + .fn = perftest_byte }), +}; diff --git a/src/vppinfra/test/sha2.c b/src/vppinfra/test/sha2.c new file mode 100644 index 00000000000..d5da2b61706 --- /dev/null +++ b/src/vppinfra/test/sha2.c @@ -0,0 +1,322 @@ +/* SPDX-License-Identifier: Apache-2.0 + * Copyright(c) 2021 Cisco Systems, Inc. + */ + +#include <vppinfra/format.h> +#include <vppinfra/test/test.h> +#include <vppinfra/crypto/sha2.h> + +typedef struct +{ + const u8 *msg; + const u8 *key; + int tc; + u32 msg_len; + u32 key_len; + u8 digest_224[28]; + u8 digest_256[32]; + u8 digest_384[48]; + u8 digest_512[64]; + u8 digest_224_len; + u8 digest_256_len; + u8 digest_384_len; + u8 digest_512_len; +} sha2_test_t; + +#ifndef CLIB_MARCH_VARIANT +static const u8 key1[20] = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, + 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, + 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b }; +static const u8 key2[4] = "Jefe"; +static const u8 key3[20] = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa }; +static const u8 key4[25] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, + 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, + 0x16, 0x17, 0x18, 0x19 }; +static const u8 key5[20] = { 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, + 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, + 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c }; +static const u8 key6[131] = { + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa +}; + +static const u8 msg1[8] = "Hi There"; +static const u8 msg2[28] = "what do ya want for nothing?"; +static const u8 msg3[50] = { + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd +}; +static const u8 msg4[50] = { + 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, + 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, + 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, + 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd +}; +static const u8 msg6[54] = + "Test Using Larger Than Block-Size Key - Hash Key First"; +static const u8 msg7[153] = + "This is a test using a larger than block-size key and a larger than " + "block-size data. The key needs to be hashed before being used by the " + "HMAC algorithm."; + +const sha2_test_t sha2_tests[] = { + { + /* RFC4231 Test Case 1 */ + .tc = 1, + .key = key1, + .key_len = sizeof (key1), + .msg = msg1, + .msg_len = sizeof (msg1), + .digest_224 = { 0x89, 0x6f, 0xb1, 0x12, 0x8a, 0xbb, 0xdf, 0x19, 0x68, 0x32, + 0x10, 0x7c, 0xd4, 0x9d, 0xf3, 0x3f, 0x47, 0xb4, 0xb1, 0x16, + 0x99, 0x12, 0xba, 0x4f, 0x53, 0x68, 0x4b, 0x22 }, + .digest_256 = { 0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53, + 0x5c, 0xa8, 0xaf, 0xce, 0xaf, 0x0b, 0xf1, 0x2b, + 0x88, 0x1d, 0xc2, 0x00, 0xc9, 0x83, 0x3d, 0xa7, + 0x26, 0xe9, 0x37, 0x6c, 0x2e, 0x32, 0xcf, 0xf7 }, + .digest_384 = { 0xaf, 0xd0, 0x39, 0x44, 0xd8, 0x48, 0x95, 0x62, 0x6b, 0x08, + 0x25, 0xf4, 0xab, 0x46, 0x90, 0x7f, 0x15, 0xf9, 0xda, 0xdb, + 0xe4, 0x10, 0x1e, 0xc6, 0x82, 0xaa, 0x03, 0x4c, 0x7c, 0xeb, + 0xc5, 0x9c, 0xfa, 0xea, 0x9e, 0xa9, 0x07, 0x6e, 0xde, 0x7f, + 0x4a, 0xf1, 0x52, 0xe8, 0xb2, 0xfa, 0x9c, 0xb6 }, + .digest_512 = { 0x87, 0xaa, 0x7c, 0xde, 0xa5, 0xef, 0x61, 0x9d, 0x4f, 0xf0, + 0xb4, 0x24, 0x1a, 0x1d, 0x6c, 0xb0, 0x23, 0x79, 0xf4, 0xe2, + 0xce, 0x4e, 0xc2, 0x78, 0x7a, 0xd0, 0xb3, 0x05, 0x45, 0xe1, + 0x7c, 0xde, 0xda, 0xa8, 0x33, 0xb7, 0xd6, 0xb8, 0xa7, 0x02, + 0x03, 0x8b, 0x27, 0x4e, 0xae, 0xa3, 0xf4, 0xe4, 0xbe, 0x9d, + 0x91, 0x4e, 0xeb, 0x61, 0xf1, 0x70, 0x2e, 0x69, 0x6c, 0x20, + 0x3a, 0x12, 0x68, 0x54 }, + }, + { + /* RFC4231 Test Case 2 */ + .tc = 2, + .key = key2, + .key_len = sizeof (key2), + .msg = msg2, + .msg_len = sizeof (msg2), + .digest_224 = { 0xa3, 0x0e, 0x01, 0x09, 0x8b, 0xc6, 0xdb, 0xbf, 0x45, 0x69, + 0x0f, 0x3a, 0x7e, 0x9e, 0x6d, 0x0f, 0x8b, 0xbe, 0xa2, 0xa3, + 0x9e, 0x61, 0x48, 0x00, 0x8f, 0xd0, 0x5e, 0x44 }, + .digest_256 = { 0x5b, 0xdc, 0xc1, 0x46, 0xbf, 0x60, 0x75, 0x4e, + 0x6a, 0x04, 0x24, 0x26, 0x08, 0x95, 0x75, 0xc7, + 0x5a, 0x00, 0x3f, 0x08, 0x9d, 0x27, 0x39, 0x83, + 0x9d, 0xec, 0x58, 0xb9, 0x64, 0xec, 0x38, 0x43 }, + .digest_384 = { 0xaf, 0x45, 0xd2, 0xe3, 0x76, 0x48, 0x40, 0x31, 0x61, 0x7f, + 0x78, 0xd2, 0xb5, 0x8a, 0x6b, 0x1b, 0x9c, 0x7e, 0xf4, 0x64, + 0xf5, 0xa0, 0x1b, 0x47, 0xe4, 0x2e, 0xc3, 0x73, 0x63, 0x22, + 0x44, 0x5e, 0x8e, 0x22, 0x40, 0xca, 0x5e, 0x69, 0xe2, 0xc7, + 0x8b, 0x32, 0x39, 0xec, 0xfa, 0xb2, 0x16, 0x49 }, + .digest_512 = { 0x16, 0x4b, 0x7a, 0x7b, 0xfc, 0xf8, 0x19, 0xe2, 0xe3, 0x95, + 0xfb, 0xe7, 0x3b, 0x56, 0xe0, 0xa3, 0x87, 0xbd, 0x64, 0x22, + 0x2e, 0x83, 0x1f, 0xd6, 0x10, 0x27, 0x0c, 0xd7, 0xea, 0x25, + 0x05, 0x54, 0x97, 0x58, 0xbf, 0x75, 0xc0, 0x5a, 0x99, 0x4a, + 0x6d, 0x03, 0x4f, 0x65, 0xf8, 0xf0, 0xe6, 0xfd, 0xca, 0xea, + 0xb1, 0xa3, 0x4d, 0x4a, 0x6b, 0x4b, 0x63, 0x6e, 0x07, 0x0a, + 0x38, 0xbc, 0xe7, 0x37 }, + }, + { /* RFC4231 Test Case 3 */ + .tc = 3, + .key = key3, + .key_len = sizeof (key3), + .msg = msg3, + .msg_len = sizeof (msg3), + .digest_224 = { 0x7f, 0xb3, 0xcb, 0x35, 0x88, 0xc6, 0xc1, 0xf6, 0xff, 0xa9, + 0x69, 0x4d, 0x7d, 0x6a, 0xd2, 0x64, 0x93, 0x65, 0xb0, 0xc1, + 0xf6, 0x5d, 0x69, 0xd1, 0xec, 0x83, 0x33, 0xea }, + .digest_256 = { 0x77, 0x3e, 0xa9, 0x1e, 0x36, 0x80, 0x0e, 0x46, + 0x85, 0x4d, 0xb8, 0xeb, 0xd0, 0x91, 0x81, 0xa7, + 0x29, 0x59, 0x09, 0x8b, 0x3e, 0xf8, 0xc1, 0x22, + 0xd9, 0x63, 0x55, 0x14, 0xce, 0xd5, 0x65, 0xfe }, + .digest_384 = { 0x88, 0x06, 0x26, 0x08, 0xd3, 0xe6, 0xad, 0x8a, 0x0a, 0xa2, + 0xac, 0xe0, 0x14, 0xc8, 0xa8, 0x6f, 0x0a, 0xa6, 0x35, 0xd9, + 0x47, 0xac, 0x9f, 0xeb, 0xe8, 0x3e, 0xf4, 0xe5, 0x59, 0x66, + 0x14, 0x4b, 0x2a, 0x5a, 0xb3, 0x9d, 0xc1, 0x38, 0x14, 0xb9, + 0x4e, 0x3a, 0xb6, 0xe1, 0x01, 0xa3, 0x4f, 0x27 }, + .digest_512 = { 0xfa, 0x73, 0xb0, 0x08, 0x9d, 0x56, 0xa2, 0x84, 0xef, 0xb0, + 0xf0, 0x75, 0x6c, 0x89, 0x0b, 0xe9, 0xb1, 0xb5, 0xdb, 0xdd, + 0x8e, 0xe8, 0x1a, 0x36, 0x55, 0xf8, 0x3e, 0x33, 0xb2, 0x27, + 0x9d, 0x39, 0xbf, 0x3e, 0x84, 0x82, 0x79, 0xa7, 0x22, 0xc8, + 0x06, 0xb4, 0x85, 0xa4, 0x7e, 0x67, 0xc8, 0x07, 0xb9, 0x46, + 0xa3, 0x37, 0xbe, 0xe8, 0x94, 0x26, 0x74, 0x27, 0x88, 0x59, + 0xe1, 0x32, 0x92, 0xfb } }, + { + /* RFC4231 Test Case 4 */ + .tc = 4, + .key = key4, + .key_len = sizeof (key4), + .msg = msg4, + .msg_len = sizeof (msg4), + .digest_224 = { 0x6c, 0x11, 0x50, 0x68, 0x74, 0x01, 0x3c, 0xac, 0x6a, 0x2a, + 0xbc, 0x1b, 0xb3, 0x82, 0x62, 0x7c, 0xec, 0x6a, 0x90, 0xd8, + 0x6e, 0xfc, 0x01, 0x2d, 0xe7, 0xaf, 0xec, 0x5a }, + .digest_256 = { 0x82, 0x55, 0x8a, 0x38, 0x9a, 0x44, 0x3c, 0x0e, + 0xa4, 0xcc, 0x81, 0x98, 0x99, 0xf2, 0x08, 0x3a, + 0x85, 0xf0, 0xfa, 0xa3, 0xe5, 0x78, 0xf8, 0x07, + 0x7a, 0x2e, 0x3f, 0xf4, 0x67, 0x29, 0x66, 0x5b }, + .digest_384 = { 0x3e, 0x8a, 0x69, 0xb7, 0x78, 0x3c, 0x25, 0x85, 0x19, 0x33, + 0xab, 0x62, 0x90, 0xaf, 0x6c, 0xa7, 0x7a, 0x99, 0x81, 0x48, + 0x08, 0x50, 0x00, 0x9c, 0xc5, 0x57, 0x7c, 0x6e, 0x1f, 0x57, + 0x3b, 0x4e, 0x68, 0x01, 0xdd, 0x23, 0xc4, 0xa7, 0xd6, 0x79, + 0xcc, 0xf8, 0xa3, 0x86, 0xc6, 0x74, 0xcf, 0xfb }, + .digest_512 = { 0xb0, 0xba, 0x46, 0x56, 0x37, 0x45, 0x8c, 0x69, 0x90, 0xe5, + 0xa8, 0xc5, 0xf6, 0x1d, 0x4a, 0xf7, 0xe5, 0x76, 0xd9, 0x7f, + 0xf9, 0x4b, 0x87, 0x2d, 0xe7, 0x6f, 0x80, 0x50, 0x36, 0x1e, + 0xe3, 0xdb, 0xa9, 0x1c, 0xa5, 0xc1, 0x1a, 0xa2, 0x5e, 0xb4, + 0xd6, 0x79, 0x27, 0x5c, 0xc5, 0x78, 0x80, 0x63, 0xa5, 0xf1, + 0x97, 0x41, 0x12, 0x0c, 0x4f, 0x2d, 0xe2, 0xad, 0xeb, 0xeb, + 0x10, 0xa2, 0x98, 0xdd }, + }, + { + /* RFC4231 Test Case 5 */ + .tc = 5, + .key = key5, + .key_len = sizeof (key5), + .msg = (u8 *) "Test With Truncation", + .msg_len = 20, + .digest_224 = { 0x0e, 0x2a, 0xea, 0x68, 0xa9, 0x0c, 0x8d, 0x37, 0xc9, 0x88, + 0xbc, 0xdb, 0x9f, 0xca, 0x6f, 0xa8 }, + .digest_224_len = 16, + .digest_256 = { 0xa3, 0xb6, 0x16, 0x74, 0x73, 0x10, 0x0e, 0xe0, 0x6e, 0x0c, + 0x79, 0x6c, 0x29, 0x55, 0x55, 0x2b }, + .digest_256_len = 16, + .digest_384 = { 0x3a, 0xbf, 0x34, 0xc3, 0x50, 0x3b, 0x2a, 0x23, 0xa4, 0x6e, + 0xfc, 0x61, 0x9b, 0xae, 0xf8, 0x97 }, + .digest_384_len = 16, + .digest_512 = { 0x41, 0x5f, 0xad, 0x62, 0x71, 0x58, 0x0a, 0x53, 0x1d, 0x41, + 0x79, 0xbc, 0x89, 0x1d, 0x87, 0xa6 }, + .digest_512_len = 16, + }, + { /* RFC4231 Test Case 6 */ + .tc = 6, + .key = key6, + .key_len = sizeof (key6), + .msg = msg6, + .msg_len = sizeof (msg6), + .digest_224 = { 0x95, 0xe9, 0xa0, 0xdb, 0x96, 0x20, 0x95, 0xad, 0xae, 0xbe, + 0x9b, 0x2d, 0x6f, 0x0d, 0xbc, 0xe2, 0xd4, 0x99, 0xf1, 0x12, + 0xf2, 0xd2, 0xb7, 0x27, 0x3f, 0xa6, 0x87, 0x0e }, + .digest_256 = { 0x60, 0xe4, 0x31, 0x59, 0x1e, 0xe0, 0xb6, 0x7f, + 0x0d, 0x8a, 0x26, 0xaa, 0xcb, 0xf5, 0xb7, 0x7f, + 0x8e, 0x0b, 0xc6, 0x21, 0x37, 0x28, 0xc5, 0x14, + 0x05, 0x46, 0x04, 0x0f, 0x0e, 0xe3, 0x7f, 0x54 }, + .digest_384 = { 0x4e, 0xce, 0x08, 0x44, 0x85, 0x81, 0x3e, 0x90, 0x88, 0xd2, + 0xc6, 0x3a, 0x04, 0x1b, 0xc5, 0xb4, 0x4f, 0x9e, 0xf1, 0x01, + 0x2a, 0x2b, 0x58, 0x8f, 0x3c, 0xd1, 0x1f, 0x05, 0x03, 0x3a, + 0xc4, 0xc6, 0x0c, 0x2e, 0xf6, 0xab, 0x40, 0x30, 0xfe, 0x82, + 0x96, 0x24, 0x8d, 0xf1, 0x63, 0xf4, 0x49, 0x52 }, + .digest_512 = { 0x80, 0xb2, 0x42, 0x63, 0xc7, 0xc1, 0xa3, 0xeb, 0xb7, 0x14, + 0x93, 0xc1, 0xdd, 0x7b, 0xe8, 0xb4, 0x9b, 0x46, 0xd1, 0xf4, + 0x1b, 0x4a, 0xee, 0xc1, 0x12, 0x1b, 0x01, 0x37, 0x83, 0xf8, + 0xf3, 0x52, 0x6b, 0x56, 0xd0, 0x37, 0xe0, 0x5f, 0x25, 0x98, + 0xbd, 0x0f, 0xd2, 0x21, 0x5d, 0x6a, 0x1e, 0x52, 0x95, 0xe6, + 0x4f, 0x73, 0xf6, 0x3f, 0x0a, 0xec, 0x8b, 0x91, 0x5a, 0x98, + 0x5d, 0x78, 0x65, 0x98 } }, + { + /* RFC4231 Test Case 7 */ + .tc = 7, + .key = key6, + .key_len = sizeof (key6), + .msg = msg7, + .msg_len = sizeof (msg7) - 1, + .digest_224 = { 0x3a, 0x85, 0x41, 0x66, 0xac, 0x5d, 0x9f, 0x02, 0x3f, 0x54, + 0xd5, 0x17, 0xd0, 0xb3, 0x9d, 0xbd, 0x94, 0x67, 0x70, 0xdb, + 0x9c, 0x2b, 0x95, 0xc9, 0xf6, 0xf5, 0x65, 0xd1 }, + .digest_256 = { 0x9b, 0x09, 0xff, 0xa7, 0x1b, 0x94, 0x2f, 0xcb, + 0x27, 0x63, 0x5f, 0xbc, 0xd5, 0xb0, 0xe9, 0x44, + 0xbf, 0xdc, 0x63, 0x64, 0x4f, 0x07, 0x13, 0x93, + 0x8a, 0x7f, 0x51, 0x53, 0x5c, 0x3a, 0x35, 0xe2 }, + .digest_384 = { 0x66, 0x17, 0x17, 0x8e, 0x94, 0x1f, 0x02, 0x0d, 0x35, 0x1e, + 0x2f, 0x25, 0x4e, 0x8f, 0xd3, 0x2c, 0x60, 0x24, 0x20, 0xfe, + 0xb0, 0xb8, 0xfb, 0x9a, 0xdc, 0xce, 0xbb, 0x82, 0x46, 0x1e, + 0x99, 0xc5, 0xa6, 0x78, 0xcc, 0x31, 0xe7, 0x99, 0x17, 0x6d, + 0x38, 0x60, 0xe6, 0x11, 0x0c, 0x46, 0x52, 0x3e }, + .digest_512 = { 0xe3, 0x7b, 0x6a, 0x77, 0x5d, 0xc8, 0x7d, 0xba, 0xa4, 0xdf, + 0xa9, 0xf9, 0x6e, 0x5e, 0x3f, 0xfd, 0xde, 0xbd, 0x71, 0xf8, + 0x86, 0x72, 0x89, 0x86, 0x5d, 0xf5, 0xa3, 0x2d, 0x20, 0xcd, + 0xc9, 0x44, 0xb6, 0x02, 0x2c, 0xac, 0x3c, 0x49, 0x82, 0xb1, + 0x0d, 0x5e, 0xeb, 0x55, 0xc3, 0xe4, 0xde, 0x15, 0x13, 0x46, + 0x76, 0xfb, 0x6d, 0xe0, 0x44, 0x60, 0x65, 0xc9, 0x74, 0x40, + 0xfa, 0x8c, 0x6a, 0x58 }, + }, + {} +}; +#else +extern const sha2_test_t sha2_tests[]; +#endif + +static clib_error_t * +check_digest (clib_error_t *err, int tc, u8 *calculated, const u8 *expected, + u8 len) +{ + if (memcmp (expected, calculated, len) != 0) + err = clib_error_return (err, + "Bad HMAC SHA%u digest for test case " + "%u:\nExpected:\n%U\nCalculated:\n%U\n", + len * 8, tc, format_hexdump, expected, len, + format_hexdump, calculated, len); + return err; +} + +#define _(bits) \ + static clib_error_t *test_clib_hmac_sha##bits (clib_error_t *err) \ + { \ + u8 digest[64]; \ + const sha2_test_t *t = sha2_tests; \ + \ + while (t->key) \ + { \ + u8 digest_len = t->digest_##bits##_len; \ + if (digest_len == 0) \ + digest_len = sizeof (t->digest_##bits); \ + clib_memset_u8 (digest, 0xfe, sizeof (digest)); \ + clib_hmac_sha##bits (t->key, t->key_len, t->msg, t->msg_len, digest); \ + if ((err = check_digest (err, t->tc, digest, t->digest_##bits, \ + digest_len))) \ + return err; \ + t++; \ + } \ + \ + return err; \ + } \ + \ + void __test_perf_fn perftest_sha##bits##_byte (test_perf_t *tp) \ + { \ + volatile uword *np = &tp->n_ops; \ + volatile uword *kl = &tp->arg0; \ + ; \ + u8 *key = test_mem_alloc_and_fill_inc_u8 (*kl, 32, 0); \ + u8 *data = test_mem_alloc_and_fill_inc_u8 (*np, 0, 0); \ + u8 *digest = test_mem_alloc (64); \ + \ + test_perf_event_enable (tp); \ + clib_hmac_sha##bits (key, *kl, data, *np, digest); \ + test_perf_event_disable (tp); \ + } \ + REGISTER_TEST (clib_hmac_sha##bits) = { \ + .name = "clib_hmac_sha" #bits, \ + .fn = test_clib_hmac_sha##bits, \ + .perf_tests = PERF_TESTS ({ .name = "byte", \ + .n_ops = 16384, \ + .arg0 = 20, \ + .fn = perftest_sha##bits##_byte }) \ + } + +_ (224); +_ (256); +_ (384); +_ (512); +#undef _ diff --git a/src/vppinfra/test/test.c b/src/vppinfra/test/test.c new file mode 100644 index 00000000000..55c2ae7a11f --- /dev/null +++ b/src/vppinfra/test/test.c @@ -0,0 +1,259 @@ +/* SPDX-License-Identifier: Apache-2.0 + * Copyright(c) 2021 Cisco Systems, Inc. + */ + +#include <vppinfra/format.h> +#include <vppinfra/test/test.h> +#include <vppinfra/error.h> + +test_main_t test_main; + +int +test_march_supported (clib_march_variant_type_t type) +{ +#define _(s, n) \ + if (CLIB_MARCH_VARIANT_TYPE_##s == type) \ + return clib_cpu_march_priority_##s (); + foreach_march_variant +#undef _ + return 0; +} + +clib_error_t * +test_funct (test_main_t *tm) +{ + for (int i = 0; i < CLIB_MARCH_TYPE_N_VARIANTS; i++) + { + test_registration_t *r = tm->registrations[i]; + + if (r == 0 || test_march_supported (i) < 0) + continue; + + fformat (stdout, "\nMultiarch Variant: %U\n", format_march_variant, i); + fformat (stdout, + "-------------------------------------------------------\n"); + while (r) + { + clib_error_t *err; + if (tm->filter && strstr (r->name, (char *) tm->filter) == 0) + goto next; + err = (r->fn) (0); + fformat (stdout, "%-50s %s\n", r->name, err ? "FAIL" : "PASS"); + for (int i = 0; i < vec_len (tm->allocated_mem); i++) + clib_mem_free (tm->allocated_mem[i]); + vec_free (tm->allocated_mem); + if (err) + { + clib_error_report (err); + fformat (stdout, "\n"); + } + next: + r = r->next; + } + } + + fformat (stdout, "\n"); + return 0; +} + +#if 0 +static u8 * +format_test_perf_bundle_core_power (u8 *s, va_list *args) +{ + test_perf_event_bundle_t __clib_unused *b = + va_arg (*args, test_perf_event_bundle_t *); + test_perf_t __clib_unused *tp = va_arg (*args, test_perf_t *); + u64 *data = va_arg (*args, u64 *); + + if (data) + s = format (s, "%7.1f %%", (f64) 100 * data[1] / data[0]); + else + s = format (s, "%9s", "Level 0"); + + if (data) + s = format (s, "%8.1f %%", (f64) 100 * data[2] / data[0]); + else + s = format (s, "%9s", "Level 1"); + + if (data) + s = format (s, "%7.1f %%", (f64) 100 * data[3] / data[0]); + else + s = format (s, "%9s", "Level 2"); + + return s; +} + +#ifdef __x86_64__ +#define PERF_INTEL_CODE(event, umask) ((event) | (umask) << 8) + , + { + .name = "core-power", + .desc = + "Core cycles where the core was running under specific turbo schedule.", + .type = PERF_TYPE_RAW, + .config[0] = PERF_INTEL_CODE (0x3c, 0x00), + .config[1] = PERF_INTEL_CODE (0x28, 0x07), + .config[2] = PERF_INTEL_CODE (0x28, 0x18), + .config[3] = PERF_INTEL_CODE (0x28, 0x20), + .config[4] = PERF_INTEL_CODE (0x28, 0x40), + .n_events = 5, + .format_fn = format_test_perf_bundle_core_power, + } +#endif +}; +#endif + +#ifdef __linux__ +clib_error_t * +test_perf (test_main_t *tm) +{ + clib_error_t *err = 0; + clib_perfmon_ctx_t _ctx, *ctx = &_ctx; + + if ((err = clib_perfmon_init_by_bundle_name ( + ctx, "%s", tm->bundle ? (char *) tm->bundle : "default"))) + return err; + + fformat (stdout, "Warming up...\n"); + clib_perfmon_warmup (ctx); + + for (int i = 0; i < CLIB_MARCH_TYPE_N_VARIANTS; i++) + { + test_registration_t *r = tm->registrations[i]; + + if (r == 0 || test_march_supported (i) < 0) + continue; + + fformat (stdout, "\nMultiarch Variant: %U\n", format_march_variant, i); + fformat (stdout, + "-------------------------------------------------------\n"); + while (r) + { + if (r->perf_tests) + { + test_perf_t *pt = r->perf_tests; + if (tm->filter && strstr (r->name, (char *) tm->filter) == 0) + goto next; + + clib_perfmon_capture_group (ctx, "%s", r->name); + do + { + for (int i = 0; i < tm->repeat; i++) + { + pt->fd = ctx->group_fd; + clib_perfmon_reset (ctx); + pt->fn (pt); + clib_perfmon_capture (ctx, pt->n_ops, "%0s", pt->name); + for (int i = 0; i < vec_len (tm->allocated_mem); i++) + clib_mem_free (tm->allocated_mem[i]); + vec_free (tm->allocated_mem); + } + } + while ((++pt)->fn); + } + next: + r = r->next; + } + fformat (stdout, "%U\n", format_perfmon_bundle, ctx); + clib_perfmon_clear (ctx); + } + + clib_perfmon_free (ctx); + return err; +} +#elif __FreeBSD__ +clib_error_t * +test_perf (test_main_t *tm) +{ + return NULL; +} +#endif + +int +main (int argc, char *argv[]) +{ + test_main_t *tm = &test_main; + unformat_input_t _i = {}, *i = &_i; + clib_mem_init (0, 64ULL << 20); + clib_error_t *err; + int perf = 0; + + /* defaults */ + tm->repeat = 3; + + unformat_init_command_line (i, argv); + + while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) + { + if (unformat (i, "perf")) + perf = 1; + else if (unformat (i, "filter %s", &tm->filter)) + ; + else if (unformat (i, "bundle %s", &tm->bundle)) + ; + else if (unformat (i, "repeat %d", &tm->repeat)) + ; + else + { + clib_warning ("unknown input '%U'", format_unformat_error, i); + exit (1); + } + } + + if (perf) + err = test_perf (tm); + else + err = test_funct (tm); + + if (err) + { + clib_error_report (err); + fformat (stderr, "\n"); + return 1; + } + return 0; +} + +void * +test_mem_alloc (uword size) +{ + void *rv; + size = round_pow2 (size, CLIB_CACHE_LINE_BYTES); + rv = clib_mem_alloc_aligned (size, CLIB_CACHE_LINE_BYTES); + clib_memset_u8 (rv, 0, size); + vec_add1 (test_main.allocated_mem, rv); + return rv; +} + +void * +test_mem_alloc_and_fill_inc_u8 (uword size, u8 start, u8 mask) +{ + u8 *rv; + mask = mask ? mask : 0xff; + size = round_pow2 (size, CLIB_CACHE_LINE_BYTES); + rv = clib_mem_alloc_aligned (size, CLIB_CACHE_LINE_BYTES); + for (uword i = 0; i < size; i++) + rv[i] = ((u8) i + start) & mask; + vec_add1 (test_main.allocated_mem, rv); + return rv; +} + +void * +test_mem_alloc_and_splat (uword elt_size, uword n_elts, void *elt) +{ + u8 *rv, *e; + uword data_size = elt_size * n_elts; + uword alloc_size = round_pow2 (data_size, CLIB_CACHE_LINE_BYTES); + e = rv = clib_mem_alloc_aligned (alloc_size, CLIB_CACHE_LINE_BYTES); + while (e - rv < data_size) + { + clib_memcpy_fast (e, elt, elt_size); + e += elt_size; + } + + if (data_size < alloc_size) + clib_memset_u8 (e, 0, alloc_size - data_size); + vec_add1 (test_main.allocated_mem, rv); + return rv; +} + diff --git a/src/vppinfra/test/test.h b/src/vppinfra/test/test.h new file mode 100644 index 00000000000..8d756366163 --- /dev/null +++ b/src/vppinfra/test/test.h @@ -0,0 +1,125 @@ +/* SPDX-License-Identifier: Apache-2.0 + * Copyright(c) 2021 Cisco Systems, Inc. + */ + +#ifndef included_test_test_h +#define included_test_test_h + +#include <vppinfra/cpu.h> +#include <vppinfra/perfmon/perfmon.h> +#ifdef __linux__ +#include <sys/ioctl.h> +#include <linux/perf_event.h> +#endif + +typedef clib_error_t *(test_fn_t) (clib_error_t *); + +struct test_perf_; +typedef void (test_perf_fn_t) (struct test_perf_ *tp); + +typedef struct test_perf_ +{ + int fd; + u64 n_ops; + union + { + u64 arg0; + void *ptr0; + }; + union + { + u64 arg1; + void *ptr1; + }; + union + { + u64 arg2; + void *ptr2; + }; + char *name; + test_perf_fn_t *fn; +} test_perf_t; + +typedef struct test_registration_ +{ + char *name; + u8 multiarch : 1; + test_fn_t *fn; + test_perf_t *perf_tests; + u32 n_perf_tests; + struct test_registration_ *next; +} test_registration_t; + +typedef struct +{ + test_registration_t *registrations[CLIB_MARCH_TYPE_N_VARIANTS]; + u32 repeat; + u8 *filter; + u8 *bundle; + f64 ref_clock; + void **allocated_mem; +} test_main_t; +extern test_main_t test_main; + +#define __test_funct_fn \ + static __clib_noinline __clib_noclone __clib_section (".test_func") +#define __test_perf_fn \ + static __clib_noinline __clib_noclone __clib_section (".test_perf") + +#define REGISTER_TEST(x) \ + test_registration_t CLIB_MARCH_SFX (__test_##x); \ + static void __clib_constructor CLIB_MARCH_SFX (__test_registration_##x) ( \ + void) \ + { \ + test_registration_t *r = &CLIB_MARCH_SFX (__test_##x); \ + r->next = \ + test_main.registrations[CLIB_MARCH_SFX (CLIB_MARCH_VARIANT_TYPE)]; \ + test_main.registrations[CLIB_MARCH_SFX (CLIB_MARCH_VARIANT_TYPE)] = r; \ + } \ + test_registration_t CLIB_MARCH_SFX (__test_##x) + +#define PERF_TESTS(...) \ + (test_perf_t[]) \ + { \ + __VA_ARGS__, {} \ + } + +#ifdef __linux__ +static_always_inline void +test_perf_event_reset (test_perf_t *t) +{ + clib_perfmon_ioctl (t->fd, PERF_EVENT_IOC_RESET); +} +static_always_inline void +test_perf_event_enable (test_perf_t *t) +{ + clib_perfmon_ioctl (t->fd, PERF_EVENT_IOC_ENABLE); +} +static_always_inline void +test_perf_event_disable (test_perf_t *t) +{ + clib_perfmon_ioctl (t->fd, PERF_EVENT_IOC_DISABLE); +} +#elif __FreeBSD__ +static_always_inline void +test_perf_event_reset (test_perf_t *t) +{ + /* TODO: Implement for FreeBSD */ +} +static_always_inline void +test_perf_event_enable (test_perf_t *t) +{ + /* TODO: Implement for FreeBSD */ +} +static_always_inline void +test_perf_event_disable (test_perf_t *t) +{ + /* TODO: Implement for FreeBSD */ +} +#endif + +void *test_mem_alloc (uword size); +void *test_mem_alloc_and_fill_inc_u8 (uword size, u8 start, u8 mask); +void *test_mem_alloc_and_splat (uword elt_size, uword n_elts, void *elt); + +#endif diff --git a/src/vppinfra/test/toeplitz.c b/src/vppinfra/test/toeplitz.c new file mode 100644 index 00000000000..708fd0e60fc --- /dev/null +++ b/src/vppinfra/test/toeplitz.c @@ -0,0 +1,514 @@ +/* SPDX-License-Identifier: Apache-2.0 + * Copyright(c) 2021 Cisco Systems, Inc. + */ + +#include <vppinfra/format.h> +#include <vppinfra/test/test.h> +#include <vppinfra/vector/toeplitz.h> + +/* secret key and test cases taken from: + * https://docs.microsoft.com/en-us/windows-hardware/drivers/network/verifying-the-rss-hash-calculation + */ + +typedef struct +{ + u32 sip, dip; + u16 sport, dport; +} __clib_packed ip4_key_t; + +typedef struct +{ + ip4_key_t key; + u32 hash_2t, hash_4t; +} ip4_test_t; + +typedef struct +{ + u16 sip[8], dip[8]; + u16 sport, dport; +} __clib_packed ip6_key_t; + +typedef struct +{ + ip6_key_t key; + u32 hash_2t, hash_4t; +} ip6_test_t; + +#define N_IP4_TESTS 5 +#define N_IP6_TESTS 3 +#define N_LENGTH_TESTS 240 + +#ifndef CLIB_MARCH_VARIANT +#define _IP4(a, b, c, d) ((d) << 24 | (c) << 16 | (b) << 8 | (a)) +#define _IP6(a, b, c, d, e, f, g, h) \ + { \ + (u16) ((a) << 8) | (u8) ((a) >> 8), (u16) ((b) << 8) | (u8) ((b) >> 8), \ + (u16) ((c) << 8) | (u8) ((c) >> 8), (u16) ((d) << 8) | (u8) ((d) >> 8), \ + (u16) ((e) << 8) | (u8) ((e) >> 8), (u16) ((f) << 8) | (u8) ((f) >> 8), \ + (u16) ((g) << 8) | (u8) ((g) >> 8), (u16) ((h) << 8) | (u8) ((h) >> 8), \ + } +#define _PORT(a) ((a) >> 8 | (((a) &0xff) << 8)) + +const ip4_test_t ip4_tests[N_IP4_TESTS] = { + /* ipv4 tests */ + { + .key.sip = _IP4 (66, 9, 149, 187), + .key.dip = _IP4 (161, 142, 100, 80), + .key.sport = _PORT (2794), + .key.dport = _PORT (1766), + .hash_2t = 0x323e8fc2, + .hash_4t = 0x51ccc178, + }, + { + .key.sip = _IP4 (199, 92, 111, 2), + .key.dip = _IP4 (65, 69, 140, 83), + .key.sport = _PORT (14230), + .key.dport = _PORT (4739), + .hash_2t = 0xd718262a, + .hash_4t = 0xc626b0ea, + }, + { + .key.sip = _IP4 (24, 19, 198, 95), + .key.dip = _IP4 (12, 22, 207, 184), + .key.sport = _PORT (12898), + .key.dport = _PORT (38024), + .hash_2t = 0xd2d0a5de, + .hash_4t = 0x5c2b394a, + }, + { + .key.sip = _IP4 (38, 27, 205, 30), + .key.dip = _IP4 (209, 142, 163, 6), + .key.sport = _PORT (48228), + .key.dport = _PORT (2217), + .hash_2t = 0x82989176, + .hash_4t = 0xafc7327f, + }, + { + .key.sip = _IP4 (153, 39, 163, 191), + .key.dip = _IP4 (202, 188, 127, 2), + .key.sport = _PORT (44251), + .key.dport = _PORT (1303), + .hash_2t = 0x5d1809c5, + .hash_4t = 0x10e828a2, + } +}; + +const ip6_test_t ip6_tests[N_IP6_TESTS] = { + { + .key.sip = _IP6 (0x3ffe, 0x2501, 0x200, 0x1fff, 0, 0, 0, 7), + .key.dip = _IP6 (0x3ffe, 0x2501, 0x200, 3, 0, 0, 0, 1), + .key.sport = _PORT (2794), + .key.dport = _PORT (1766), + .hash_2t = 0x2cc18cd5, + .hash_4t = 0x40207d3d, + }, + { + .key.sip = _IP6 (0x3ffe, 0x501, 8, 0, 0x260, 0x97ff, 0xfe40, 0xefab), + .key.dip = _IP6 (0xff02, 0, 0, 0, 0, 0, 0, 1), + .key.sport = _PORT (14230), + .key.dport = _PORT (4739), + .hash_2t = 0x0f0c461c, + .hash_4t = 0xdde51bbf, + }, + { + .key.sip = _IP6 (0x3ffe, 0x1900, 0x4545, 3, 0x200, 0xf8ff, 0xfe21, 0x67cf), + .key.dip = _IP6 (0xfe80, 0, 0, 0, 0x200, 0xf8ff, 0xfe21, 0x67cf), + .key.sport = _PORT (44251), + .key.dport = _PORT (38024), + .hash_2t = 0x4b61e985, + .hash_4t = 0x02d1feef, + } +}; + +const u32 length_test_hashes[N_LENGTH_TESTS] = { + 0x00000000, 0x00000000, 0x2b6d12ad, 0x9de4446e, 0x061f00bf, 0xad7ed8f7, + 0x4bc7b068, 0x231fc545, 0xdbd97a33, 0xcdab29e7, 0x2d665c0c, 0x31e28ed7, + 0x14e19218, 0x5aa89f0f, 0xd47de07f, 0x355ec712, 0x7e1cbfc0, 0xf84de19d, + 0xbcf66bd3, 0x104086c6, 0x71900b34, 0xcd2f9819, 0xeae68ebb, 0x54d63b4c, + 0x5f865a2c, 0x9d6ded08, 0xe00b0912, 0x3fcf07a6, 0x3bd9ca93, 0x3f4f3bbb, + 0xd0b82624, 0xa28a08e1, 0xa585969f, 0x0c8f4a71, 0x5dce7bdd, 0x4fcf2a6d, + 0x91c89ae9, 0xbef8a24d, 0x8e3d30fe, 0xc8027848, 0xc1e7e513, 0xa12bd3d9, + 0x46700bb4, 0xc6339dab, 0x970805ad, 0xfcb50ac8, 0xc6db4f44, 0x792e2987, + 0xacfb7836, 0xa25ec529, 0x957d7beb, 0x6732809a, 0x891836ed, 0xeefb83b2, + 0xca96b40b, 0x93fd5abd, 0x9076f922, 0x59adb4eb, 0x9705aafb, 0x282719b1, + 0xdda9cb8a, 0x3f499131, 0x47491130, 0x30ef0759, 0xad1cf855, 0x428aa312, + 0x4200240a, 0x71a72857, 0x16b30c36, 0x10cca9a3, 0x166f091e, 0x30e00560, + 0x8acd20ba, 0xfa633d76, 0x0fe32eb7, 0xdcc0122f, 0x20aa8ab0, 0x62b2a9af, + 0x7a6c80a6, 0x27e87268, 0x95b797a8, 0x25d18ccd, 0x68a7fb00, 0xc54bcdad, + 0x3bd0e717, 0xf0df54c9, 0x780daadf, 0x7b435605, 0x150c1e10, 0x8a892e54, + 0x9d27cb25, 0xe23383a5, 0x57aac408, 0x83b8abf8, 0x560f33af, 0xd5cb3307, + 0x79ae8edc, 0x9b127665, 0x320f18bd, 0x385d636b, 0xbd1b2dbf, 0x97679888, + 0x738894a4, 0xeba2afb0, 0xfa7c2d50, 0xb6741aa1, 0x28922bba, 0x7783242b, + 0xa694cca2, 0xa32781c0, 0x696cd670, 0xa714d72f, 0xea34d35a, 0xc5aed81e, + 0x0438433a, 0xc1939ab2, 0xb51c123a, 0x121426b9, 0x1add93ba, 0x50c56b6a, + 0x7e90902a, 0xae3abd85, 0x2f7a0088, 0xb45cf6f9, 0x80070094, 0x8bd46467, + 0xdfd1b762, 0x0bb25856, 0x48eefe84, 0x0989dbb9, 0xfc32472b, 0x965fec6b, + 0x5a256bd0, 0x6df7127a, 0x7856d0d6, 0xedc82bd3, 0x1b563b96, 0xc73eace7, + 0xba4c0a93, 0xdfd6dd97, 0x923c41db, 0x14926ca6, 0x22e52ab1, 0x22852a66, + 0x79606b9c, 0xb0f22b23, 0xb46354ba, 0x9c3cd931, 0x03a92bd6, 0x84000834, + 0x5425df65, 0xf4dd3fc9, 0x391cc873, 0xa560b52e, 0x828037d9, 0x31323dd5, + 0x5c6e3147, 0x28e21f85, 0xa431eb51, 0xf468c4a3, 0x9bea1d2e, 0x43d9109c, + 0x5bb9b081, 0xe0825675, 0xc9c92591, 0xd29fc812, 0x03136bc9, 0x5e005a1f, + 0x6d821ed8, 0x3f0bfcc4, 0x24774162, 0x893bde94, 0x6475efea, 0x6711538e, + 0xc4755f6d, 0x9425ebe2, 0xacf471b4, 0xb947ab0c, 0x1f78c455, 0x372b3ed7, + 0xb3ec24d7, 0x18c4459f, 0xa8ff3695, 0xe4aa2b85, 0x8a52ad7e, 0xe05e8177, + 0x7aa348ed, 0x3e4ac6aa, 0x17dcf8a5, 0x93b933b0, 0x8f7413ec, 0xc77bfe61, + 0xfdb72874, 0x4370f138, 0xdf3462ad, 0xc8970a59, 0xb4a9fed8, 0xa2ddc39b, + 0xd61db62a, 0x95c5fc1b, 0x7b22e6e0, 0x1969702c, 0x7992aebb, 0x59d7c225, + 0x0e16db0b, 0x9f2afc21, 0x246cf66b, 0xb3d6569d, 0x29c532d7, 0xe155747a, + 0xe38d7872, 0xea704969, 0xb69095b0, 0x1b198efd, 0x55daab76, 0xa2a377b6, + 0xb31aa2fa, 0x48b73c41, 0xf0cc501a, 0x9c9ca831, 0x1b591b99, 0xb2d8d22f, + 0xab4b5f69, 0x4fe00e71, 0xdf5480bd, 0x982540d7, 0x7f34ea4f, 0xd7be66e1, + 0x9d2ab1ba, 0x1ba62e12, 0xee3fb36c, 0xf28d7c5a, 0x756311eb, 0xc68567f2, + 0x7b6ea177, 0xc398d9f3 +}; + +#else +extern const ip4_test_t ip4_tests[N_IP4_TESTS]; +extern const ip6_test_t ip6_tests[N_IP6_TESTS]; +extern const u32 length_test_hashes[N_LENGTH_TESTS]; +#endif + +__test_funct_fn u32 +wrapper (clib_toeplitz_hash_key_t *k, u8 *data, u32 n_bytes) +{ + return clib_toeplitz_hash (k, data, n_bytes); +} + +__test_funct_fn void +wrapper_x4 (clib_toeplitz_hash_key_t *k, u8 *d0, u8 *d1, u8 *d2, u8 *d3, + u32 *h0, u32 *h1, u32 *h2, u32 *h3, u32 n_bytes) +{ + clib_toeplitz_hash_x4 (k, d0, d1, d2, d3, h0, h1, h2, h3, n_bytes); +} + +static clib_error_t * +test_clib_toeplitz_hash (clib_error_t *err) +{ + u32 r; + int n_key_copies, bigkey_len, bigdata_len; + u8 *bigkey, *bigdata; + clib_toeplitz_hash_key_t *k; + + k = clib_toeplitz_hash_key_init (0, 0); + + for (int i = 0; i < N_IP4_TESTS; i++) + { + r = wrapper (k, (u8 *) &ip4_tests[i].key, 8); + if (ip4_tests[i].hash_2t != r) + return clib_error_return (err, + "wrong IPv4 2 tuple hash for test %u, " + "calculated 0x%08x expected 0x%08x", + i, ip4_tests[i].hash_2t, r); + + r = wrapper (k, (u8 *) &ip4_tests[i].key, 12); + if (ip4_tests[i].hash_4t != r) + return clib_error_return (err, + "wrong IPv4 4 tuple hash for test %u, " + "calculated 0x%08x expected 0x%08x", + i, ip4_tests[i].hash_4t, r); + } + + for (int i = 0; i < N_IP6_TESTS; i++) + { + r = wrapper (k, (u8 *) &ip6_tests[i].key, 32); + if (ip6_tests[i].hash_2t != r) + return clib_error_return (err, + "wrong IPv6 2 tuple hash for test %u, " + "calculated 0x%08x expected 0x%08x", + i, ip6_tests[i].hash_2t, r); + + r = wrapper (k, (u8 *) &ip6_tests[i].key, 36); + if (ip6_tests[i].hash_4t != r) + return clib_error_return (err, + "wrong IPv6 4 tuple hash for test %u, " + "calculated 0x%08x expected 0x%08x", + i, ip6_tests[i].hash_4t, r); + } + + n_key_copies = 6; + bigkey_len = k->key_length * n_key_copies; + bigdata_len = bigkey_len - 4; + bigkey = test_mem_alloc_and_splat (k->key_length, n_key_copies, k->data); + bigdata = test_mem_alloc_and_fill_inc_u8 (bigdata_len, 0, 0); + u32 key_len = k->key_length; + + clib_toeplitz_hash_key_free (k); + k = clib_toeplitz_hash_key_init (bigkey, n_key_copies * key_len); + + for (int i = 0; i < N_LENGTH_TESTS - 4; i++) + { + r = wrapper (k, bigdata, i); + if (length_test_hashes[i] != r) + { + err = clib_error_return (err, + "wrong length test hash for length %u, " + "calculated 0x%08x expected 0x%08x " + "xor 0x%08x", + i, r, length_test_hashes[i], + r ^ length_test_hashes[i]); + goto done; + } + } + +done: + clib_toeplitz_hash_key_free (k); + return err; +} + +void __test_perf_fn +perftest_fixed_12byte (test_perf_t *tp) +{ + u32 n = tp->n_ops; + u8 *data = test_mem_alloc_and_splat (12, n, (void *) &ip4_tests[0].key); + u8 *res = test_mem_alloc (4 * n); + clib_toeplitz_hash_key_t *k = clib_toeplitz_hash_key_init (0, 0); + + test_perf_event_enable (tp); + for (int i = 0; i < n; i++) + ((u32 *) res)[i] = clib_toeplitz_hash (k, data + i * 12, 12); + test_perf_event_disable (tp); + + clib_toeplitz_hash_key_free (k); +} + +void __test_perf_fn +perftest_fixed_36byte (test_perf_t *tp) +{ + u32 n = tp->n_ops; + u8 *data = test_mem_alloc_and_splat (36, n, (void *) &ip6_tests[0].key); + u8 *res = test_mem_alloc (4 * n); + clib_toeplitz_hash_key_t *k = clib_toeplitz_hash_key_init (0, 0); + + test_perf_event_enable (tp); + for (int i = 0; i < n; i++) + ((u32 *) res)[i] = clib_toeplitz_hash (k, data + i * 36, 36); + test_perf_event_disable (tp); + + clib_toeplitz_hash_key_free (k); +} + +void __test_perf_fn +perftest_variable_size (test_perf_t *tp) +{ + u32 key_len, n_keys, n = tp->n_ops; + u8 *key, *data = test_mem_alloc (n); + u32 *res = test_mem_alloc (sizeof (u32)); + clib_toeplitz_hash_key_t *k = clib_toeplitz_hash_key_init (0, 0); + + k = clib_toeplitz_hash_key_init (0, 0); + key_len = k->key_length; + n_keys = ((n + 4) / k->key_length) + 1; + key = test_mem_alloc_and_splat (n_keys, key_len, k->data); + clib_toeplitz_hash_key_free (k); + k = clib_toeplitz_hash_key_init (key, key_len * n_keys); + + test_perf_event_enable (tp); + res[0] = clib_toeplitz_hash (k, data, n); + test_perf_event_disable (tp); + + clib_toeplitz_hash_key_free (k); +} + +REGISTER_TEST (clib_toeplitz_hash) = { + .name = "clib_toeplitz_hash", + .fn = test_clib_toeplitz_hash, + .perf_tests = PERF_TESTS ({ .name = "fixed (per 12 byte tuple)", + .n_ops = 1024, + .fn = perftest_fixed_12byte }, + { .name = "fixed (per 36 byte tuple)", + .n_ops = 1024, + .fn = perftest_fixed_36byte }, + { .name = "variable size (per byte)", + .n_ops = 16384, + .fn = perftest_variable_size }), +}; + +static clib_error_t * +test_clib_toeplitz_hash_x4 (clib_error_t *err) +{ + u32 r[4]; + int n_key_copies, bigkey_len, bigdata_len; + u8 *bigkey, *bigdata0, *bigdata1, *bigdata2, *bigdata3; + clib_toeplitz_hash_key_t *k; + + k = clib_toeplitz_hash_key_init (0, 0); + + wrapper_x4 (k, (u8 *) &ip4_tests[0].key, (u8 *) &ip4_tests[1].key, + (u8 *) &ip4_tests[2].key, (u8 *) &ip4_tests[3].key, r, r + 1, + r + 2, r + 3, 8); + + if (ip4_tests[0].hash_2t != r[0] || ip4_tests[1].hash_2t != r[1] || + ip4_tests[2].hash_2t != r[2] || ip4_tests[3].hash_2t != r[3]) + return clib_error_return (err, + "wrong IPv4 2 tuple x4 hash " + "calculated { 0x%08x, 0x%08x, 0x%08x, 0x%08x } " + "expected { 0x%08x, 0x%08x, 0x%08x, 0x%08x }", + ip4_tests[0].hash_2t, ip4_tests[1].hash_2t, + ip4_tests[2].hash_2t, ip4_tests[3].hash_2t, r[0], + r[1], r[2], r[3]); + + wrapper_x4 (k, (u8 *) &ip4_tests[0].key, (u8 *) &ip4_tests[1].key, + (u8 *) &ip4_tests[2].key, (u8 *) &ip4_tests[3].key, r, r + 1, + r + 2, r + 3, 12); + + if (ip4_tests[0].hash_4t != r[0] || ip4_tests[1].hash_4t != r[1] || + ip4_tests[2].hash_4t != r[2] || ip4_tests[3].hash_4t != r[3]) + return clib_error_return (err, + "wrong IPv4 4 tuple x4 hash " + "calculated { 0x%08x, 0x%08x, 0x%08x, 0x%08x } " + "expected { 0x%08x, 0x%08x, 0x%08x, 0x%08x }", + ip4_tests[0].hash_4t, ip4_tests[1].hash_4t, + ip4_tests[2].hash_4t, ip4_tests[3].hash_4t, r[0], + r[1], r[2], r[3]); + + wrapper_x4 (k, (u8 *) &ip6_tests[0].key, (u8 *) &ip6_tests[1].key, + (u8 *) &ip6_tests[2].key, (u8 *) &ip6_tests[0].key, r, r + 1, + r + 2, r + 3, 32); + + if (ip6_tests[0].hash_2t != r[0] || ip6_tests[1].hash_2t != r[1] || + ip6_tests[2].hash_2t != r[2] || ip6_tests[0].hash_2t != r[3]) + return clib_error_return (err, + "wrong IPv6 2 tuple x4 hash " + "calculated { 0x%08x, 0x%08x, 0x%08x, 0x%08x } " + "expected { 0x%08x, 0x%08x, 0x%08x, 0x%08x }", + ip6_tests[0].hash_2t, ip6_tests[1].hash_2t, + ip6_tests[2].hash_2t, ip6_tests[0].hash_2t, r[0], + r[1], r[2], r[3]); + + wrapper_x4 (k, (u8 *) &ip6_tests[0].key, (u8 *) &ip6_tests[1].key, + (u8 *) &ip6_tests[2].key, (u8 *) &ip6_tests[0].key, r, r + 1, + r + 2, r + 3, 36); + + if (ip6_tests[0].hash_4t != r[0] || ip6_tests[1].hash_4t != r[1] || + ip6_tests[2].hash_4t != r[2] || ip6_tests[0].hash_4t != r[3]) + return clib_error_return (err, + "wrong IPv6 4 tuple x4 hash " + "calculated { 0x%08x, 0x%08x, 0x%08x, 0x%08x } " + "expected { 0x%08x, 0x%08x, 0x%08x, 0x%08x }", + ip6_tests[0].hash_4t, ip6_tests[1].hash_4t, + ip6_tests[2].hash_4t, ip6_tests[0].hash_4t, r[0], + r[1], r[2], r[3]); + + n_key_copies = 6; + bigkey_len = k->key_length * n_key_copies; + bigdata_len = bigkey_len - 4; + bigkey = test_mem_alloc_and_splat (k->key_length, n_key_copies, k->data); + bigdata0 = test_mem_alloc_and_fill_inc_u8 (bigdata_len, 0, 0); + bigdata1 = test_mem_alloc_and_fill_inc_u8 (bigdata_len, 0, 0); + bigdata2 = test_mem_alloc_and_fill_inc_u8 (bigdata_len, 0, 0); + bigdata3 = test_mem_alloc_and_fill_inc_u8 (bigdata_len, 0, 0); + u32 key_len = k->key_length; + + clib_toeplitz_hash_key_free (k); + k = clib_toeplitz_hash_key_init (bigkey, n_key_copies * key_len); + + for (int i = 0; i < N_LENGTH_TESTS - 4; i++) + { + wrapper_x4 (k, bigdata0, bigdata1, bigdata2, bigdata3, r, r + 1, r + 2, + r + 3, i); + if (length_test_hashes[i] != r[0] || length_test_hashes[i] != r[1] || + length_test_hashes[i] != r[2] || length_test_hashes[i] != r[3]) + { + err = clib_error_return ( + err, + "wrong length test hash x4 for length %u, " + "calculated { 0x%08x, 0x%08x, 0x%08x, 0x%08x }, expected 0x%08x", + i, r[0], r[1], r[2], r[3], length_test_hashes[i]); + goto done; + } + } + +done: + clib_toeplitz_hash_key_free (k); + return err; +} + +void __test_perf_fn +perftest_fixed_12byte_x4 (test_perf_t *tp) +{ + u32 n = tp->n_ops / 4; + u8 *d0 = test_mem_alloc_and_splat (12, n, (void *) &ip4_tests[0].key); + u8 *d1 = test_mem_alloc_and_splat (12, n, (void *) &ip4_tests[1].key); + u8 *d2 = test_mem_alloc_and_splat (12, n, (void *) &ip4_tests[2].key); + u8 *d3 = test_mem_alloc_and_splat (12, n, (void *) &ip4_tests[3].key); + u32 *h0 = test_mem_alloc (4 * n); + u32 *h1 = test_mem_alloc (4 * n); + u32 *h2 = test_mem_alloc (4 * n); + u32 *h3 = test_mem_alloc (4 * n); + clib_toeplitz_hash_key_t *k = clib_toeplitz_hash_key_init (0, 0); + + test_perf_event_enable (tp); + for (int i = 0; i < n; i++) + clib_toeplitz_hash_x4 (k, d0 + i * 12, d1 + i * 12, d2 + i * 12, + d3 + i * 12, h0 + i, h1 + i, h2 + i, h3 + i, 12); + test_perf_event_disable (tp); + + clib_toeplitz_hash_key_free (k); +} + +void __test_perf_fn +perftest_fixed_36byte_x4 (test_perf_t *tp) +{ + u32 n = tp->n_ops / 4; + u8 *d0 = test_mem_alloc_and_splat (36, n, (void *) &ip4_tests[0].key); + u8 *d1 = test_mem_alloc_and_splat (36, n, (void *) &ip4_tests[1].key); + u8 *d2 = test_mem_alloc_and_splat (36, n, (void *) &ip4_tests[2].key); + u8 *d3 = test_mem_alloc_and_splat (36, n, (void *) &ip4_tests[3].key); + u32 *h0 = test_mem_alloc (4 * n); + u32 *h1 = test_mem_alloc (4 * n); + u32 *h2 = test_mem_alloc (4 * n); + u32 *h3 = test_mem_alloc (4 * n); + clib_toeplitz_hash_key_t *k = clib_toeplitz_hash_key_init (0, 0); + + test_perf_event_enable (tp); + for (int i = 0; i < n; i++) + clib_toeplitz_hash_x4 (k, d0 + i * 36, d1 + i * 36, d2 + i * 36, + d3 + i * 36, h0 + i, h1 + i, h2 + i, h3 + i, 36); + test_perf_event_disable (tp); + + clib_toeplitz_hash_key_free (k); +} + +void __test_perf_fn +perftest_variable_size_x4 (test_perf_t *tp) +{ + u32 key_len, n_keys, n = tp->n_ops / 4; + u8 *key; + u8 *d0 = test_mem_alloc (n); + u8 *d1 = test_mem_alloc (n); + u8 *d2 = test_mem_alloc (n); + u8 *d3 = test_mem_alloc (n); + u32 *h0 = test_mem_alloc (sizeof (u32)); + u32 *h1 = test_mem_alloc (sizeof (u32)); + u32 *h2 = test_mem_alloc (sizeof (u32)); + u32 *h3 = test_mem_alloc (sizeof (u32)); + clib_toeplitz_hash_key_t *k = clib_toeplitz_hash_key_init (0, 0); + + k = clib_toeplitz_hash_key_init (0, 0); + key_len = k->key_length; + n_keys = ((n + 4) / k->key_length) + 1; + key = test_mem_alloc_and_splat (n_keys, key_len, k->data); + clib_toeplitz_hash_key_free (k); + k = clib_toeplitz_hash_key_init (key, key_len * n_keys); + + test_perf_event_enable (tp); + clib_toeplitz_hash_x4 (k, d0, d1, d2, d3, h0, h1, h2, h3, n); + test_perf_event_disable (tp); + + clib_toeplitz_hash_key_free (k); +} + +REGISTER_TEST (clib_toeplitz_hash_x4) = { + .name = "clib_toeplitz_hash_x4", + .fn = test_clib_toeplitz_hash_x4, + .perf_tests = PERF_TESTS ({ .name = "fixed (per 12 byte tuple)", + .n_ops = 1024, + .fn = perftest_fixed_12byte_x4 }, + { .name = "fixed (per 36 byte tuple)", + .n_ops = 1024, + .fn = perftest_fixed_36byte_x4 }, + { .name = "variable size (per byte)", + .n_ops = 16384, + .fn = perftest_variable_size_x4 }), +}; |