summaryrefslogtreecommitdiffstats
path: root/src/spdk/intel-ipsec-mb/LibTestApp/ipsec_xvalid.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/spdk/intel-ipsec-mb/LibTestApp/ipsec_xvalid.c')
-rw-r--r--src/spdk/intel-ipsec-mb/LibTestApp/ipsec_xvalid.c2055
1 files changed, 2055 insertions, 0 deletions
diff --git a/src/spdk/intel-ipsec-mb/LibTestApp/ipsec_xvalid.c b/src/spdk/intel-ipsec-mb/LibTestApp/ipsec_xvalid.c
new file mode 100644
index 000000000..c1f0467a1
--- /dev/null
+++ b/src/spdk/intel-ipsec-mb/LibTestApp/ipsec_xvalid.c
@@ -0,0 +1,2055 @@
+/**********************************************************************
+ Copyright(c) 2019, Intel Corporation All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the
+ distribution.
+ * Neither the name of Intel Corporation nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+**********************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <string.h>
+#include <errno.h>
+#include <malloc.h> /* memalign() or _aligned_malloc()/aligned_free() */
+#include "misc.h"
+
+#ifdef _WIN32
+#include <intrin.h>
+#define strdup _strdup
+#define __forceinline static __forceinline
+#define BSWAP64 _byteswap_uint64
+#else
+#include <x86intrin.h>
+#define __forceinline static inline __attribute__((always_inline))
+#define BSWAP64 __builtin_bswap64
+#endif
+
+#include <intel-ipsec-mb.h>
+
+/* maximum size of a test buffer */
+#define JOB_SIZE_TOP (16 * 1024)
+/* min size of a buffer when testing range of buffers */
+#define DEFAULT_JOB_SIZE_MIN 16
+/* max size of a buffer when testing range of buffers */
+#define DEFAULT_JOB_SIZE_MAX (2 * 1024)
+/* number of bytes to increase buffer size when testing range of buffers */
+#define DEFAULT_JOB_SIZE_STEP 16
+
+#define DEFAULT_JOB_ITER 10
+
+#define AAD_SIZE 12
+#define MAX_IV_SIZE 16
+
+/* Maximum key and digest size for SHA-512 */
+#define MAX_KEY_SIZE SHA_512_BLOCK_SIZE
+#define MAX_DIGEST_SIZE SHA512_DIGEST_SIZE_IN_BYTES
+
+#define DIM(x) (sizeof(x)/sizeof(x[0]))
+
+#define SEED 0xdeadcafe
+#define PT_PATTERN 0x44444444
+#define KEY_PATTERN 0x66666666
+#define TAG_PATTERN 0x77777777
+#define STACK_DEPTH 8192
+
+enum arch_type_e {
+ ARCH_SSE = 0,
+ ARCH_AESNI_EMU,
+ ARCH_AVX,
+ ARCH_AVX2,
+ ARCH_AVX512,
+ NUM_ARCHS
+};
+
+/* Struct storing cipher parameters */
+struct params_s {
+ JOB_CIPHER_MODE cipher_mode; /* CBC, CNTR, DES, GCM etc. */
+ JOB_HASH_ALG hash_alg; /* SHA-1 or others... */
+ uint32_t key_size;
+ uint32_t buf_size;
+ uint64_t aad_size;
+ uint32_t num_sizes;
+};
+
+/* Struct storing all expanded keys */
+struct cipher_auth_keys {
+ uint8_t temp_buf[SHA_512_BLOCK_SIZE];
+ DECLARE_ALIGNED(uint32_t dust[15 * 4], 16);
+ uint8_t ipad[SHA512_DIGEST_SIZE_IN_BYTES];
+ uint8_t opad[SHA512_DIGEST_SIZE_IN_BYTES];
+ DECLARE_ALIGNED(uint32_t k1_expanded[15 * 4], 16);
+ DECLARE_ALIGNED(uint8_t k2[16], 16);
+ DECLARE_ALIGNED(uint8_t k3[16], 16);
+ DECLARE_ALIGNED(uint32_t enc_keys[15 * 4], 16);
+ DECLARE_ALIGNED(uint32_t dec_keys[15 * 4], 16);
+ DECLARE_ALIGNED(struct gcm_key_data gdata_key, 64);
+};
+
+/* Struct storing all necessary data for crypto operations */
+struct data {
+ uint8_t test_buf[JOB_SIZE_TOP];
+ uint8_t src_dst_buf[JOB_SIZE_TOP];
+ uint8_t aad[AAD_SIZE];
+ uint8_t in_digest[MAX_DIGEST_SIZE];
+ uint8_t out_digest[MAX_DIGEST_SIZE];
+ uint8_t iv[MAX_IV_SIZE];
+ uint8_t key[MAX_KEY_SIZE];
+ struct cipher_auth_keys enc_keys;
+ struct cipher_auth_keys dec_keys;
+};
+
+struct custom_job_params {
+ JOB_CIPHER_MODE cipher_mode; /* CBC, CNTR, DES, GCM etc. */
+ JOB_HASH_ALG hash_alg; /* SHA-1 or others... */
+ uint32_t key_size;
+};
+
+union params {
+ enum arch_type_e arch_type;
+ struct custom_job_params job_params;
+};
+
+struct str_value_mapping {
+ const char *name;
+ union params values;
+};
+
+struct str_value_mapping arch_str_map[] = {
+ {.name = "SSE", .values.arch_type = ARCH_SSE },
+ {.name = "AESNI_EMU", .values.arch_type = ARCH_AESNI_EMU },
+ {.name = "AVX", .values.arch_type = ARCH_AVX },
+ {.name = "AVX2", .values.arch_type = ARCH_AVX2 },
+ {.name = "AVX512", .values.arch_type = ARCH_AVX512 }
+};
+
+struct str_value_mapping cipher_algo_str_map[] = {
+ {
+ .name = "aes-cbc-128",
+ .values.job_params = {
+ .cipher_mode = CBC,
+ .key_size = AES_128_BYTES
+ }
+ },
+ {
+ .name = "aes-cbc-192",
+ .values.job_params = {
+ .cipher_mode = CBC,
+ .key_size = AES_192_BYTES
+ }
+ },
+ {
+ .name = "aes-cbc-256",
+ .values.job_params = {
+ .cipher_mode = CBC,
+ .key_size = AES_256_BYTES
+ }
+ },
+ {
+ .name = "aes-ctr-128",
+ .values.job_params = {
+ .cipher_mode = CNTR,
+ .key_size = AES_128_BYTES
+ }
+ },
+ {
+ .name = "aes-ctr-192",
+ .values.job_params = {
+ .cipher_mode = CNTR,
+ .key_size = AES_192_BYTES
+ }
+ },
+ {
+ .name = "aes-ctr-256",
+ .values.job_params = {
+ .cipher_mode = CNTR,
+ .key_size = AES_256_BYTES
+ }
+ },
+ {
+ .name = "aes-ctr-bit-128",
+ .values.job_params = {
+ .cipher_mode = CNTR_BITLEN,
+ .key_size = AES_128_BYTES
+ }
+ },
+ {
+ .name = "aes-ctr-bit-192",
+ .values.job_params = {
+ .cipher_mode = CNTR_BITLEN,
+ .key_size = AES_192_BYTES
+ }
+ },
+ {
+ .name = "aes-ctr-bit-256",
+ .values.job_params = {
+ .cipher_mode = CNTR_BITLEN,
+ .key_size = AES_256_BYTES
+ }
+ },
+ {
+ .name = "aes-ecb-128",
+ .values.job_params = {
+ .cipher_mode = ECB,
+ .key_size = AES_128_BYTES
+ }
+ },
+ {
+ .name = "aes-ecb-192",
+ .values.job_params = {
+ .cipher_mode = ECB,
+ .key_size = AES_192_BYTES
+ }
+ },
+ {
+ .name = "aes-ecb-256",
+ .values.job_params = {
+ .cipher_mode = ECB,
+ .key_size = AES_256_BYTES
+ }
+ },
+ {
+ .name = "aes-docsis",
+ .values.job_params = {
+ .cipher_mode = DOCSIS_SEC_BPI,
+ .key_size = AES_128_BYTES
+ }
+ },
+ {
+ .name = "des-docsis",
+ .values.job_params = {
+ .cipher_mode = DOCSIS_DES,
+ .key_size = 8
+ }
+ },
+ {
+ .name = "des-cbc",
+ .values.job_params = {
+ .cipher_mode = DES,
+ .key_size = 8
+ }
+ },
+ {
+ .name = "3des-cbc",
+ .values.job_params = {
+ .cipher_mode = DES3,
+ .key_size = 24
+ }
+ },
+ {
+ .name = "null",
+ .values.job_params = {
+ .cipher_mode = NULL_CIPHER,
+ .key_size = 0
+ }
+ }
+};
+
+struct str_value_mapping hash_algo_str_map[] = {
+ {
+ .name = "sha1-hmac",
+ .values.job_params = {
+ .hash_alg = SHA1
+ }
+ },
+ {
+ .name = "sha224-hmac",
+ .values.job_params = {
+ .hash_alg = SHA_224
+ }
+ },
+ {
+ .name = "sha256-hmac",
+ .values.job_params = {
+ .hash_alg = SHA_256
+ }
+ },
+ {
+ .name = "sha384-hmac",
+ .values.job_params = {
+ .hash_alg = SHA_384
+ }
+ },
+ {
+ .name = "sha512-hmac",
+ .values.job_params = {
+ .hash_alg = SHA_512
+ }
+ },
+ {
+ .name = "aes-xcbc",
+ .values.job_params = {
+ .hash_alg = AES_XCBC
+ }
+ },
+ {
+ .name = "md5-hmac",
+ .values.job_params = {
+ .hash_alg = MD5
+ }
+ },
+ {
+ .name = "aes-cmac",
+ .values.job_params = {
+ .hash_alg = AES_CMAC
+ }
+ },
+ {
+ .name = "null",
+ .values.job_params = {
+ .hash_alg = NULL_HASH
+ }
+ },
+ {
+ .name = "aes-cmac-bitlen",
+ .values.job_params = {
+ .hash_alg = AES_CMAC_BITLEN
+ }
+ },
+ {
+ .name = "sha1",
+ .values.job_params = {
+ .hash_alg = PLAIN_SHA1
+ }
+ },
+ {
+ .name = "sha224",
+ .values.job_params = {
+ .hash_alg = PLAIN_SHA_224
+ }
+ },
+ {
+ .name = "sha256",
+ .values.job_params = {
+ .hash_alg = PLAIN_SHA_256
+ }
+ },
+ {
+ .name = "sha384",
+ .values.job_params = {
+ .hash_alg = PLAIN_SHA_384
+ }
+ },
+ {
+ .name = "sha512",
+ .values.job_params = {
+ .hash_alg = PLAIN_SHA_512
+ }
+ },
+};
+
+struct str_value_mapping aead_algo_str_map[] = {
+ {
+ .name = "aes-gcm-128",
+ .values.job_params = {
+ .cipher_mode = GCM,
+ .hash_alg = AES_GMAC,
+ .key_size = AES_128_BYTES
+ }
+ },
+ {
+ .name = "aes-gcm-192",
+ .values.job_params = {
+ .cipher_mode = GCM,
+ .hash_alg = AES_GMAC,
+ .key_size = AES_192_BYTES
+ }
+ },
+ {
+ .name = "aes-gcm-256",
+ .values.job_params = {
+ .cipher_mode = GCM,
+ .hash_alg = AES_GMAC,
+ .key_size = AES_256_BYTES
+ }
+ },
+ {
+ .name = "aes-ccm-128",
+ .values.job_params = {
+ .cipher_mode = CCM,
+ .hash_alg = AES_CCM,
+ .key_size = AES_128_BYTES
+ }
+ },
+ {
+ .name = "pon-128",
+ .values.job_params = {
+ .cipher_mode = PON_AES_CNTR,
+ .hash_alg = PON_CRC_BIP,
+ .key_size = AES_128_BYTES
+ }
+ },
+ {
+ .name = "pon-128-no-ctr",
+ .values.job_params = {
+ .cipher_mode = PON_AES_CNTR,
+ .hash_alg = PON_CRC_BIP,
+ .key_size = 0
+ }
+ },
+};
+
+/* This struct stores all information about performed test case */
+struct variant_s {
+ uint32_t arch;
+ struct params_s params;
+ uint64_t *avg_times;
+};
+
+const uint8_t auth_tag_length_bytes[19] = {
+ 12, /* SHA1 */
+ 14, /* SHA_224 */
+ 16, /* SHA_256 */
+ 24, /* SHA_384 */
+ 32, /* SHA_512 */
+ 12, /* AES_XCBC */
+ 12, /* MD5 */
+ 0, /* NULL_HASH */
+#ifndef NO_GCM
+ 16, /* AES_GMAC */
+#endif
+ 0, /* CUSTOM HASH */
+ 16, /* AES_CCM */
+ 16, /* AES_CMAC */
+ 20, /* PLAIN_SHA1 */
+ 28, /* PLAIN_SHA_224 */
+ 32, /* PLAIN_SHA_256 */
+ 48, /* PLAIN_SHA_384 */
+ 64, /* PLAIN_SHA_512 */
+ 4, /* AES_CMAC_BITLEN (3GPP) */
+ 8, /* PON */
+};
+
+/* Minimum, maximum and step values of key sizes */
+const uint8_t key_sizes[13][3] = {
+ {16, 32, 8}, /* CBC */
+ {16, 32, 8}, /* CNTR */
+ {0, 0, 1}, /* NULL */
+ {16, 16, 1}, /* DOCSIS_SEC_BPI */
+#ifndef NO_GCM
+ {16, 32, 8}, /* GCM */
+#endif
+ {0, 0, 1}, /* CUSTOM_CIPHER */
+ {8, 8, 1}, /* DES */
+ {8, 8, 1}, /* DOCSIS_DES */
+ {16, 16, 1}, /* CCM */
+ {24, 24, 1}, /* DES3 */
+ {16, 16, 1}, /* PON_AES_CNTR */
+ {16, 32, 8}, /* ECB */
+ {16, 32, 8}, /* CNTR_BITLEN */
+};
+
+uint8_t custom_test = 0;
+uint8_t verbose = 0;
+
+enum range {
+ RANGE_MIN = 0,
+ RANGE_STEP,
+ RANGE_MAX,
+ NUM_RANGE
+};
+
+uint32_t job_sizes[NUM_RANGE] = {DEFAULT_JOB_SIZE_MIN,
+ DEFAULT_JOB_SIZE_STEP,
+ DEFAULT_JOB_SIZE_MAX};
+uint32_t job_iter = DEFAULT_JOB_ITER;
+
+struct custom_job_params custom_job_params = {
+ .cipher_mode = NULL_CIPHER,
+ .hash_alg = NULL_HASH,
+ .key_size = 0
+};
+
+/* AESNI_EMU disabled by default */
+uint8_t enc_archs[NUM_ARCHS] = {1, 0, 1, 1, 1};
+uint8_t dec_archs[NUM_ARCHS] = {1, 0, 1, 1, 1};
+
+uint64_t flags = 0; /* flags passed to alloc_mb_mgr() */
+
+/** Generate random buffer */
+static void
+generate_random_buf(uint8_t *buf, const uint32_t length)
+{
+ uint32_t i;
+
+ for (i = 0; i < length; i++)
+ buf[i] = (uint8_t) rand();
+}
+
+/*
+ * Searches across a block of memory if a pattern is present
+ * (indicating there is some left over sensitive data)
+ *
+ * Returns 0 if pattern is present or -1 if not present
+ */
+static int
+search_patterns(const void *ptr, const size_t mem_size)
+{
+ const uint8_t *ptr8 = (const uint8_t *) ptr;
+ size_t i;
+
+ if (mem_size < 4)
+ return -1;
+
+ for (i = 0; i <= (mem_size - 4); i++) {
+ const uint32_t string = ((const uint32_t *) ptr8)[0];
+ int ret = -1;
+
+ if (string == KEY_PATTERN) {
+ fprintf(stderr, "Part of KEY is present\n");
+ ret = 0;
+ }
+ if (string == TAG_PATTERN) {
+ fprintf(stderr, "Part of TAG is present\n");
+ ret = 0;
+ }
+ if (string == PT_PATTERN) {
+ fprintf(stderr,
+ "Part of plain/ciphertext is present\n");
+ ret = 0;
+ }
+ if (ret == 0) {
+ fprintf(stderr, "Offset = %zu\n", i);
+ return 0;
+ }
+ ptr8++;
+ }
+
+ return -1;
+}
+
+static void
+byte_hexdump(const char *message, const uint8_t *ptr, const uint32_t len)
+{
+ uint32_t ctr;
+
+ printf("%s:\n", message);
+ for (ctr = 0; ctr < len; ctr++) {
+ printf("0x%02X ", ptr[ctr] & 0xff);
+ if (!((ctr + 1) % 16))
+ printf("\n");
+ }
+ printf("\n");
+ printf("\n");
+};
+
+static void
+print_algo_info(const struct params_s *params)
+{
+ struct custom_job_params *job_params;
+ uint32_t i;
+
+ for (i = 0; i < DIM(aead_algo_str_map); i++) {
+ job_params = &aead_algo_str_map[i].values.job_params;
+ if (job_params->cipher_mode == params->cipher_mode &&
+ job_params->hash_alg == params->hash_alg &&
+ job_params->key_size == params->key_size) {
+ printf("AEAD algo = %s\n", aead_algo_str_map[i].name);
+ return;
+ }
+ }
+
+ for (i = 0; i < DIM(cipher_algo_str_map); i++) {
+ job_params = &cipher_algo_str_map[i].values.job_params;
+ if (job_params->cipher_mode == params->cipher_mode &&
+ job_params->key_size == params->key_size) {
+ printf("Cipher algo = %s ",
+ cipher_algo_str_map[i].name);
+ break;
+ }
+ }
+ for (i = 0; i < DIM(hash_algo_str_map); i++) {
+ job_params = &hash_algo_str_map[i].values.job_params;
+ if (job_params->hash_alg == params->hash_alg) {
+ printf("Hash algo = %s\n", hash_algo_str_map[i].name);
+ break;
+ }
+ }
+}
+
+static void
+print_arch_info(const enum arch_type_e arch)
+{
+ uint32_t i;
+
+ for (i = 0; i < DIM(arch_str_map); i++) {
+ if (arch_str_map[i].values.arch_type == arch)
+ printf("Architecture = %s\n",
+ arch_str_map[i].name);
+ }
+}
+
+static int
+fill_job(JOB_AES_HMAC *job, const struct params_s *params,
+ uint8_t *buf, uint8_t *digest, const uint8_t *aad,
+ const uint32_t buf_size, const uint8_t tag_size,
+ JOB_CIPHER_DIRECTION cipher_dir,
+ struct cipher_auth_keys *keys, uint8_t *iv)
+{
+ static const void *ks_ptr[3];
+ uint32_t *k1_expanded = keys->k1_expanded;
+ uint8_t *k2 = keys->k2;
+ uint8_t *k3 = keys->k3;
+ uint32_t *enc_keys = keys->enc_keys;
+ uint32_t *dec_keys = keys->dec_keys;
+ uint8_t *ipad = keys->ipad;
+ uint8_t *opad = keys->opad;
+ struct gcm_key_data *gdata_key = &keys->gdata_key;
+
+ /* Force partial byte, by substracting 3 bits from the full length */
+ if (params->cipher_mode == CNTR_BITLEN)
+ job->msg_len_to_cipher_in_bits = buf_size * 8 - 3;
+ else
+ job->msg_len_to_cipher_in_bytes = buf_size;
+
+ job->msg_len_to_hash_in_bytes = buf_size;
+ job->hash_start_src_offset_in_bytes = 0;
+ job->cipher_start_src_offset_in_bytes = 0;
+ job->iv = iv;
+
+ if (params->cipher_mode == PON_AES_CNTR) {
+ /* Substract XGEM header */
+ job->msg_len_to_cipher_in_bytes -= 8;
+ job->cipher_start_src_offset_in_bytes = 8;
+ /* If no crypto needed, set msg_len_to_cipher to 0 */
+ if (params->key_size == 0)
+ job->msg_len_to_cipher_in_bytes = 0;
+ }
+
+ /* In-place operation */
+ job->src = buf;
+ job->dst = buf + job->cipher_start_src_offset_in_bytes;
+ job->auth_tag_output = digest;
+
+ job->hash_alg = params->hash_alg;
+ switch (params->hash_alg) {
+ case AES_XCBC:
+ job->u.XCBC._k1_expanded = k1_expanded;
+ job->u.XCBC._k2 = k2;
+ job->u.XCBC._k3 = k3;
+ break;
+ case AES_CMAC:
+ job->u.CMAC._key_expanded = k1_expanded;
+ job->u.CMAC._skey1 = k2;
+ job->u.CMAC._skey2 = k3;
+ break;
+ case AES_CMAC_BITLEN:
+ job->u.CMAC._key_expanded = k1_expanded;
+ job->u.CMAC._skey1 = k2;
+ job->u.CMAC._skey2 = k3;
+ /*
+ * CMAC bit level version is done in bits (length is
+ * converted to bits and it is decreased by 4 bits,
+ * to force the CMAC bitlen path)
+ */
+ job->msg_len_to_hash_in_bits =
+ (job->msg_len_to_hash_in_bytes * 8) - 4;
+ break;
+ case SHA1:
+ case SHA_224:
+ case SHA_256:
+ case SHA_384:
+ case SHA_512:
+ case MD5:
+ /* HMAC hash alg is SHA1 or MD5 */
+ job->u.HMAC._hashed_auth_key_xor_ipad =
+ (uint8_t *) ipad;
+ job->u.HMAC._hashed_auth_key_xor_opad =
+ (uint8_t *) opad;
+ break;
+ case PON_CRC_BIP:
+ case NULL_HASH:
+ case AES_GMAC:
+ case AES_CCM:
+ case PLAIN_SHA1:
+ case PLAIN_SHA_224:
+ case PLAIN_SHA_256:
+ case PLAIN_SHA_384:
+ case PLAIN_SHA_512:
+ /* No operation needed */
+ break;
+ default:
+ printf("Unsupported hash algorithm\n");
+ return -1;
+ }
+
+ job->auth_tag_output_len_in_bytes = tag_size;
+
+ job->cipher_direction = cipher_dir;
+
+ if (params->cipher_mode == NULL_CIPHER) {
+ job->chain_order = HASH_CIPHER;
+ } else if (params->cipher_mode == CCM) {
+ if (job->cipher_direction == ENCRYPT)
+ job->chain_order = HASH_CIPHER;
+ else
+ job->chain_order = CIPHER_HASH;
+ } else {
+ if (job->cipher_direction == ENCRYPT)
+ job->chain_order = CIPHER_HASH;
+ else
+ job->chain_order = HASH_CIPHER;
+ }
+
+ /* Translating enum to the API's one */
+ job->cipher_mode = params->cipher_mode;
+ job->aes_key_len_in_bytes = params->key_size;
+
+ switch (job->cipher_mode) {
+ case CBC:
+ case DOCSIS_SEC_BPI:
+ job->aes_enc_key_expanded = enc_keys;
+ job->aes_dec_key_expanded = dec_keys;
+ job->iv_len_in_bytes = 16;
+ break;
+ case PON_AES_CNTR:
+ case CNTR:
+ case CNTR_BITLEN:
+ job->aes_enc_key_expanded = enc_keys;
+ job->aes_dec_key_expanded = enc_keys;
+ job->iv_len_in_bytes = 16;
+ break;
+ case GCM:
+ job->aes_enc_key_expanded = gdata_key;
+ job->aes_dec_key_expanded = gdata_key;
+ job->u.GCM.aad_len_in_bytes = params->aad_size;
+ job->u.GCM.aad = aad;
+ job->iv_len_in_bytes = 12;
+ break;
+ case CCM:
+ job->msg_len_to_cipher_in_bytes = buf_size;
+ job->msg_len_to_hash_in_bytes = buf_size;
+ job->hash_start_src_offset_in_bytes = 0;
+ job->cipher_start_src_offset_in_bytes = 0;
+ job->u.CCM.aad_len_in_bytes = params->aad_size;
+ job->u.CCM.aad = aad;
+ job->aes_enc_key_expanded = enc_keys;
+ job->aes_dec_key_expanded = enc_keys;
+ job->iv_len_in_bytes = 13;
+ break;
+ case DES:
+ case DOCSIS_DES:
+ job->aes_enc_key_expanded = enc_keys;
+ job->aes_dec_key_expanded = enc_keys;
+ job->iv_len_in_bytes = 8;
+ break;
+ case DES3:
+ ks_ptr[0] = ks_ptr[1] = ks_ptr[2] = enc_keys;
+ job->aes_enc_key_expanded = ks_ptr;
+ job->aes_dec_key_expanded = ks_ptr;
+ job->iv_len_in_bytes = 8;
+ break;
+ case ECB:
+ job->aes_enc_key_expanded = enc_keys;
+ job->aes_dec_key_expanded = dec_keys;
+ job->iv_len_in_bytes = 0;
+ break;
+ case NULL_CIPHER:
+ /* No operation needed */
+ break;
+ default:
+ printf("Unsupported cipher mode\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+prepare_keys(MB_MGR *mb_mgr, struct cipher_auth_keys *keys,
+ const uint8_t *key, const struct params_s *params,
+ const unsigned int force_pattern)
+{
+ uint8_t *buf = keys->temp_buf;
+ uint32_t *dust = keys->dust;
+ uint32_t *k1_expanded = keys->k1_expanded;
+ uint8_t *k2 = keys->k2;
+ uint8_t *k3 = keys->k3;
+ uint32_t *enc_keys = keys->enc_keys;
+ uint32_t *dec_keys = keys->dec_keys;
+ uint8_t *ipad = keys->ipad;
+ uint8_t *opad = keys->opad;
+ struct gcm_key_data *gdata_key = &keys->gdata_key;
+ uint8_t i;
+
+ /* Set all expanded keys to KEY_PATTERN if flag is set */
+ if (force_pattern) {
+ switch (params->hash_alg) {
+ case AES_XCBC:
+ memset(k1_expanded, KEY_PATTERN,
+ sizeof(keys->k1_expanded));
+ break;
+ case AES_CMAC:
+ case AES_CMAC_BITLEN:
+ memset(k1_expanded, KEY_PATTERN,
+ sizeof(keys->k1_expanded));
+ memset(k2, KEY_PATTERN, sizeof(keys->k2));
+ memset(k3, KEY_PATTERN, sizeof(keys->k3));
+ break;
+ case SHA1:
+ case SHA_224:
+ case SHA_256:
+ case SHA_384:
+ case SHA_512:
+ case MD5:
+ memset(ipad, KEY_PATTERN, sizeof(keys->ipad));
+ memset(opad, KEY_PATTERN, sizeof(keys->opad));
+ break;
+ case AES_CCM:
+ case AES_GMAC:
+ case NULL_HASH:
+ case PLAIN_SHA1:
+ case PLAIN_SHA_224:
+ case PLAIN_SHA_256:
+ case PLAIN_SHA_384:
+ case PLAIN_SHA_512:
+ case PON_CRC_BIP:
+ /* No operation needed */
+ break;
+ default:
+ fprintf(stderr, "Unsupported hash algo\n");
+ return -1;
+ }
+
+ switch (params->cipher_mode) {
+ case GCM:
+ memset(gdata_key, KEY_PATTERN, sizeof(keys->gdata_key));
+ break;
+ case PON_AES_CNTR:
+ case CBC:
+ case CCM:
+ case CNTR:
+ case CNTR_BITLEN:
+ case DOCSIS_SEC_BPI:
+ case ECB:
+ memset(enc_keys, KEY_PATTERN, sizeof(keys->enc_keys));
+ memset(dec_keys, KEY_PATTERN, sizeof(keys->dec_keys));
+ break;
+ case DES:
+ case DES3:
+ case DOCSIS_DES:
+ memset(enc_keys, KEY_PATTERN, sizeof(keys->enc_keys));
+ break;
+ case NULL_CIPHER:
+ /* No operation needed */
+ break;
+ default:
+ fprintf(stderr, "Unsupported cipher mode\n");
+ return -1;
+ }
+
+ return 0;
+ }
+
+ switch (params->hash_alg) {
+ case AES_XCBC:
+ IMB_AES_XCBC_KEYEXP(mb_mgr, key, k1_expanded, k2, k3);
+ break;
+ case AES_CMAC:
+ case AES_CMAC_BITLEN:
+ IMB_AES_KEYEXP_128(mb_mgr, key, k1_expanded, dust);
+ IMB_AES_CMAC_SUBKEY_GEN_128(mb_mgr, k1_expanded, k2, k3);
+ break;
+ case SHA1:
+ /* compute ipad hash */
+ memset(buf, 0x36, SHA1_BLOCK_SIZE);
+ for (i = 0; i < SHA1_BLOCK_SIZE; i++)
+ buf[i] ^= key[i];
+ IMB_SHA1_ONE_BLOCK(mb_mgr, buf, ipad);
+
+ /* compute opad hash */
+ memset(buf, 0x5c, SHA1_BLOCK_SIZE);
+ for (i = 0; i < SHA1_BLOCK_SIZE; i++)
+ buf[i] ^= key[i];
+ IMB_SHA1_ONE_BLOCK(mb_mgr, buf, opad);
+
+ break;
+ case SHA_224:
+ /* compute ipad hash */
+ memset(buf, 0x36, SHA_256_BLOCK_SIZE);
+ for (i = 0; i < SHA_256_BLOCK_SIZE; i++)
+ buf[i] ^= key[i];
+ IMB_SHA224_ONE_BLOCK(mb_mgr, buf, ipad);
+
+ /* compute opad hash */
+ memset(buf, 0x5c, SHA_256_BLOCK_SIZE);
+ for (i = 0; i < SHA_256_BLOCK_SIZE; i++)
+ buf[i] ^= key[i];
+ IMB_SHA224_ONE_BLOCK(mb_mgr, buf, opad);
+
+ break;
+ case SHA_256:
+ /* compute ipad hash */
+ memset(buf, 0x36, SHA_256_BLOCK_SIZE);
+ for (i = 0; i < SHA_256_BLOCK_SIZE; i++)
+ buf[i] ^= key[i];
+ IMB_SHA256_ONE_BLOCK(mb_mgr, buf, ipad);
+
+ /* compute opad hash */
+ memset(buf, 0x5c, SHA_256_BLOCK_SIZE);
+ for (i = 0; i < SHA_256_BLOCK_SIZE; i++)
+ buf[i] ^= key[i];
+ IMB_SHA256_ONE_BLOCK(mb_mgr, buf, opad);
+
+ break;
+ case SHA_384:
+ /* compute ipad hash */
+ memset(buf, 0x36, SHA_384_BLOCK_SIZE);
+ for (i = 0; i < SHA_384_BLOCK_SIZE; i++)
+ buf[i] ^= key[i];
+ IMB_SHA384_ONE_BLOCK(mb_mgr, buf, ipad);
+
+ /* compute opad hash */
+ memset(buf, 0x5c, SHA_384_BLOCK_SIZE);
+ for (i = 0; i < SHA_384_BLOCK_SIZE; i++)
+ buf[i] ^= key[i];
+ IMB_SHA384_ONE_BLOCK(mb_mgr, buf, opad);
+
+ break;
+ case SHA_512:
+ /* compute ipad hash */
+ memset(buf, 0x36, SHA_512_BLOCK_SIZE);
+ for (i = 0; i < SHA_512_BLOCK_SIZE; i++)
+ buf[i] ^= key[i];
+ IMB_SHA512_ONE_BLOCK(mb_mgr, buf, ipad);
+
+ /* compute opad hash */
+ memset(buf, 0x5c, SHA_512_BLOCK_SIZE);
+ for (i = 0; i < SHA_512_BLOCK_SIZE; i++)
+ buf[i] ^= key[i];
+ IMB_SHA512_ONE_BLOCK(mb_mgr, buf, opad);
+
+ break;
+ case MD5:
+ /* compute ipad hash */
+ memset(buf, 0x36, 64);
+ for (i = 0; i < 64; i++)
+ buf[i] ^= key[i];
+ IMB_MD5_ONE_BLOCK(mb_mgr, buf, ipad);
+
+ /* compute opad hash */
+ memset(buf, 0x5c, 64);
+ for (i = 0; i < 64; i++)
+ buf[i] ^= key[i];
+ IMB_MD5_ONE_BLOCK(mb_mgr, buf, opad);
+
+ break;
+ case AES_CCM:
+ case AES_GMAC:
+ case NULL_HASH:
+ case PLAIN_SHA1:
+ case PLAIN_SHA_224:
+ case PLAIN_SHA_256:
+ case PLAIN_SHA_384:
+ case PLAIN_SHA_512:
+ case PON_CRC_BIP:
+ /* No operation needed */
+ break;
+ default:
+ fprintf(stderr, "Unsupported hash algo\n");
+ return -1;
+ }
+
+ switch (params->cipher_mode) {
+ case GCM:
+ switch (params->key_size) {
+ case AES_128_BYTES:
+ IMB_AES128_GCM_PRE(mb_mgr, key, gdata_key);
+ break;
+ case AES_192_BYTES:
+ IMB_AES192_GCM_PRE(mb_mgr, key, gdata_key);
+ break;
+ case AES_256_BYTES:
+ IMB_AES256_GCM_PRE(mb_mgr, key, gdata_key);
+ break;
+ default:
+ fprintf(stderr, "Wrong key size\n");
+ return -1;
+ }
+ break;
+ case PON_AES_CNTR:
+ switch (params->key_size) {
+ case 16:
+ IMB_AES_KEYEXP_128(mb_mgr, key, enc_keys, dec_keys);
+ break;
+ case 0:
+ break;
+ default:
+ fprintf(stderr, "Wrong key size\n");
+ return -1;
+ }
+ break;
+ case CBC:
+ case CCM:
+ case CNTR:
+ case CNTR_BITLEN:
+ case DOCSIS_SEC_BPI:
+ case ECB:
+ switch (params->key_size) {
+ case AES_128_BYTES:
+ IMB_AES_KEYEXP_128(mb_mgr, key, enc_keys, dec_keys);
+ break;
+ case AES_192_BYTES:
+ IMB_AES_KEYEXP_192(mb_mgr, key, enc_keys, dec_keys);
+ break;
+ case AES_256_BYTES:
+ IMB_AES_KEYEXP_256(mb_mgr, key, enc_keys, dec_keys);
+ break;
+ default:
+ fprintf(stderr, "Wrong key size\n");
+ return -1;
+ }
+ break;
+ case DES:
+ case DES3:
+ case DOCSIS_DES:
+ des_key_schedule((uint64_t *) enc_keys, key);
+ break;
+ case NULL_CIPHER:
+ /* No operation needed */
+ break;
+ default:
+ fprintf(stderr, "Unsupported cipher mode\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+/* Modify the test buffer to set the HEC value and CRC, so the final
+ * decrypted message can be compared against the test buffer */
+static int
+modify_pon_test_buf(uint8_t *test_buf, const struct params_s *params,
+ const JOB_AES_HMAC *job, const uint64_t xgem_hdr)
+{
+ /* Set plaintext CRC in test buffer for PON */
+ uint32_t *buf32 = (uint32_t *) &test_buf[8 + params->buf_size - 4];
+ uint64_t *buf64 = (uint64_t *) test_buf;
+ const uint32_t *tag32 = (uint32_t *) job->auth_tag_output;
+ const uint64_t hec_mask = BSWAP64(0xfffffffffffe000);
+ const uint64_t xgem_hdr_out = ((const uint64_t *)job->src)[0];
+
+ if (params->buf_size >= 5)
+ buf32[0] = tag32[1];
+
+ /* Check if any bits apart from HEC are modified */
+ if ((xgem_hdr_out & hec_mask) != (xgem_hdr & hec_mask)) {
+ fprintf(stderr, "XGEM header overwritten outside HEC\n");
+ fprintf(stderr, "Original XGEM header: %"PRIx64"\n",
+ xgem_hdr & hec_mask );
+ fprintf(stderr, "Output XGEM header: %"PRIx64"\n",
+ xgem_hdr_out & hec_mask);
+ return -1;
+ }
+
+ /* Modify original XGEM header to include calculated HEC */
+ buf64[0] = xgem_hdr_out;
+
+ return 0;
+}
+
+/*
+ * Checks for sensitive information in registers, stack and MB_MGR
+ * (in this order, to try to minimize pollution of the data left out
+ * after the job completion, due to these actual checks).
+ *
+ * Returns -1 if sensitive information was found or 0 if not.
+ */
+static int
+perform_safe_checks(MB_MGR *mgr, const enum arch_type_e arch,
+ const char *dir)
+{
+ uint8_t *rsp_ptr;
+ uint32_t simd_size = 0;
+
+ dump_gps();
+ switch (arch) {
+ case ARCH_SSE:
+ case ARCH_AESNI_EMU:
+ dump_xmms_sse();
+ simd_size = XMM_MEM_SIZE;
+ break;
+ case ARCH_AVX:
+ dump_xmms_avx();
+ simd_size = XMM_MEM_SIZE;
+ break;
+ case ARCH_AVX2:
+ dump_ymms();
+ simd_size = YMM_MEM_SIZE;
+ break;
+ case ARCH_AVX512:
+ dump_zmms();
+ simd_size = ZMM_MEM_SIZE;
+ break;
+ default:
+ fprintf(stderr,
+ "Error getting the architecture\n");
+ return -1;
+ }
+ if (search_patterns(gps, GP_MEM_SIZE) == 0) {
+ fprintf(stderr, "Pattern found in GP registers "
+ "after %s data\n", dir);
+ return -1;
+ }
+ if (search_patterns(simd_regs, simd_size) == 0) {
+ fprintf(stderr, "Pattern found in SIMD "
+ "registers after %s data\n", dir);
+ return -1;
+ }
+ rsp_ptr = rdrsp();
+ if (search_patterns((rsp_ptr - STACK_DEPTH),
+ STACK_DEPTH) == 0) {
+ fprintf(stderr, "Pattern found in stack after "
+ "%s data\n", dir);
+ return -1;
+ }
+ if (search_patterns(mgr, sizeof(MB_MGR)) == 0) {
+ fprintf(stderr, "Pattern found in MB_MGR after "
+ "%s data\n", dir);
+ return -1;
+ }
+
+ return 0;
+}
+
+static void
+clear_scratch_simd(const enum arch_type_e arch)
+{
+ switch (arch) {
+ case ARCH_SSE:
+ case ARCH_AESNI_EMU:
+ clear_scratch_xmms_sse();
+ break;
+ case ARCH_AVX:
+ clear_scratch_xmms_avx();
+ break;
+ case ARCH_AVX2:
+ clear_scratch_ymms();
+ break;
+ case ARCH_AVX512:
+ clear_scratch_zmms();
+ break;
+ default:
+ fprintf(stderr, "Invalid architecture\n");
+ exit(EXIT_FAILURE);
+ }
+}
+
+/* Performs test using AES_HMAC or DOCSIS */
+static int
+do_test(MB_MGR *enc_mb_mgr, const enum arch_type_e enc_arch,
+ MB_MGR *dec_mb_mgr, const enum arch_type_e dec_arch,
+ const struct params_s *params, struct data *data,
+ const unsigned safe_check)
+{
+ JOB_AES_HMAC *job;
+ uint32_t i;
+ int ret = -1;
+ uint32_t buf_size = params->buf_size;
+ uint8_t tag_size = auth_tag_length_bytes[params->hash_alg - 1];
+ uint64_t xgem_hdr = 0;
+ uint8_t tag_size_to_check = 0;
+ struct cipher_auth_keys *enc_keys = &data->enc_keys;
+ struct cipher_auth_keys *dec_keys = &data->dec_keys;
+ uint8_t *aad = data->aad;
+ uint8_t *iv = data->iv;
+ uint8_t *in_digest = data->in_digest;
+ uint8_t *out_digest = data->out_digest;
+ uint8_t *test_buf = data->test_buf;
+ uint8_t *src_dst_buf = data->src_dst_buf;
+ uint8_t *key = data->key;
+
+ if (params->hash_alg == PON_CRC_BIP) {
+ /* Buf size is XGEM payload, including CRC,
+ * allocate space for XGEM header and padding */
+ buf_size = buf_size + 8;
+ if (buf_size % 8)
+ buf_size = (buf_size + 8) & 0xfffffff8;
+ /* Only first 4 bytes are checked, corresponding to BIP */
+ tag_size_to_check = 4;
+ }
+
+ /* If performing a test searching for sensitive information,
+ * set keys and plaintext to known values,
+ * so they can be searched later on in the MB_MGR structure and stack.
+ * Otherwise, just randomize the data */
+ if (safe_check) {
+ memset(test_buf, PT_PATTERN, buf_size);
+ memset(key, KEY_PATTERN, MAX_KEY_SIZE);
+ } else {
+ generate_random_buf(test_buf, buf_size);
+ generate_random_buf(key, MAX_KEY_SIZE);
+ generate_random_buf(iv, MAX_IV_SIZE);
+ generate_random_buf(aad, AAD_SIZE);
+ }
+
+ /* For PON, construct the XGEM header, setting valid PLI */
+ if (params->hash_alg == PON_CRC_BIP) {
+ /* create XGEM header template */
+ const uint64_t pli = ((params->buf_size) << 2) & 0xffff;
+ uint64_t *p_src = (uint64_t *)test_buf;
+
+ xgem_hdr = ((pli >> 8) & 0xff) | ((pli & 0xff) << 8);
+ p_src[0] = xgem_hdr;
+ }
+
+ /*
+ * Expand/schedule keys.
+ * If checking for sensitive information, first use actual
+ * key expansion functions and check the stack for left over
+ * information and then set a pattern in the expanded key memory
+ * to search for later on.
+ * If not checking for sensitive information, just use the key
+ * expansion functions.
+ */
+ if (safe_check) {
+ uint8_t *rsp_ptr;
+
+ /* Clear scratch registers before expanding keys to prevent
+ * other functions from storing sensitive data in stack */
+ clear_scratch_simd(enc_arch);
+ if (prepare_keys(enc_mb_mgr, enc_keys, key, params, 0) < 0)
+ goto exit;
+
+ rsp_ptr = rdrsp();
+ if (search_patterns((rsp_ptr - STACK_DEPTH),
+ STACK_DEPTH) == 0) {
+ fprintf(stderr, "Pattern found in stack after "
+ "expanding encryption keys\n");
+ goto exit;
+ }
+
+ if (prepare_keys(dec_mb_mgr, dec_keys, key, params, 0) < 0)
+ goto exit;
+
+ rsp_ptr = rdrsp();
+ if (search_patterns((rsp_ptr - STACK_DEPTH),
+ STACK_DEPTH) == 0) {
+ fprintf(stderr, "Pattern found in stack after "
+ "expanding decryption keys\n");
+ goto exit;
+ }
+
+ if (prepare_keys(enc_mb_mgr, enc_keys, key, params, 1) < 0)
+ goto exit;
+
+ if (prepare_keys(enc_mb_mgr, dec_keys, key, params, 1) < 0)
+ goto exit;
+ } else {
+ if (prepare_keys(enc_mb_mgr, enc_keys, key, params, 0) < 0)
+ goto exit;
+
+ if (prepare_keys(enc_mb_mgr, dec_keys, key, params, 0) < 0)
+ goto exit;
+ }
+
+ for (i = 0; i < job_iter; i++) {
+ job = IMB_GET_NEXT_JOB(enc_mb_mgr);
+ /*
+ * Encrypt + generate digest from encrypted message
+ * using architecture under test
+ */
+ memcpy(src_dst_buf, test_buf, buf_size);
+ if (fill_job(job, params, src_dst_buf, in_digest, aad,
+ buf_size, tag_size, ENCRYPT, enc_keys, iv) < 0)
+ goto exit;
+
+ /* Randomize memory for input digest */
+ generate_random_buf(in_digest, tag_size);
+
+ /* Clear scratch registers before submitting job to prevent
+ * other functions from storing sensitive data in stack */
+ if (safe_check)
+ clear_scratch_simd(enc_arch);
+ job = IMB_SUBMIT_JOB(enc_mb_mgr);
+
+ if (!job)
+ job = IMB_FLUSH_JOB(enc_mb_mgr);
+
+ if (!job) {
+ fprintf(stderr, "job not returned\n");
+ goto exit;
+ }
+
+ /* Check that the registers, stack and MB_MGR do not contain any
+ * sensitive information after job is returned */
+ if (safe_check)
+ if (perform_safe_checks(enc_mb_mgr, enc_arch,
+ "encrypting") < 0)
+ goto exit;
+
+ if (job->status != STS_COMPLETED) {
+ fprintf(stderr, "failed job, status:%d\n",
+ job->status);
+ goto exit;
+ }
+
+ if (params->hash_alg == PON_CRC_BIP) {
+ if (modify_pon_test_buf(test_buf, params, job,
+ xgem_hdr) < 0)
+ goto exit;
+ }
+
+ job = IMB_GET_NEXT_JOB(dec_mb_mgr);
+
+ /* Randomize memory for input digest */
+ generate_random_buf(out_digest, tag_size);
+
+ /*
+ * Generate digest from encrypted message and decrypt
+ * using reference architecture
+ */
+ if (fill_job(job, params, src_dst_buf, out_digest, aad,
+ buf_size, tag_size, DECRYPT, dec_keys, iv) < 0)
+ goto exit;
+
+ /* Clear scratch registers before submitting job to prevent
+ * other functions from storing sensitive data in stack */
+ if (safe_check)
+ clear_scratch_simd(dec_arch);
+ job = IMB_SUBMIT_JOB(dec_mb_mgr);
+
+ if (!job)
+ job = IMB_FLUSH_JOB(dec_mb_mgr);
+
+ /* Check that the registers, stack and MB_MGR do not contain any
+ * sensitive information after job is returned */
+ if (safe_check)
+ if (perform_safe_checks(dec_mb_mgr, dec_arch,
+ "decrypting") < 0)
+ goto exit;
+
+ if (!job) {
+ fprintf(stderr, "job not returned\n");
+ goto exit;
+ }
+
+ if (job->status != STS_COMPLETED) {
+ fprintf(stderr, "failed job, status:%d\n",
+ job->status);
+ goto exit;
+ }
+
+ if (params->hash_alg != NULL_HASH &&
+ memcmp(in_digest, out_digest, tag_size_to_check) != 0) {
+ fprintf(stderr,
+ "\nInput and output tags don't match\n");
+ byte_hexdump("Input digest", in_digest,
+ tag_size_to_check);
+ byte_hexdump("Output digest", out_digest,
+ tag_size_to_check);
+ goto exit;
+ }
+
+ if (params->cipher_mode != NULL_CIPHER &&
+ memcmp(src_dst_buf, test_buf, buf_size) != 0) {
+ fprintf(stderr,
+ "\nDecrypted text and plaintext don't match\n");
+ byte_hexdump("Plaintext (orig)", test_buf, buf_size);
+ byte_hexdump("Decrypted msg", src_dst_buf, buf_size);
+ goto exit;
+ }
+
+ if (params->hash_alg == PON_CRC_BIP && params->buf_size > 4) {
+ const uint64_t plen = params->buf_size - 4;
+
+ if (memcmp(src_dst_buf + 8 + plen,
+ out_digest + 4, 4) != 0) {
+ fprintf(stderr, "\nDecrypted CRC and calculated"
+ " CRC don't match\n");
+ byte_hexdump("Decrypted CRC",
+ src_dst_buf + 8 + plen, 4);
+ byte_hexdump("Calculated CRC",
+ out_digest + 4, 4);
+ goto exit;
+ }
+ }
+ }
+
+ ret = 0;
+
+exit:
+ if (ret < 0) {
+ printf("Failures in\n");
+ print_algo_info(params);
+ printf("Encrypting ");
+ print_arch_info(enc_arch);
+ printf("Decrypting ");
+ print_arch_info(dec_arch);
+ printf("Buffer size = %u\n", params->buf_size);
+ printf("Key size = %u\n", params->key_size);
+ printf("Tag size = %u\n", tag_size);
+ }
+
+ return ret;
+}
+
+/* Runs test for each buffer size */
+static void
+process_variant(MB_MGR *enc_mgr, const enum arch_type_e enc_arch,
+ MB_MGR *dec_mgr, const enum arch_type_e dec_arch,
+ struct params_s *params, struct data *variant_data,
+ const unsigned int safe_check)
+{
+ const uint32_t sizes = params->num_sizes;
+ uint32_t sz;
+
+ if (verbose) {
+ printf("Testing ");
+ print_algo_info(params);
+ }
+
+ /* Reset the variant data */
+ memset(variant_data, 0, sizeof(struct data));
+
+ for (sz = 0; sz < sizes; sz++) {
+ const uint32_t buf_size = job_sizes[RANGE_MIN] +
+ (sz * job_sizes[RANGE_STEP]);
+ params->aad_size = AAD_SIZE;
+
+ params->buf_size = buf_size;
+
+ /*
+ * CBC and ECB operation modes do not support lengths which are
+ * non-multiple of block size
+ */
+ if (params->cipher_mode == CBC || params->cipher_mode == ECB)
+ if ((buf_size % AES_BLOCK_SIZE) != 0)
+ continue;
+
+ if (params->cipher_mode == DES || params->cipher_mode == DES3)
+ if ((buf_size % DES_BLOCK_SIZE) != 0)
+ continue;
+
+ /* Check for sensitive data first, then normal cross
+ * architecture validation */
+ if (safe_check && do_test(enc_mgr, enc_arch, dec_mgr, dec_arch,
+ params, variant_data, 1) < 0)
+ exit(EXIT_FAILURE);
+
+ if (do_test(enc_mgr, enc_arch, dec_mgr, dec_arch,
+ params, variant_data, 0) < 0)
+ exit(EXIT_FAILURE);
+
+ }
+}
+
+/* Sets cipher direction and key size */
+static void
+run_test(const enum arch_type_e enc_arch, const enum arch_type_e dec_arch,
+ struct params_s *params, struct data *variant_data,
+ const unsigned int safe_check)
+{
+ MB_MGR *enc_mgr = NULL;
+ MB_MGR *dec_mgr = NULL;
+
+ if (enc_arch == ARCH_AESNI_EMU)
+ enc_mgr = alloc_mb_mgr(flags | IMB_FLAG_AESNI_OFF);
+ else
+ enc_mgr = alloc_mb_mgr(flags);
+
+ if (enc_mgr == NULL) {
+ fprintf(stderr, "MB MGR could not be allocated\n");
+ exit(EXIT_FAILURE);
+ }
+
+ /* Reset the MB MGR structure in case it is allocated with
+ * memory containing the patterns that will be searched later on */
+ if (safe_check)
+ memset(enc_mgr, 0, sizeof(MB_MGR));
+
+ switch (enc_arch) {
+ case ARCH_SSE:
+ case ARCH_AESNI_EMU:
+ init_mb_mgr_sse(enc_mgr);
+ break;
+ case ARCH_AVX:
+ init_mb_mgr_avx(enc_mgr);
+ break;
+ case ARCH_AVX2:
+ init_mb_mgr_avx2(enc_mgr);
+ break;
+ case ARCH_AVX512:
+ init_mb_mgr_avx512(enc_mgr);
+ break;
+ default:
+ fprintf(stderr, "Invalid architecture\n");
+ exit(EXIT_FAILURE);
+ }
+
+ if (dec_arch == ARCH_AESNI_EMU)
+ dec_mgr = alloc_mb_mgr(flags | IMB_FLAG_AESNI_OFF);
+ else
+ dec_mgr = alloc_mb_mgr(flags);
+
+ if (dec_mgr == NULL) {
+ fprintf(stderr, "MB MGR could not be allocated\n");
+ exit(EXIT_FAILURE);
+ }
+
+ /* Reset the MB MGR structure in case it is allocated with
+ * memory containing the patterns that will be searched later on */
+ if (safe_check)
+ memset(dec_mgr, 0, sizeof(MB_MGR));
+
+ switch (dec_arch) {
+ case ARCH_SSE:
+ case ARCH_AESNI_EMU:
+ init_mb_mgr_sse(dec_mgr);
+ break;
+ case ARCH_AVX:
+ init_mb_mgr_avx(dec_mgr);
+ break;
+ case ARCH_AVX2:
+ init_mb_mgr_avx2(dec_mgr);
+ break;
+ case ARCH_AVX512:
+ init_mb_mgr_avx512(dec_mgr);
+ break;
+ default:
+ fprintf(stderr, "Invalid architecture\n");
+ exit(EXIT_FAILURE);
+ }
+
+ if (custom_test) {
+ params->key_size = custom_job_params.key_size;
+ params->cipher_mode = custom_job_params.cipher_mode;
+ params->hash_alg = custom_job_params.hash_alg;
+ process_variant(enc_mgr, enc_arch, dec_mgr, dec_arch, params,
+ variant_data, safe_check);
+ goto exit;
+ }
+
+ JOB_HASH_ALG hash_alg;
+ JOB_CIPHER_MODE c_mode;
+
+ for (c_mode = CBC; c_mode <= CNTR_BITLEN; c_mode++) {
+ /* Skip CUSTOM_CIPHER */
+ if (c_mode == CUSTOM_CIPHER)
+ continue;
+ params->cipher_mode = c_mode;
+ uint8_t min_sz = key_sizes[c_mode - 1][0];
+ uint8_t max_sz = key_sizes[c_mode - 1][1];
+ uint8_t step_sz = key_sizes[c_mode - 1][2];
+ uint8_t key_sz;
+
+ for (key_sz = min_sz; key_sz <= max_sz; key_sz += step_sz) {
+ params->key_size = key_sz;
+ for (hash_alg = SHA1; hash_alg <= PON_CRC_BIP;
+ hash_alg++) {
+ /* Skip CUSTOM_HASH */
+ if (hash_alg == CUSTOM_HASH)
+ continue;
+
+ /* Skip not supported combinations */
+ if ((c_mode == GCM && hash_alg != AES_GMAC) ||
+ (c_mode != GCM && hash_alg == AES_GMAC))
+ continue;
+ if ((c_mode == CCM && hash_alg != AES_CCM) ||
+ (c_mode != CCM && hash_alg == AES_CCM))
+ continue;
+ if ((c_mode == PON_AES_CNTR &&
+ hash_alg != PON_CRC_BIP) ||
+ (c_mode != PON_AES_CNTR &&
+ hash_alg == PON_CRC_BIP))
+ continue;
+
+ params->hash_alg = hash_alg;
+ process_variant(enc_mgr, enc_arch, dec_mgr,
+ dec_arch, params, variant_data,
+ safe_check);
+ }
+ }
+ }
+
+exit:
+ free_mb_mgr(enc_mgr);
+ free_mb_mgr(dec_mgr);
+}
+
+/* Prepares data structure for test variants storage,
+ * sets test configuration
+ */
+static void
+run_tests(const unsigned int safe_check)
+{
+ struct params_s params;
+ struct data *variant_data = NULL;
+ enum arch_type_e enc_arch, dec_arch;
+ const uint32_t min_size = job_sizes[RANGE_MIN];
+ const uint32_t max_size = job_sizes[RANGE_MAX];
+ const uint32_t step_size = job_sizes[RANGE_STEP];
+
+ params.num_sizes = ((max_size - min_size) / step_size) + 1;
+
+ variant_data = malloc(sizeof(struct data));
+
+ if (variant_data == NULL) {
+ fprintf(stderr, "Test data could not be allocated\n");
+ exit(EXIT_FAILURE);
+ }
+
+ if (verbose) {
+ if (min_size == max_size)
+ printf("Testing buffer size = %u bytes\n", min_size);
+ else
+ printf("Testing buffer sizes from %u to %u "
+ "in steps of %u bytes\n",
+ min_size, max_size, step_size);
+ }
+ /* Performing tests for each selected architecture */
+ for (enc_arch = ARCH_SSE; enc_arch < NUM_ARCHS; enc_arch++) {
+ if (enc_archs[enc_arch] == 0)
+ continue;
+ printf("\nEncrypting with ");
+ print_arch_info(enc_arch);
+
+ for (dec_arch = ARCH_SSE; dec_arch < NUM_ARCHS; dec_arch++) {
+ if (dec_archs[dec_arch] == 0)
+ continue;
+ printf("\tDecrypting with ");
+ print_arch_info(dec_arch);
+ run_test(enc_arch, dec_arch, &params, variant_data,
+ safe_check);
+ }
+
+ } /* end for run */
+
+ free(variant_data);
+}
+
+static void usage(void)
+{
+ fprintf(stderr, "Usage: exhaustive_test [args], "
+ "where args are zero or more\n"
+ "-h: print this message\n"
+ "-v: verbose, prints extra information\n"
+ "--enc-arch: encrypting with architecture "
+ "(AESNI_EMU/SSE/AVX/AVX2/AVX512)\n"
+ "--dec-arch: decrypting with architecture "
+ "(AESNI_EMU/SSE/AVX/AVX2/AVX512)\n"
+ "--cipher-algo: Select cipher algorithm to run on the custom "
+ "test\n"
+ "--hash-algo: Select hash algorithm to run on the custom test\n"
+ "--aead-algo: Select AEAD algorithm to run on the custom test\n"
+ "--no-avx512: Don't do AVX512\n"
+ "--no-avx2: Don't do AVX2\n"
+ "--no-avx: Don't do AVX\n"
+ "--no-sse: Don't do SSE\n"
+ "--aesni-emu: Do AESNI_EMU (disabled by default)\n"
+ "--shani-on: use SHA extensions, default: auto-detect\n"
+ "--shani-off: don't use SHA extensions\n"
+ "--job-size: size of the cipher & MAC job in bytes. "
+ "It can be:\n"
+ " - single value: test single size\n"
+ " - range: test multiple sizes with following format"
+ " min:step:max (e.g. 16:16:256)\n"
+ " (-o still applies for MAC)\n"
+ "--job-iter: number of tests iterations for each job size\n"
+ "--safe-check: check if keys, IVs, plaintext or tags "
+ "get cleared from MB_MGR upon job completion (off by default; "
+ "requires library compiled with SAFE_DATA)\n");
+}
+
+static int
+get_next_num_arg(const char * const *argv, const int index, const int argc,
+ void *dst, const size_t dst_size)
+{
+ char *endptr = NULL;
+ uint64_t val;
+
+ if (dst == NULL || argv == NULL || index < 0 || argc < 0) {
+ fprintf(stderr, "%s() internal error!\n", __func__);
+ exit(EXIT_FAILURE);
+ }
+
+ if (index >= (argc - 1)) {
+ fprintf(stderr, "'%s' requires an argument!\n", argv[index]);
+ exit(EXIT_FAILURE);
+ }
+
+#ifdef _WIN32
+ val = _strtoui64(argv[index + 1], &endptr, 0);
+#else
+ val = strtoull(argv[index + 1], &endptr, 0);
+#endif
+ if (endptr == argv[index + 1] || (endptr != NULL && *endptr != '\0')) {
+ fprintf(stderr, "Error converting '%s' as value for '%s'!\n",
+ argv[index + 1], argv[index]);
+ exit(EXIT_FAILURE);
+ }
+
+ switch (dst_size) {
+ case (sizeof(uint8_t)):
+ *((uint8_t *)dst) = (uint8_t) val;
+ break;
+ case (sizeof(uint16_t)):
+ *((uint16_t *)dst) = (uint16_t) val;
+ break;
+ case (sizeof(uint32_t)):
+ *((uint32_t *)dst) = (uint32_t) val;
+ break;
+ case (sizeof(uint64_t)):
+ *((uint64_t *)dst) = val;
+ break;
+ default:
+ fprintf(stderr, "%s() invalid dst_size %u!\n",
+ __func__, (unsigned) dst_size);
+ exit(EXIT_FAILURE);
+ break;
+ }
+
+ return index + 1;
+}
+
+static int
+detect_arch(unsigned int arch_support[NUM_ARCHS])
+{
+ const uint64_t detect_sse =
+ IMB_FEATURE_SSE4_2 | IMB_FEATURE_CMOV | IMB_FEATURE_AESNI;
+ const uint64_t detect_avx =
+ IMB_FEATURE_AVX | IMB_FEATURE_CMOV | IMB_FEATURE_AESNI;
+ const uint64_t detect_avx2 = IMB_FEATURE_AVX2 | detect_avx;
+ const uint64_t detect_avx512 = IMB_FEATURE_AVX512_SKX | detect_avx2;
+ MB_MGR *p_mgr = NULL;
+ enum arch_type_e arch_id;
+
+ if (arch_support == NULL) {
+ fprintf(stderr, "Array not passed correctly\n");
+ return -1;
+ }
+
+ for (arch_id = ARCH_SSE; arch_id < NUM_ARCHS; arch_id++)
+ arch_support[arch_id] = 1;
+
+ p_mgr = alloc_mb_mgr(0);
+ if (p_mgr == NULL) {
+ fprintf(stderr, "Architecture detect error!\n");
+ return -1;
+ }
+
+ if ((p_mgr->features & detect_avx512) != detect_avx512)
+ arch_support[ARCH_AVX512] = 0;
+
+ if ((p_mgr->features & detect_avx2) != detect_avx2)
+ arch_support[ARCH_AVX2] = 0;
+
+ if ((p_mgr->features & detect_avx) != detect_avx)
+ arch_support[ARCH_AVX] = 0;
+
+ if ((p_mgr->features & detect_sse) != detect_sse) {
+ arch_support[ARCH_SSE] = 0;
+ arch_support[ARCH_AESNI_EMU] = 0;
+ }
+
+ free_mb_mgr(p_mgr);
+
+ return 0;
+}
+
+/*
+ * Check string argument is supported and if it is, return values associated
+ * with it.
+ */
+static const union params *
+check_string_arg(const char *param, const char *arg,
+ const struct str_value_mapping *map,
+ const unsigned int num_avail_opts)
+{
+ unsigned int i;
+
+ if (arg == NULL) {
+ fprintf(stderr, "%s requires an argument\n", param);
+ goto exit;
+ }
+
+ for (i = 0; i < num_avail_opts; i++)
+ if (strcmp(arg, map[i].name) == 0)
+ return &(map[i].values);
+
+ /* Argument is not listed in the available options */
+ fprintf(stderr, "Invalid argument for %s\n", param);
+exit:
+ fprintf(stderr, "Accepted arguments: ");
+ for (i = 0; i < num_avail_opts; i++)
+ fprintf(stderr, "%s ", map[i].name);
+ fprintf(stderr, "\n");
+
+ return NULL;
+}
+
+static int
+parse_range(const char * const *argv, const int index, const int argc,
+ uint32_t range_values[NUM_RANGE])
+{
+ char *token;
+ uint32_t number;
+ unsigned int i;
+
+
+ if (range_values == NULL || argv == NULL || index < 0 || argc < 0) {
+ fprintf(stderr, "%s() internal error!\n", __func__);
+ exit(EXIT_FAILURE);
+ }
+
+ if (index >= (argc - 1)) {
+ fprintf(stderr, "'%s' requires an argument!\n", argv[index]);
+ exit(EXIT_FAILURE);
+ }
+
+ char *copy_arg = strdup(argv[index + 1]);
+
+ if (copy_arg == NULL) {
+ fprintf(stderr, "%s() internal error!\n", __func__);
+ exit(EXIT_FAILURE);
+ }
+
+ errno = 0;
+ token = strtok(copy_arg, ":");
+
+ /* Try parsing range (minimum, step and maximum values) */
+ for (i = 0; i < NUM_RANGE; i++) {
+ if (token == NULL)
+ goto no_range;
+
+ number = strtoul(token, NULL, 10);
+
+ if (errno != 0)
+ goto no_range;
+
+ range_values[i] = number;
+ token = strtok(NULL, ":");
+ }
+
+ if (token != NULL)
+ goto no_range;
+
+ if (range_values[RANGE_MAX] < range_values[RANGE_MIN]) {
+ fprintf(stderr, "Maximum value of range cannot be lower "
+ "than minimum value\n");
+ exit(EXIT_FAILURE);
+ }
+
+ if (range_values[RANGE_STEP] == 0) {
+ fprintf(stderr, "Step value in range cannot be 0\n");
+ exit(EXIT_FAILURE);
+ }
+
+ goto end_range;
+no_range:
+ /* Try parsing as single value */
+ get_next_num_arg(argv, index, argc, &job_sizes[RANGE_MIN],
+ sizeof(job_sizes[RANGE_MIN]));
+
+ job_sizes[RANGE_MAX] = job_sizes[RANGE_MIN];
+
+end_range:
+ free(copy_arg);
+ return (index + 1);
+
+}
+
+int main(int argc, char *argv[])
+{
+ int i;
+ unsigned int arch_id;
+ unsigned int arch_support[NUM_ARCHS];
+ const union params *values;
+ unsigned int cipher_algo_set = 0;
+ unsigned int hash_algo_set = 0;
+ unsigned int aead_algo_set = 0;
+ unsigned int safe_check = 0;
+
+ for (i = 1; i < argc; i++)
+ if (strcmp(argv[i], "-h") == 0) {
+ usage();
+ return EXIT_SUCCESS;
+ } else if (strcmp(argv[i], "-v") == 0) {
+ verbose = 1;
+ } else if (strcmp(argv[i], "--no-avx512") == 0) {
+ enc_archs[ARCH_AVX512] = 0;
+ dec_archs[ARCH_AVX512] = 0;
+ } else if (strcmp(argv[i], "--no-avx2") == 0) {
+ enc_archs[ARCH_AVX2] = 0;
+ dec_archs[ARCH_AVX2] = 0;
+ } else if (strcmp(argv[i], "--no-avx") == 0) {
+ enc_archs[ARCH_AVX] = 0;
+ dec_archs[ARCH_AVX] = 0;
+ } else if (strcmp(argv[i], "--no-sse") == 0) {
+ enc_archs[ARCH_SSE] = 0;
+ dec_archs[ARCH_SSE] = 0;
+ } else if (strcmp(argv[i], "--aesni-emu") == 0) {
+ enc_archs[ARCH_AESNI_EMU] = 1;
+ dec_archs[ARCH_AESNI_EMU] = 1;
+ } else if (strcmp(argv[i], "--shani-on") == 0) {
+ flags &= (~IMB_FLAG_SHANI_OFF);
+ } else if (strcmp(argv[i], "--shani-off") == 0) {
+ flags |= IMB_FLAG_SHANI_OFF;
+ } else if (strcmp(argv[i], "--enc-arch") == 0) {
+ values = check_string_arg(argv[i], argv[i+1],
+ arch_str_map,
+ DIM(arch_str_map));
+ if (values == NULL)
+ return EXIT_FAILURE;
+
+ /*
+ * Disable all the other architectures
+ * and enable only the specified
+ */
+ memset(enc_archs, 0, sizeof(enc_archs));
+ enc_archs[values->arch_type] = 1;
+ i++;
+ } else if (strcmp(argv[i], "--dec-arch") == 0) {
+ values = check_string_arg(argv[i], argv[i+1],
+ arch_str_map,
+ DIM(arch_str_map));
+ if (values == NULL)
+ return EXIT_FAILURE;
+
+ /*
+ * Disable all the other architectures
+ * and enable only the specified
+ */
+ memset(dec_archs, 0, sizeof(dec_archs));
+ dec_archs[values->arch_type] = 1;
+ i++;
+ } else if (strcmp(argv[i], "--cipher-algo") == 0) {
+ values = check_string_arg(argv[i], argv[i+1],
+ cipher_algo_str_map,
+ DIM(cipher_algo_str_map));
+ if (values == NULL)
+ return EXIT_FAILURE;
+
+ custom_job_params.cipher_mode =
+ values->job_params.cipher_mode;
+ custom_job_params.key_size =
+ values->job_params.key_size;
+ custom_test = 1;
+ cipher_algo_set = 1;
+ i++;
+ } else if (strcmp(argv[i], "--hash-algo") == 0) {
+ values = check_string_arg(argv[i], argv[i+1],
+ hash_algo_str_map,
+ DIM(hash_algo_str_map));
+ if (values == NULL)
+ return EXIT_FAILURE;
+
+ custom_job_params.hash_alg =
+ values->job_params.hash_alg;
+ custom_test = 1;
+ hash_algo_set = 1;
+ i++;
+ } else if (strcmp(argv[i], "--aead-algo") == 0) {
+ values = check_string_arg(argv[i], argv[i+1],
+ aead_algo_str_map,
+ DIM(aead_algo_str_map));
+ if (values == NULL)
+ return EXIT_FAILURE;
+
+ custom_job_params.cipher_mode =
+ values->job_params.cipher_mode;
+ custom_job_params.key_size =
+ values->job_params.key_size;
+ custom_job_params.hash_alg =
+ values->job_params.hash_alg;
+ custom_test = 1;
+ aead_algo_set = 1;
+ i++;
+ } else if (strcmp(argv[i], "--job-size") == 0) {
+ /* Try parsing the argument as a range first */
+ i = parse_range((const char * const *)argv, i, argc,
+ job_sizes);
+ if (job_sizes[RANGE_MAX] > JOB_SIZE_TOP) {
+ fprintf(stderr,
+ "Invalid job size %u (max %u)\n",
+ (unsigned) job_sizes[RANGE_MAX],
+ JOB_SIZE_TOP);
+ return EXIT_FAILURE;
+ }
+ } else if (strcmp(argv[i], "--job-iter") == 0) {
+ i = get_next_num_arg((const char * const *)argv, i,
+ argc, &job_iter, sizeof(job_iter));
+ } else if (strcmp(argv[i], "--safe-check") == 0) {
+ safe_check = 1;
+ } else {
+ usage();
+ return EXIT_FAILURE;
+ }
+
+ if (custom_test) {
+ if (aead_algo_set && (cipher_algo_set || hash_algo_set)) {
+ fprintf(stderr, "AEAD algorithm cannot be used "
+ "combined with another cipher/hash "
+ "algorithm\n");
+ return EXIT_FAILURE;
+ }
+ }
+
+ if (job_sizes[RANGE_MIN] == 0) {
+ fprintf(stderr, "Buffer size cannot be 0 unless only "
+ "an AEAD algorithm is tested\n");
+ return EXIT_FAILURE;
+ }
+
+ if (detect_arch(arch_support) < 0)
+ return EXIT_FAILURE;
+
+ /* disable tests depending on instruction sets supported */
+ for (arch_id = 0; arch_id < NUM_ARCHS; arch_id++) {
+ if (arch_support[arch_id] == 0) {
+ enc_archs[arch_id] = 0;
+ dec_archs[arch_id] = 0;
+ fprintf(stderr,
+ "%s not supported. Disabling %s tests\n",
+ arch_str_map[arch_id].name,
+ arch_str_map[arch_id].name);
+ }
+ }
+
+ MB_MGR *p_mgr = alloc_mb_mgr(flags);
+ if (p_mgr == NULL) {
+ fprintf(stderr, "Error allocating MB_MGR structure!\n");
+ return EXIT_FAILURE;
+ }
+
+ if (safe_check && ((p_mgr->features & IMB_FEATURE_SAFE_DATA) == 0)) {
+ fprintf(stderr, "Library needs to be compiled with SAFE_DATA "
+ "if --safe-check is enabled\n");
+ free_mb_mgr(p_mgr);
+ return EXIT_FAILURE;
+ }
+ if (enc_archs[ARCH_SSE] || dec_archs[ARCH_SSE]) {
+ init_mb_mgr_sse(p_mgr);
+ fprintf(stderr, "%s SHA extensions (shani) for SSE arch\n",
+ (p_mgr->features & IMB_FEATURE_SHANI) ?
+ "Using" : "Not using");
+ }
+ free_mb_mgr(p_mgr);
+
+ srand(SEED);
+
+ run_tests(safe_check);
+
+ return EXIT_SUCCESS;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-08 21:18:58 +0000