[dpdk-dev] [PATCH v2] test/crypto: remove crypto perf tests
Pablo de Lara
pablo.de.lara.guarch at intel.com
Wed Oct 4 08:48:38 CEST 2017
Since the crypto perf application is flexible enough
to cover all the crypto performance tests, these are not needed
anymore, so they will be removed to avoid duplications.
Besides, the crypto perf application gives the user more options
to get performance, for every single supported algorithm,
such as varying the buffer size as the user wants.
Signed-off-by: Pablo de Lara <pablo.de.lara.guarch at intel.com>
---
Changes in v2:
- Rebased against latest code
- Added note in release notes
doc/guides/rel_notes/release_17_11.rst | 15 +
test/test/Makefile | 1 -
test/test/test_cryptodev_perf.c | 4932 --------------------------------
3 files changed, 15 insertions(+), 4933 deletions(-)
delete mode 100644 test/test/test_cryptodev_perf.c
diff --git a/doc/guides/rel_notes/release_17_11.rst b/doc/guides/rel_notes/release_17_11.rst
index ebb5021..58e614b 100644
--- a/doc/guides/rel_notes/release_17_11.rst
+++ b/doc/guides/rel_notes/release_17_11.rst
@@ -164,6 +164,21 @@ ABI Changes
=========================================================
+Removed Items
+-------------
+
+.. This section should contain removed items in this release. Sample format:
+
+ * Add a short 1-2 sentence description of the removed item in the past
+ tense.
+
+ This section is a comment. do not overwrite or remove it.
+ Also, make sure to start the actual text at the margin.
+ =========================================================
+
+* The crypto performance unit tests have been removed, substituted
+ by the dpdk-test-crypto-perf application.
+
Shared Library Versions
-----------------------
diff --git a/test/test/Makefile b/test/test/Makefile
index 42d9a49..de360e3 100644
--- a/test/test/Makefile
+++ b/test/test/Makefile
@@ -198,7 +198,6 @@ SRCS-$(CONFIG_RTE_LIBRTE_PMD_RING) += test_pmd_ring.c
SRCS-$(CONFIG_RTE_LIBRTE_PMD_RING) += test_pmd_ring_perf.c
SRCS-$(CONFIG_RTE_LIBRTE_CRYPTODEV) += test_cryptodev_blockcipher.c
-SRCS-$(CONFIG_RTE_LIBRTE_CRYPTODEV) += test_cryptodev_perf.c
SRCS-$(CONFIG_RTE_LIBRTE_CRYPTODEV) += test_cryptodev.c
ifeq ($(CONFIG_RTE_LIBRTE_EVENTDEV),y)
diff --git a/test/test/test_cryptodev_perf.c b/test/test/test_cryptodev_perf.c
deleted file mode 100644
index 3b57e6d..0000000
--- a/test/test/test_cryptodev_perf.c
+++ /dev/null
@@ -1,4932 +0,0 @@
-/*-
- * BSD LICENSE
- *
- * Copyright(c) 2015-2017 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 <rte_common.h>
-#include <rte_mbuf.h>
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
-#include <rte_crypto.h>
-#include <rte_cryptodev.h>
-#include <rte_cycles.h>
-
-#include "test.h"
-#include "test_cryptodev.h"
-#include "test_cryptodev_gcm_test_vectors.h"
-
-#define AES_CIPHER_IV_LENGTH 16
-#define TRIPLE_DES_CIPHER_IV_LENGTH 8
-#define AES_GCM_AAD_LENGTH 16
-
-#define PERF_NUM_OPS_INFLIGHT (128)
-#define DEFAULT_NUM_REQS_TO_SUBMIT (10000000)
-
-struct crypto_testsuite_params {
- struct rte_mempool *mbuf_mp;
- struct rte_mempool *op_mpool;
- struct rte_mempool *sess_mp;
-
- uint16_t nb_queue_pairs;
-
- struct rte_cryptodev_config conf;
- struct rte_cryptodev_qp_conf qp_conf;
- uint8_t dev_id;
-};
-
-enum chain_mode {
- CIPHER_HASH,
- HASH_CIPHER,
- CIPHER_ONLY,
- HASH_ONLY,
- AEAD
-};
-
-
-struct symmetric_op {
- const uint8_t *aad_data;
-
- const uint8_t *p_data;
- uint32_t p_len;
-
- const uint8_t *c_data;
- uint32_t c_len;
-
- const uint8_t *t_data;
- uint32_t t_len;
-
-};
-
-struct symmetric_session_attrs {
- enum rte_crypto_cipher_operation cipher;
- enum rte_crypto_auth_operation auth;
- enum rte_crypto_aead_operation aead;
-
- enum rte_crypto_cipher_algorithm cipher_algorithm;
- const uint8_t *key_cipher_data;
- uint32_t key_cipher_len;
-
- enum rte_crypto_auth_algorithm auth_algorithm;
- const uint8_t *key_auth_data;
- uint32_t key_auth_len;
-
- enum rte_crypto_aead_algorithm aead_algorithm;
- const uint8_t *key_aead_data;
- uint32_t key_aead_len;
-
- const uint8_t *iv_data;
- uint16_t iv_len;
- uint16_t aad_len;
- uint32_t digest_len;
-};
-
-static struct rte_cryptodev_sym_session *test_crypto_session;
-
-#define ALIGN_POW2_ROUNDUP(num, align) \
- (((num) + (align) - 1) & ~((align) - 1))
-
-/*
- * This struct is needed to avoid unnecessary allocation or checking
- * of allocation of crypto params with current alloc on the fly
- * implementation.
- */
-
-struct crypto_params {
- uint8_t *aad;
- uint8_t *digest;
-};
-
-struct perf_test_params {
-
- unsigned total_operations;
- unsigned burst_size;
- unsigned buf_size;
-
- enum chain_mode chain;
-
- enum rte_crypto_cipher_algorithm cipher_algo;
- unsigned int key_length;
- enum rte_crypto_auth_algorithm auth_algo;
- enum rte_crypto_aead_algorithm aead_algo;
-
- struct symmetric_session_attrs *session_attrs;
-
- struct symmetric_op *symmetric_op;
-};
-
-#define MAX_NUM_OF_OPS_PER_UT (128)
-
-struct crypto_unittest_params {
- struct rte_crypto_sym_xform cipher_xform;
- struct rte_crypto_sym_xform auth_xform;
-
- struct rte_cryptodev_sym_session *sess;
-
- struct rte_crypto_op *op;
-
- struct rte_mbuf *obuf[MAX_NUM_OF_OPS_PER_UT];
- struct rte_mbuf *ibuf[MAX_NUM_OF_OPS_PER_UT];
-
- uint8_t *digest;
-};
-
-static int
-test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
- enum rte_crypto_cipher_algorithm cipher_algo,
- unsigned int cipher_key_len,
- enum rte_crypto_auth_algorithm auth_algo);
-static int
-test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain,
- enum rte_crypto_cipher_algorithm cipher_algo,
- unsigned int cipher_key_len,
- enum rte_crypto_auth_algorithm auth_algo,
- enum rte_crypto_aead_algorithm aead_algo);
-static int
-test_perf_create_armv8_session(uint8_t dev_id, enum chain_mode chain,
- enum rte_crypto_cipher_algorithm cipher_algo,
- unsigned int cipher_key_len,
- enum rte_crypto_auth_algorithm auth_algo);
-
-static struct rte_mbuf *
-test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz);
-static inline struct rte_crypto_op *
-test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
- struct rte_cryptodev_sym_session *sess, unsigned int data_len);
-static inline struct rte_crypto_op *
-test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m,
- struct rte_cryptodev_sym_session *sess, unsigned int data_len,
- enum chain_mode chain);
-static inline struct rte_crypto_op *
-test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
- struct rte_cryptodev_sym_session *sess, unsigned int data_len,
- enum chain_mode chain __rte_unused);
-static inline struct rte_crypto_op *
-test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
- struct rte_cryptodev_sym_session *sess, unsigned int data_len,
- enum chain_mode chain __rte_unused);
-static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo);
-
-
-static const char *chain_mode_name(enum chain_mode mode)
-{
- switch (mode) {
- case CIPHER_HASH: return "cipher_hash"; break;
- case HASH_CIPHER: return "hash_cipher"; break;
- case CIPHER_ONLY: return "cipher_only"; break;
- case HASH_ONLY: return "hash_only"; break;
- case AEAD: return "aead"; break;
- default: return ""; break;
- }
-}
-
-static const char *pmd_name(uint8_t driver_id)
-{
- uint8_t null_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_NULL_PMD));
- uint8_t dpaa2_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
- uint8_t snow3g_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
- uint8_t aesni_gcm_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
- uint8_t aesni_mb_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
- uint8_t qat_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
-
- if (driver_id == null_pmd)
- return RTE_STR(CRYPTODEV_NAME_NULL_PMD);
- else if (driver_id == aesni_gcm_pmd)
- return RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD);
- else if (driver_id == aesni_mb_pmd)
- return RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD);
- else if (driver_id == qat_pmd)
- return RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
- else if (driver_id == snow3g_pmd)
- return RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD);
- else if (driver_id == dpaa2_pmd)
- return RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
- else
- return "";
-}
-
-static struct rte_mbuf *
-setup_test_string(struct rte_mempool *mpool,
- const uint8_t *data, size_t len, uint8_t blocksize)
-{
- struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
- size_t t_len = len - (blocksize ? (len % blocksize) : 0);
-
- if (m) {
- char *dst = rte_pktmbuf_append(m, t_len);
-
- if (!dst) {
- rte_pktmbuf_free(m);
- return NULL;
- }
-
- rte_memcpy(dst, (const void *)data, t_len);
- }
- return m;
-}
-
-static struct crypto_testsuite_params testsuite_params = { NULL };
-static struct crypto_unittest_params unittest_params;
-static int gbl_driver_id;
-
-static int
-testsuite_setup(void)
-{
- struct crypto_testsuite_params *ts_params = &testsuite_params;
- struct rte_cryptodev_info info;
- unsigned i, nb_devs, valid_dev_id = 0;
- int ret;
- uint16_t qp_id;
-
- ts_params->mbuf_mp = rte_mempool_lookup("CRYPTO_PERF_MBUFPOOL");
- if (ts_params->mbuf_mp == NULL) {
- /* Not already created so create */
- ts_params->mbuf_mp = rte_pktmbuf_pool_create(
- "CRYPTO_PERF_MBUFPOOL",
- NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
- rte_socket_id());
- if (ts_params->mbuf_mp == NULL) {
- RTE_LOG(ERR, USER1, "Can't create CRYPTO_PERF_MBUFPOOL\n");
- return TEST_FAILED;
- }
- }
-
-
- ts_params->op_mpool = rte_crypto_op_pool_create("CRYPTO_OP_POOL",
- RTE_CRYPTO_OP_TYPE_SYMMETRIC,
- NUM_MBUFS, MBUF_CACHE_SIZE,
- DEFAULT_NUM_XFORMS *
- sizeof(struct rte_crypto_sym_xform) +
- MAXIMUM_IV_LENGTH,
- rte_socket_id());
- if (ts_params->op_mpool == NULL) {
- RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
- return TEST_FAILED;
- }
-
- /* Create an AESNI MB device if required */
- if (gbl_driver_id == rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) {
- nb_devs = rte_cryptodev_device_count_by_driver(
- rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
- if (nb_devs < 1) {
- ret = rte_vdev_init(
- RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
-
- TEST_ASSERT(ret == 0,
- "Failed to create instance of pmd : %s",
- RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
- }
- }
-
- /* Create an AESNI GCM device if required */
- if (gbl_driver_id == rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD))) {
- nb_devs = rte_cryptodev_device_count_by_driver(
- rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)));
- if (nb_devs < 1) {
- ret = rte_vdev_init(
- RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL);
-
- TEST_ASSERT(ret == 0,
- "Failed to create instance of pmd : %s",
- RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
- }
- }
-
- /* Create a SNOW3G device if required */
- if (gbl_driver_id == rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD))) {
- nb_devs = rte_cryptodev_device_count_by_driver(
- rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD)));
- if (nb_devs < 1) {
- ret = rte_vdev_init(
- RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL);
-
- TEST_ASSERT(ret == 0,
- "Failed to create instance of pmd : %s",
- RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
- }
- }
-
- /* Create an OPENSSL device if required */
- if (gbl_driver_id == rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))) {
- nb_devs = rte_cryptodev_device_count_by_driver(
- rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)));
- if (nb_devs < 1) {
- ret = rte_vdev_init(
- RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
- NULL);
-
- TEST_ASSERT(ret == 0, "Failed to create "
- "instance of pmd : %s",
- RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
- }
- }
-
- /* Create an ARMv8 device if required */
- if (gbl_driver_id == rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_ARMV8_PMD))) {
- nb_devs = rte_cryptodev_device_count_by_driver(
- rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)));
- if (nb_devs < 1) {
- ret = rte_vdev_init(
- RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
- NULL);
-
- TEST_ASSERT(ret == 0, "Failed to create "
- "instance of pmd : %s",
- RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
- }
- }
-
- nb_devs = rte_cryptodev_count();
- if (nb_devs < 1) {
- RTE_LOG(ERR, USER1, "No crypto devices found?\n");
- return TEST_FAILED;
- }
-
- /* Search for the first valid */
- for (i = 0; i < nb_devs; i++) {
- rte_cryptodev_info_get(i, &info);
- if (info.driver_id == (uint8_t) gbl_driver_id) {
- ts_params->dev_id = i;
- valid_dev_id = 1;
- break;
- }
- }
-
- if (!valid_dev_id)
- return TEST_FAILED;
-
- /*
- * Using Crypto Device Id 0 by default.
- * Set up all the qps on this device
- */
-
- rte_cryptodev_info_get(ts_params->dev_id, &info);
-
- ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
- ts_params->conf.socket_id = SOCKET_ID_ANY;
-
- unsigned int session_size = sizeof(struct rte_cryptodev_sym_session) +
- rte_cryptodev_get_private_session_size(ts_params->dev_id);
-
- ts_params->sess_mp = rte_mempool_create(
- "test_sess_mp_perf",
- info.sym.max_nb_sessions,
- session_size,
- 0, 0, NULL, NULL, NULL,
- NULL, SOCKET_ID_ANY,
- 0);
-
- TEST_ASSERT_NOT_NULL(ts_params->sess_mp,
- "session mempool allocation failed");
-
- TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->dev_id,
- &ts_params->conf),
- "Failed to configure cryptodev %u",
- ts_params->dev_id);
-
- ts_params->qp_conf.nb_descriptors = PERF_NUM_OPS_INFLIGHT;
- for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
-
- TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
- ts_params->dev_id, qp_id,
- &ts_params->qp_conf,
- rte_cryptodev_socket_id(ts_params->dev_id),
- ts_params->sess_mp),
- "Failed to setup queue pair %u on cryptodev %u",
- qp_id, ts_params->dev_id);
- }
-
- return TEST_SUCCESS;
-}
-static void
-testsuite_teardown(void)
-{
- struct crypto_testsuite_params *ts_params =
- &testsuite_params;
-
- if (ts_params->mbuf_mp != NULL)
- RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_MBUFPOOL count %u\n",
- rte_mempool_avail_count(ts_params->mbuf_mp));
- if (ts_params->op_mpool != NULL)
- RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_OP POOL count %u\n",
- rte_mempool_avail_count(ts_params->op_mpool));
- /* Free session mempool */
- if (ts_params->sess_mp != NULL) {
- rte_mempool_free(ts_params->sess_mp);
- ts_params->sess_mp = NULL;
- }
-
-}
-
-static int
-ut_setup(void)
-{
- struct crypto_testsuite_params *ts_params = &testsuite_params;
- struct crypto_unittest_params *ut_params = &unittest_params;
-
- /* Clear unit test parameters before running test */
- memset(ut_params, 0, sizeof(*ut_params));
-
- rte_cryptodev_stats_reset(ts_params->dev_id);
-
- /* Start the device */
- TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->dev_id),
- "Failed to start cryptodev %u",
- ts_params->dev_id);
-
- return TEST_SUCCESS;
-}
-
-static void
-ut_teardown(void)
-{
- struct crypto_testsuite_params *ts_params = &testsuite_params;
- struct crypto_unittest_params *ut_params = &unittest_params;
- struct rte_cryptodev_stats stats;
-
- unsigned i;
-
- /* free crypto session structure */
- if (ut_params->sess) {
- rte_cryptodev_sym_session_clear(ts_params->dev_id,
- ut_params->sess);
- rte_cryptodev_sym_session_free(ut_params->sess);
- }
-
- /* free crypto operation structure */
- if (ut_params->op)
- rte_crypto_op_free(ut_params->op);
-
- for (i = 0; i < MAX_NUM_OF_OPS_PER_UT; i++) {
- if (ut_params->obuf[i])
- rte_pktmbuf_free(ut_params->obuf[i]);
- else if (ut_params->ibuf[i])
- rte_pktmbuf_free(ut_params->ibuf[i]);
- }
-
- if (ts_params->mbuf_mp != NULL)
- RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_MBUFPOOL count %u\n",
- rte_mempool_avail_count(ts_params->mbuf_mp));
-
- rte_cryptodev_stats_get(ts_params->dev_id, &stats);
-
- /* Stop the device */
- rte_cryptodev_stop(ts_params->dev_id);
-}
-
-const char plaintext_quote[] =
- "THE COUNT OF MONTE CRISTO by Alexandre Dumas, Pere Chapter 1. "
- "Marseilles--The Arrival. On the 24th of February, 1815, the "
- "look-out at Notre-Dame de la Garde signalled the three-master,"
- " the Pharaon from Smyrna, Trieste, and Naples. As usual, a "
- "pilot put off immediately, and rounding the Chateau d'If, got "
- "on board the vessel between Cape Morgion and Rion island. "
- "Immediately, and according to custom, the ramparts of Fort "
- "Saint-Jean were covered with spectators; it is always an event "
- "at Marseilles for a ship to come into port, especially when "
- "this ship, like the Pharaon, has been built, rigged, and laden"
- " at the old Phocee docks, and belongs to an owner of the city."
- " The ship drew on and had safely passed the strait, which some"
- " volcanic shock has made between the Calasareigne and Jaros "
- "islands; had doubled Pomegue, and approached the harbor under"
- " topsails, jib, and spanker, but so slowly and sedately that"
- " the idlers, with that instinct which is the forerunner of "
- "evil, asked one another what misfortune could have happened "
- "on board. However, those experienced in navigation saw plainly"
- " that if any accident had occurred, it was not to the vessel "
- "herself, for she bore down with all the evidence of being "
- "skilfully handled, the anchor a-cockbill, the jib-boom guys "
- "already eased off, and standing by the side of the pilot, who"
- " was steering the Pharaon towards the narrow entrance of the"
- " inner port, was a young man, who, with activity and vigilant"
- " eye, watched every motion of the ship, and repeated each "
- "direction of the pilot. The vague disquietude which prevailed "
- "among the spectators had so much affected one of the crowd "
- "that he did not await the arrival of the vessel in harbor, but"
- " jumping into a small skiff, desired to be pulled alongside "
- "the Pharaon, which he reached as she rounded into La Reserve "
- "basin. When the young man on board saw this person approach, "
- "he left his station by the pilot, and, hat in hand, leaned "
- "over the ship's bulwarks. He was a fine, tall, slim young "
- "fellow of eighteen or twenty, with black eyes, and hair as "
- "dark as a raven's wing; and his whole appearance bespoke that "
- "calmness and resolution peculiar to men accustomed from their "
- "cradle to contend with danger. \"Ah, is it you, Dantes?\" "
- "cried the man in the skiff. \"What's the matter? and why have "
- "you such an air of sadness aboard?\" \"A great misfortune, M. "
- "Morrel,\" replied the young man,--\"a great misfortune, for me"
- " especially! Off Civita Vecchia we lost our brave Captain "
- "Leclere.\" \"And the cargo?\" inquired the owner, eagerly. "
- "\"Is all safe, M. Morrel; and I think you will be satisfied on"
- " that head. But poor Captain Leclere--\" \"What happened to "
- "him?\" asked the owner, with an air of considerable "
- "resignation. \"What happened to the worthy captain?\" \"He "
- "died.\" \"Fell into the sea?\" \"No, sir, he died of "
- "brain-fever in dreadful agony.\" Then turning to the crew, "
- "he said, \"Bear a hand there, to take in sail!\" All hands "
- "obeyed, and at once the eight or ten seamen who composed the "
- "crew, sprang to their respective stations at the spanker "
- "brails and outhaul, topsail sheets and halyards, the jib "
- "downhaul, and the topsail clewlines and buntlines. The young "
- "sailor gave a look to see that his orders were promptly and "
- "accurately obeyed, and then turned again to the owner. \"And "
- "how did this misfortune occur?\" inquired the latter, resuming"
- " the interrupted conversation. \"Alas, sir, in the most "
- "unexpected manner. After a long talk with the harbor-master, "
- "Captain Leclere left Naples greatly disturbed in mind. In "
- "twenty-four hours he was attacked by a fever, and died three "
- "days afterwards. We performed the usual burial service, and he"
- " is at his rest, sewn up in his hammock with a thirty-six "
- "pound shot at his head and his heels, off El Giglio island. "
- "We bring to his widow his sword and cross of honor. It was "
- "worth while, truly,\" added the young man with a melancholy "
- "smile, \"to make war against the English for ten years, and "
- "to die in his bed at last, like everybody else.";
-
-#define QUOTE_LEN_64B (64)
-#define QUOTE_LEN_128B (128)
-#define QUOTE_LEN_256B (256)
-#define QUOTE_LEN_512B (512)
-#define QUOTE_LEN_768B (768)
-#define QUOTE_LEN_1024B (1024)
-#define QUOTE_LEN_1280B (1280)
-#define QUOTE_LEN_1536B (1536)
-#define QUOTE_LEN_1792B (1792)
-#define QUOTE_LEN_2048B (2048)
-
-
-/* ***** AES-CBC / HMAC-SHA256 Performance Tests ***** */
-
-#define HMAC_KEY_LENGTH_SHA256 (DIGEST_BYTE_LENGTH_SHA256)
-
-#define CIPHER_KEY_LENGTH_AES_CBC (16)
-#define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC)
-
-static uint8_t aes_cbc_128_key[] = {
- 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
- 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA };
-
-static uint8_t aes_cbc_128_iv[] = {
- 0xf5, 0xd3, 0x89, 0x0f, 0x47, 0x00, 0xcb, 0x52,
- 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1 };
-
-static uint8_t hmac_sha256_key[] = {
- 0xff, 0xcb, 0x37, 0x30, 0x1d, 0x4a, 0xc2, 0x41,
- 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
- 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
- 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60 };
-
-
-/* Cipher text output */
-
-static const uint8_t AES_CBC_ciphertext_64B[] = {
- 0x05, 0x15, 0x77, 0x32, 0xc9, 0x66, 0x91, 0x50,
- 0x93, 0x9f, 0xbb, 0x4e, 0x2e, 0x5a, 0x02, 0xd0,
- 0x2d, 0x9d, 0x31, 0x5d, 0xc8, 0x9e, 0x86, 0x36,
- 0x54, 0x5c, 0x50, 0xe8, 0x75, 0x54, 0x74, 0x5e,
- 0xd5, 0xa2, 0x84, 0x21, 0x2d, 0xc5, 0xf8, 0x1c,
- 0x55, 0x1a, 0xba, 0x91, 0xce, 0xb5, 0xa3, 0x1e,
- 0x31, 0xbf, 0xe9, 0xa1, 0x97, 0x5c, 0x2b, 0xd6,
- 0x57, 0xa5, 0x9f, 0xab, 0xbd, 0xb0, 0x9b, 0x9c
-};
-
-static const uint8_t AES_CBC_ciphertext_128B[] = {
- 0x79, 0x92, 0x65, 0xc8, 0xfb, 0x0a, 0xc7, 0xc4,
- 0x9b, 0x3b, 0xbe, 0x69, 0x7f, 0x7c, 0xf4, 0x4e,
- 0xa5, 0x0d, 0xf6, 0x33, 0xc4, 0xdf, 0xf3, 0x0d,
- 0xdb, 0xb9, 0x68, 0x34, 0xb0, 0x0d, 0xbd, 0xb9,
- 0xa7, 0xf3, 0x86, 0x50, 0x2a, 0xbe, 0x50, 0x5d,
- 0xb3, 0xbe, 0x72, 0xf9, 0x02, 0xb1, 0x69, 0x0b,
- 0x8c, 0x96, 0x4c, 0x3c, 0x0c, 0x1e, 0x76, 0xe5,
- 0x7e, 0x75, 0xdd, 0xd0, 0xa9, 0x75, 0x00, 0x13,
- 0x6b, 0x1e, 0xc0, 0xad, 0xfc, 0x03, 0xb5, 0x99,
- 0xdc, 0x37, 0x35, 0xfc, 0x16, 0x34, 0xfd, 0xb4,
- 0xea, 0x1e, 0xb6, 0x51, 0xdf, 0xab, 0x87, 0xd6,
- 0x87, 0x41, 0xfa, 0x1c, 0xc6, 0x78, 0xa6, 0x3c,
- 0x1d, 0x76, 0xfe, 0xff, 0x65, 0xfc, 0x63, 0x1e,
- 0x1f, 0xe2, 0x7c, 0x9b, 0xa2, 0x72, 0xc3, 0x34,
- 0x23, 0xdf, 0x01, 0xf0, 0xfd, 0x02, 0x8b, 0x97,
- 0x00, 0x2b, 0x97, 0x4e, 0xab, 0x98, 0x21, 0x3c
-};
-
-static const uint8_t AES_CBC_ciphertext_256B[] = {
- 0xc7, 0x71, 0x2b, 0xed, 0x2c, 0x97, 0x59, 0xfa,
- 0xcf, 0x5a, 0xb9, 0x31, 0x92, 0xe0, 0xc9, 0x92,
- 0xc0, 0x2d, 0xd5, 0x9c, 0x84, 0xbf, 0x70, 0x36,
- 0x13, 0x48, 0xe0, 0xb1, 0xbf, 0x6c, 0xcd, 0x91,
- 0xa0, 0xc3, 0x57, 0x6c, 0x3f, 0x0e, 0x34, 0x41,
- 0xe7, 0x9c, 0xc0, 0xec, 0x18, 0x0c, 0x05, 0x52,
- 0x78, 0xe2, 0x3c, 0x6e, 0xdf, 0xa5, 0x49, 0xc7,
- 0xf2, 0x55, 0x00, 0x8f, 0x65, 0x6d, 0x4b, 0xd0,
- 0xcb, 0xd4, 0xd2, 0x0b, 0xea, 0xf4, 0xb0, 0x85,
- 0x61, 0x9e, 0x36, 0xc0, 0x71, 0xb7, 0x80, 0xad,
- 0x40, 0x78, 0xb4, 0x70, 0x2b, 0xe8, 0x80, 0xc5,
- 0x19, 0x35, 0x96, 0x55, 0x3b, 0x40, 0x03, 0xbb,
- 0x9f, 0xa6, 0xc2, 0x82, 0x92, 0x04, 0xc3, 0xa6,
- 0x96, 0xc4, 0x7f, 0x4c, 0x3e, 0x3c, 0x79, 0x82,
- 0x88, 0x8b, 0x3f, 0x8b, 0xc5, 0x9f, 0x44, 0xbe,
- 0x71, 0xe7, 0x09, 0xa2, 0x40, 0xa2, 0x23, 0x4e,
- 0x9f, 0x31, 0xab, 0x6f, 0xdf, 0x59, 0x40, 0xe1,
- 0x12, 0x15, 0x55, 0x4b, 0xea, 0x3f, 0xa1, 0x41,
- 0x4f, 0xaf, 0xcd, 0x27, 0x2a, 0x61, 0xa1, 0x9e,
- 0x82, 0x30, 0x05, 0x05, 0x55, 0xce, 0x99, 0xd3,
- 0x8f, 0x3f, 0x86, 0x79, 0xdc, 0x9f, 0x33, 0x07,
- 0x75, 0x26, 0xc8, 0x72, 0x81, 0x0f, 0x9b, 0xf7,
- 0xb1, 0xfb, 0xd3, 0x91, 0x36, 0x08, 0xab, 0x26,
- 0x70, 0x53, 0x0c, 0x99, 0xfd, 0xa9, 0x07, 0xb4,
- 0xe9, 0xce, 0xc1, 0xd6, 0xd2, 0x2c, 0x71, 0x80,
- 0xec, 0x59, 0x61, 0x0b, 0x24, 0xf0, 0x6d, 0x33,
- 0x73, 0x45, 0x6e, 0x80, 0x03, 0x45, 0xf2, 0x76,
- 0xa5, 0x8a, 0xc9, 0xcf, 0xaf, 0x4a, 0xed, 0x35,
- 0xc0, 0x97, 0x52, 0xc5, 0x00, 0xdf, 0xef, 0xc7,
- 0x9f, 0xf2, 0xe8, 0x15, 0x3e, 0xb3, 0x30, 0xe7,
- 0x00, 0xd0, 0x4e, 0xeb, 0x79, 0xf6, 0xf6, 0xcf,
- 0xf0, 0xe7, 0x61, 0xd5, 0x3d, 0x6a, 0x73, 0x9d
-};
-
-static const uint8_t AES_CBC_ciphertext_512B[] = {
- 0xb4, 0xc6, 0xc6, 0x5f, 0x7e, 0xca, 0x05, 0x70,
- 0x21, 0x7b, 0x92, 0x9e, 0x23, 0xe7, 0x92, 0xb8,
- 0x27, 0x3d, 0x20, 0x29, 0x57, 0xfa, 0x1f, 0x26,
- 0x0a, 0x04, 0x34, 0xa6, 0xf2, 0xdc, 0x44, 0xb6,
- 0x43, 0x40, 0x62, 0xde, 0x0c, 0xde, 0x1c, 0x30,
- 0x43, 0x85, 0x0b, 0xe8, 0x93, 0x1f, 0xa1, 0x2a,
- 0x8a, 0x27, 0x35, 0x39, 0x14, 0x9f, 0x37, 0x64,
- 0x59, 0xb5, 0x0e, 0x96, 0x82, 0x5d, 0x63, 0x45,
- 0xd6, 0x93, 0x89, 0x46, 0xe4, 0x71, 0x31, 0xeb,
- 0x0e, 0xd1, 0x7b, 0xda, 0x90, 0xb5, 0x81, 0xac,
- 0x76, 0x54, 0x54, 0x85, 0x0b, 0xa9, 0x46, 0x9c,
- 0xf0, 0xfd, 0xde, 0x5d, 0xa8, 0xe3, 0xee, 0xe9,
- 0xf4, 0x9d, 0x34, 0x76, 0x39, 0xe7, 0xc3, 0x4a,
- 0x84, 0x38, 0x92, 0x61, 0xf1, 0x12, 0x9f, 0x05,
- 0xda, 0xdb, 0xc1, 0xd4, 0xb0, 0xa0, 0x27, 0x19,
- 0xa0, 0x56, 0x5d, 0x9b, 0xcc, 0x47, 0x7c, 0x15,
- 0x1d, 0x52, 0x66, 0xd5, 0xff, 0xef, 0x12, 0x23,
- 0x86, 0xe2, 0xee, 0x81, 0x2c, 0x3d, 0x7d, 0x28,
- 0xd5, 0x42, 0xdf, 0xdb, 0x75, 0x1c, 0xeb, 0xdf,
- 0x13, 0x23, 0xd5, 0x17, 0x89, 0xea, 0xd7, 0x01,
- 0xff, 0x57, 0x6a, 0x44, 0x61, 0xf4, 0xea, 0xbe,
- 0x97, 0x9b, 0xc2, 0xb1, 0x9c, 0x5d, 0xff, 0x4f,
- 0x73, 0x2d, 0x3f, 0x57, 0x28, 0x38, 0xbf, 0x3d,
- 0x9f, 0xda, 0x49, 0x55, 0x8f, 0xb2, 0x77, 0xec,
- 0x0f, 0xbc, 0xce, 0xb8, 0xc6, 0xe1, 0x03, 0xed,
- 0x35, 0x9c, 0xf2, 0x4d, 0xa4, 0x29, 0x6c, 0xd6,
- 0x6e, 0x05, 0x53, 0x46, 0xc1, 0x41, 0x09, 0x36,
- 0x0b, 0x7d, 0xf4, 0x9e, 0x0f, 0xba, 0x86, 0x33,
- 0xdd, 0xf1, 0xa7, 0xf7, 0xd5, 0x29, 0xa8, 0xa7,
- 0x4d, 0xce, 0x0c, 0xf5, 0xb4, 0x6c, 0xd8, 0x27,
- 0xb0, 0x87, 0x2a, 0x6f, 0x7f, 0x3f, 0x8f, 0xc3,
- 0xe2, 0x3e, 0x94, 0xcf, 0x61, 0x4a, 0x09, 0x3d,
- 0xf9, 0x55, 0x19, 0x31, 0xf2, 0xd2, 0x4a, 0x3e,
- 0xc1, 0xf5, 0xed, 0x7c, 0x45, 0xb0, 0x0c, 0x7b,
- 0xdd, 0xa6, 0x0a, 0x26, 0x66, 0xec, 0x85, 0x49,
- 0x00, 0x38, 0x05, 0x7c, 0x9c, 0x1c, 0x92, 0xf5,
- 0xf7, 0xdb, 0x5d, 0xbd, 0x61, 0x0c, 0xc9, 0xaf,
- 0xfd, 0x57, 0x3f, 0xee, 0x2b, 0xad, 0x73, 0xef,
- 0xa3, 0xc1, 0x66, 0x26, 0x44, 0x5e, 0xf9, 0x12,
- 0x86, 0x66, 0xa9, 0x61, 0x75, 0xa1, 0xbc, 0x40,
- 0x7f, 0xa8, 0x08, 0x02, 0xc0, 0x76, 0x0e, 0x76,
- 0xb3, 0x26, 0x3d, 0x1c, 0x40, 0x65, 0xe4, 0x18,
- 0x0f, 0x62, 0x17, 0x8f, 0x1e, 0x61, 0xb8, 0x08,
- 0x83, 0x54, 0x42, 0x11, 0x03, 0x30, 0x8e, 0xb7,
- 0xc1, 0x9c, 0xec, 0x69, 0x52, 0x95, 0xfb, 0x7b,
- 0x1a, 0x0c, 0x20, 0x24, 0xf7, 0xb8, 0x38, 0x0c,
- 0xb8, 0x7b, 0xb6, 0x69, 0x70, 0xd0, 0x61, 0xb9,
- 0x70, 0x06, 0xc2, 0x5b, 0x20, 0x47, 0xf7, 0xd9,
- 0x32, 0xc2, 0xf2, 0x90, 0xb6, 0x4d, 0xcd, 0x3c,
- 0x6d, 0x74, 0xea, 0x82, 0x35, 0x1b, 0x08, 0x44,
- 0xba, 0xb7, 0x33, 0x82, 0x33, 0x27, 0x54, 0x77,
- 0x6e, 0x58, 0xfe, 0x46, 0x5a, 0xb4, 0x88, 0x53,
- 0x8d, 0x9b, 0xb1, 0xab, 0xdf, 0x04, 0xe1, 0xfb,
- 0xd7, 0x1e, 0xd7, 0x38, 0x64, 0x54, 0xba, 0xb0,
- 0x6c, 0x84, 0x7a, 0x0f, 0xa7, 0x80, 0x6b, 0x86,
- 0xd9, 0xc9, 0xc6, 0x31, 0x95, 0xfa, 0x8a, 0x2c,
- 0x14, 0xe1, 0x85, 0x66, 0x27, 0xfd, 0x63, 0x3e,
- 0xf0, 0xfa, 0x81, 0xc9, 0x89, 0x4f, 0xe2, 0x6a,
- 0x8c, 0x17, 0xb5, 0xc7, 0x9f, 0x5d, 0x3f, 0x6b,
- 0x3f, 0xcd, 0x13, 0x7a, 0x3c, 0xe6, 0x4e, 0xfa,
- 0x7a, 0x10, 0xb8, 0x7c, 0x40, 0xec, 0x93, 0x11,
- 0x1f, 0xd0, 0x9e, 0xc3, 0x56, 0xb9, 0xf5, 0x21,
- 0x18, 0x41, 0x31, 0xea, 0x01, 0x8d, 0xea, 0x1c,
- 0x95, 0x5e, 0x56, 0x33, 0xbc, 0x7a, 0x3f, 0x6f
-};
-
-static const uint8_t AES_CBC_ciphertext_768B[] = {
- 0x3e, 0x7f, 0x9e, 0x4c, 0x88, 0x15, 0x68, 0x69,
- 0x10, 0x09, 0xe1, 0xa7, 0x0f, 0x27, 0x88, 0x2d,
- 0x90, 0x73, 0x4f, 0x67, 0xd3, 0x8b, 0xaf, 0xa1,
- 0x2c, 0x37, 0xa5, 0x6c, 0x7c, 0xbd, 0x95, 0x4c,
- 0x82, 0xcf, 0x05, 0x49, 0x16, 0x5c, 0xe7, 0x06,
- 0xd4, 0xcb, 0x55, 0x65, 0x9a, 0xd0, 0xe1, 0x46,
- 0x3a, 0x37, 0x71, 0xad, 0xb0, 0xb4, 0x99, 0x1e,
- 0x23, 0x57, 0x48, 0x96, 0x9c, 0xc5, 0xc4, 0xdb,
- 0x64, 0x3e, 0xc9, 0x7f, 0x90, 0x5a, 0xa0, 0x08,
- 0x75, 0x4c, 0x09, 0x06, 0x31, 0x6e, 0x59, 0x29,
- 0xfc, 0x2f, 0x72, 0xde, 0xf2, 0x40, 0x5a, 0xfe,
- 0xd3, 0x66, 0x64, 0xb8, 0x9c, 0xc9, 0xa6, 0x1f,
- 0xc3, 0x52, 0xcd, 0xb5, 0xd1, 0x4f, 0x43, 0x3f,
- 0xf4, 0x59, 0x25, 0xc4, 0xdd, 0x3e, 0x58, 0x7c,
- 0x21, 0xd6, 0x21, 0xce, 0xa4, 0xbe, 0x08, 0x23,
- 0x46, 0x68, 0xc0, 0x00, 0x91, 0x47, 0xca, 0x9b,
- 0xe0, 0xb4, 0xe3, 0xab, 0xbf, 0xcf, 0x68, 0x26,
- 0x97, 0x23, 0x09, 0x93, 0x64, 0x8f, 0x57, 0x59,
- 0xe2, 0x41, 0x7c, 0xa2, 0x48, 0x7e, 0xd5, 0x2c,
- 0x54, 0x09, 0x1b, 0x07, 0x94, 0xca, 0x39, 0x83,
- 0xdd, 0xf4, 0x7a, 0x1d, 0x2d, 0xdd, 0x67, 0xf7,
- 0x3c, 0x30, 0x89, 0x3e, 0xc1, 0xdc, 0x1d, 0x8f,
- 0xfc, 0xb1, 0xe9, 0x13, 0x31, 0xb0, 0x16, 0xdb,
- 0x88, 0xf2, 0x32, 0x7e, 0x73, 0xa3, 0xdf, 0x08,
- 0x6b, 0x53, 0x92, 0x08, 0xc9, 0x9d, 0x98, 0xb2,
- 0xf4, 0x8c, 0xb1, 0x95, 0xdc, 0xb6, 0xfc, 0xec,
- 0xf1, 0xc9, 0x0d, 0x6d, 0x42, 0x2c, 0xf5, 0x38,
- 0x29, 0xf4, 0xd8, 0x98, 0x0f, 0xb0, 0x81, 0xa5,
- 0xaa, 0xe6, 0x1f, 0x6e, 0x87, 0x32, 0x1b, 0x02,
- 0x07, 0x57, 0x38, 0x83, 0xf3, 0xe4, 0x54, 0x7c,
- 0xa8, 0x43, 0xdf, 0x3f, 0x42, 0xfd, 0x67, 0x28,
- 0x06, 0x4d, 0xea, 0xce, 0x1f, 0x84, 0x4a, 0xcd,
- 0x8c, 0x61, 0x5e, 0x8f, 0x61, 0xed, 0x84, 0x03,
- 0x53, 0x6a, 0x9e, 0xbf, 0x68, 0x83, 0xa7, 0x42,
- 0x56, 0x57, 0xcd, 0x45, 0x29, 0xfc, 0x7b, 0x07,
- 0xfc, 0xe9, 0xb9, 0x42, 0xfd, 0x29, 0xd5, 0xfd,
- 0x98, 0x11, 0xd1, 0x8d, 0x67, 0x29, 0x47, 0x61,
- 0xd8, 0x27, 0x37, 0x79, 0x29, 0xd1, 0x94, 0x6f,
- 0x8d, 0xf3, 0x1b, 0x3d, 0x6a, 0xb1, 0x59, 0xef,
- 0x1b, 0xd4, 0x70, 0x0e, 0xac, 0xab, 0xa0, 0x2b,
- 0x1f, 0x5e, 0x04, 0xf0, 0x0e, 0x35, 0x72, 0x90,
- 0xfc, 0xcf, 0x86, 0x43, 0xea, 0x45, 0x6d, 0x22,
- 0x63, 0x06, 0x1a, 0x58, 0xd7, 0x2d, 0xc5, 0xb0,
- 0x60, 0x69, 0xe8, 0x53, 0xc2, 0xa2, 0x57, 0x83,
- 0xc4, 0x31, 0xb4, 0xc6, 0xb3, 0xa1, 0x77, 0xb3,
- 0x1c, 0xca, 0x89, 0x3f, 0xf5, 0x10, 0x3b, 0x36,
- 0x31, 0x7d, 0x00, 0x46, 0x00, 0x92, 0xa0, 0xa0,
- 0x34, 0xd8, 0x5e, 0x62, 0xa9, 0xe0, 0x23, 0x37,
- 0x50, 0x85, 0xc7, 0x3a, 0x20, 0xa3, 0x98, 0xc0,
- 0xac, 0x20, 0x06, 0x0f, 0x17, 0x3c, 0xfc, 0x43,
- 0x8c, 0x9d, 0xec, 0xf5, 0x9a, 0x35, 0x96, 0xf7,
- 0xb7, 0x4c, 0xf9, 0x69, 0xf8, 0xd4, 0x1e, 0x9e,
- 0xf9, 0x7c, 0xc4, 0xd2, 0x11, 0x14, 0x41, 0xb9,
- 0x89, 0xd6, 0x07, 0xd2, 0x37, 0x07, 0x5e, 0x5e,
- 0xae, 0x60, 0xdc, 0xe4, 0xeb, 0x38, 0x48, 0x6d,
- 0x95, 0x8d, 0x71, 0xf2, 0xba, 0xda, 0x5f, 0x08,
- 0x9d, 0x4a, 0x0f, 0x56, 0x90, 0x64, 0xab, 0xb6,
- 0x88, 0x22, 0xa8, 0x90, 0x1f, 0x76, 0x2c, 0x83,
- 0x43, 0xce, 0x32, 0x55, 0x45, 0x84, 0x57, 0x43,
- 0xf9, 0xa8, 0xd1, 0x4f, 0xe3, 0xc1, 0x72, 0x9c,
- 0xeb, 0x64, 0xf7, 0xe4, 0x61, 0x2b, 0x93, 0xd1,
- 0x1f, 0xbb, 0x5c, 0xff, 0xa1, 0x59, 0x69, 0xcf,
- 0xf7, 0xaf, 0x58, 0x45, 0xd5, 0x3e, 0x98, 0x7d,
- 0x26, 0x39, 0x5c, 0x75, 0x3c, 0x4a, 0xbf, 0x5e,
- 0x12, 0x10, 0xb0, 0x93, 0x0f, 0x86, 0x82, 0xcf,
- 0xb2, 0xec, 0x70, 0x5c, 0x0b, 0xad, 0x5d, 0x63,
- 0x65, 0x32, 0xa6, 0x04, 0x58, 0x03, 0x91, 0x2b,
- 0xdb, 0x8f, 0xd3, 0xa3, 0x2b, 0x3a, 0xf5, 0xa1,
- 0x62, 0x6c, 0xb6, 0xf0, 0x13, 0x3b, 0x8c, 0x07,
- 0x10, 0x82, 0xc9, 0x56, 0x24, 0x87, 0xfc, 0x56,
- 0xe8, 0xef, 0x90, 0x8b, 0xd6, 0x48, 0xda, 0x53,
- 0x04, 0x49, 0x41, 0xa4, 0x67, 0xe0, 0x33, 0x24,
- 0x6b, 0x9c, 0x07, 0x55, 0x4c, 0x5d, 0xe9, 0x35,
- 0xfa, 0xbd, 0xea, 0xa8, 0x3f, 0xe9, 0xf5, 0x20,
- 0x5c, 0x60, 0x0f, 0x0d, 0x24, 0xcb, 0x1a, 0xd6,
- 0xe8, 0x5c, 0xa8, 0x42, 0xae, 0xd0, 0xd2, 0xf2,
- 0xa8, 0xbe, 0xea, 0x0f, 0x8d, 0xfb, 0x81, 0xa3,
- 0xa4, 0xef, 0xb7, 0x3e, 0x91, 0xbd, 0x26, 0x0f,
- 0x8e, 0xf1, 0xb2, 0xa5, 0x47, 0x06, 0xfa, 0x40,
- 0x8b, 0x31, 0x7a, 0x5a, 0x74, 0x2a, 0x0a, 0x7c,
- 0x62, 0x5d, 0x39, 0xa4, 0xae, 0x14, 0x85, 0x08,
- 0x5b, 0x20, 0x85, 0xf1, 0x57, 0x6e, 0x71, 0x13,
- 0x4e, 0x2b, 0x49, 0x87, 0x01, 0xdf, 0x37, 0xed,
- 0x28, 0xee, 0x4d, 0xa1, 0xf4, 0xb3, 0x3b, 0xba,
- 0x2d, 0xb3, 0x46, 0x17, 0x84, 0x80, 0x9d, 0xd7,
- 0x93, 0x1f, 0x28, 0x7c, 0xf5, 0xf9, 0xd6, 0x85,
- 0x8c, 0xa5, 0x44, 0xe9, 0x2c, 0x65, 0x51, 0x5f,
- 0x53, 0x7a, 0x09, 0xd9, 0x30, 0x16, 0x95, 0x89,
- 0x9c, 0x0b, 0xef, 0x90, 0x6d, 0x23, 0xd3, 0x48,
- 0x57, 0x3b, 0x55, 0x69, 0x96, 0xfc, 0xf7, 0x52,
- 0x92, 0x38, 0x36, 0xbf, 0xa9, 0x0a, 0xbb, 0x68,
- 0x45, 0x08, 0x25, 0xee, 0x59, 0xfe, 0xee, 0xf2,
- 0x2c, 0xd4, 0x5f, 0x78, 0x59, 0x0d, 0x90, 0xf1,
- 0xd7, 0xe4, 0x39, 0x0e, 0x46, 0x36, 0xf5, 0x75,
- 0x03, 0x3c, 0x28, 0xfb, 0xfa, 0x8f, 0xef, 0xc9,
- 0x61, 0x00, 0x94, 0xc3, 0xd2, 0x0f, 0xd9, 0xda
-};
-
-static const uint8_t AES_CBC_ciphertext_1024B[] = {
- 0x7d, 0x01, 0x7e, 0x2f, 0x92, 0xb3, 0xea, 0x72,
- 0x4a, 0x3f, 0x10, 0xf9, 0x2b, 0xb0, 0xd5, 0xb9,
- 0x19, 0x68, 0x94, 0xe9, 0x93, 0xe9, 0xd5, 0x26,
- 0x20, 0x44, 0xe2, 0x47, 0x15, 0x8d, 0x75, 0x48,
- 0x8e, 0xe4, 0x40, 0x81, 0xb5, 0x06, 0xa8, 0xb8,
- 0x0e, 0x0f, 0x3b, 0xbc, 0x5b, 0xbe, 0x3b, 0xa2,
- 0x2a, 0x0c, 0x48, 0x98, 0x19, 0xdf, 0xe9, 0x25,
- 0x75, 0xab, 0x93, 0x44, 0xb1, 0x72, 0x70, 0xbb,
- 0x20, 0xcf, 0x78, 0xe9, 0x4d, 0xc6, 0xa9, 0xa9,
- 0x84, 0x78, 0xc5, 0xc0, 0xc4, 0xc9, 0x79, 0x1a,
- 0xbc, 0x61, 0x25, 0x5f, 0xac, 0x01, 0x03, 0xb7,
- 0xef, 0x07, 0xf2, 0x62, 0x98, 0xee, 0xe3, 0xad,
- 0x94, 0x75, 0x30, 0x67, 0xb9, 0x15, 0x00, 0xe7,
- 0x11, 0x32, 0x2e, 0x6b, 0x55, 0x9f, 0xac, 0x68,
- 0xde, 0x61, 0x05, 0x80, 0x01, 0xf3, 0xad, 0xab,
- 0xaf, 0x45, 0xe0, 0xf4, 0x68, 0x5c, 0xc0, 0x52,
- 0x92, 0xc8, 0x21, 0xb6, 0xf5, 0x8a, 0x1d, 0xbb,
- 0xfc, 0x4a, 0x11, 0x62, 0xa2, 0xc4, 0xf1, 0x2d,
- 0x0e, 0xb2, 0xc7, 0x17, 0x34, 0xb4, 0x2a, 0x54,
- 0x81, 0xc2, 0x1e, 0xcf, 0x51, 0x0a, 0x76, 0x54,
- 0xf1, 0x48, 0x0d, 0x5c, 0xcd, 0x38, 0x3e, 0x38,
- 0x3e, 0xf8, 0x46, 0x1d, 0x00, 0xf5, 0x62, 0xe1,
- 0x5c, 0xb7, 0x8d, 0xce, 0xd0, 0x3f, 0xbb, 0x22,
- 0xf1, 0xe5, 0xb1, 0xa0, 0x58, 0x5e, 0x3c, 0x0f,
- 0x15, 0xd1, 0xac, 0x3e, 0xc7, 0x72, 0xc4, 0xde,
- 0x8b, 0x95, 0x3e, 0x91, 0xf7, 0x1d, 0x04, 0x9a,
- 0xc8, 0xe4, 0xbf, 0xd3, 0x22, 0xca, 0x4a, 0xdc,
- 0xb6, 0x16, 0x79, 0x81, 0x75, 0x2f, 0x6b, 0xa7,
- 0x04, 0x98, 0xa7, 0x4e, 0xc1, 0x19, 0x90, 0x33,
- 0x33, 0x3c, 0x7f, 0xdd, 0xac, 0x09, 0x0c, 0xc3,
- 0x91, 0x34, 0x74, 0xab, 0xa5, 0x35, 0x0a, 0x13,
- 0xc3, 0x56, 0x67, 0x6d, 0x1a, 0x3e, 0xbf, 0x56,
- 0x06, 0x67, 0x15, 0x5f, 0xfc, 0x8b, 0xa2, 0x3c,
- 0x5e, 0xaf, 0x56, 0x1f, 0xe3, 0x2e, 0x9d, 0x0a,
- 0xf9, 0x9b, 0xc7, 0xb5, 0x03, 0x1c, 0x68, 0x99,
- 0xfa, 0x3c, 0x37, 0x59, 0xc1, 0xf7, 0x6a, 0x83,
- 0x22, 0xee, 0xca, 0x7f, 0x7d, 0x49, 0xe6, 0x48,
- 0x84, 0x54, 0x7a, 0xff, 0xb3, 0x72, 0x21, 0xd8,
- 0x7a, 0x5d, 0xb1, 0x4b, 0xcc, 0x01, 0x6f, 0x90,
- 0xc6, 0x68, 0x1c, 0x2c, 0xa1, 0xe2, 0x74, 0x40,
- 0x26, 0x9b, 0x57, 0x53, 0xa3, 0x7c, 0x0b, 0x0d,
- 0xcf, 0x05, 0x5d, 0x62, 0x4f, 0x75, 0x06, 0x62,
- 0x1f, 0x26, 0x32, 0xaa, 0x25, 0xcc, 0x26, 0x8d,
- 0xae, 0x01, 0x47, 0xa3, 0x00, 0x42, 0xe2, 0x4c,
- 0xee, 0x29, 0xa2, 0x81, 0xa0, 0xfd, 0xeb, 0xff,
- 0x9a, 0x66, 0x6e, 0x47, 0x5b, 0xab, 0x93, 0x5a,
- 0x02, 0x6d, 0x6f, 0xf2, 0x6e, 0x02, 0x9d, 0xb1,
- 0xab, 0x56, 0xdc, 0x8b, 0x9b, 0x17, 0xa8, 0xfb,
- 0x87, 0x42, 0x7c, 0x91, 0x1e, 0x14, 0xc6, 0x6f,
- 0xdc, 0xf0, 0x27, 0x30, 0xfa, 0x3f, 0xc4, 0xad,
- 0x57, 0x85, 0xd2, 0xc9, 0x32, 0x2c, 0x13, 0xa6,
- 0x04, 0x04, 0x50, 0x05, 0x2f, 0x72, 0xd9, 0x44,
- 0x55, 0x6e, 0x93, 0x40, 0xed, 0x7e, 0xd4, 0x40,
- 0x3e, 0x88, 0x3b, 0x8b, 0xb6, 0xeb, 0xc6, 0x5d,
- 0x9c, 0x99, 0xa1, 0xcf, 0x30, 0xb2, 0xdc, 0x48,
- 0x8a, 0x01, 0xa7, 0x61, 0x77, 0x50, 0x14, 0xf3,
- 0x0c, 0x49, 0x53, 0xb3, 0xb4, 0xb4, 0x28, 0x41,
- 0x4a, 0x2d, 0xd2, 0x4d, 0x2a, 0x30, 0x31, 0x83,
- 0x03, 0x5e, 0xaa, 0xd3, 0xa3, 0xd1, 0xa1, 0xca,
- 0x62, 0xf0, 0xe1, 0xf2, 0xff, 0xf0, 0x19, 0xa6,
- 0xde, 0x22, 0x47, 0xb5, 0x28, 0x7d, 0xf7, 0x07,
- 0x16, 0x0d, 0xb1, 0x55, 0x81, 0x95, 0xe5, 0x1d,
- 0x4d, 0x78, 0xa9, 0x3e, 0xce, 0xe3, 0x1c, 0xf9,
- 0x47, 0xc8, 0xec, 0xc5, 0xc5, 0x93, 0x4c, 0x34,
- 0x20, 0x6b, 0xee, 0x9a, 0xe6, 0x86, 0x57, 0x58,
- 0xd5, 0x58, 0xf1, 0x33, 0x10, 0x29, 0x9e, 0x93,
- 0x2f, 0xf5, 0x90, 0x00, 0x17, 0x67, 0x4f, 0x39,
- 0x18, 0xe1, 0xcf, 0x55, 0x78, 0xbb, 0xe6, 0x29,
- 0x3e, 0x77, 0xd5, 0x48, 0xb7, 0x42, 0x72, 0x53,
- 0x27, 0xfa, 0x5b, 0xe0, 0x36, 0x14, 0x97, 0xb8,
- 0x9b, 0x3c, 0x09, 0x77, 0xc1, 0x0a, 0xe4, 0xa2,
- 0x63, 0xfc, 0xbe, 0x5c, 0x17, 0xcf, 0x01, 0xf5,
- 0x03, 0x0f, 0x17, 0xbc, 0x93, 0xdd, 0x5f, 0xe2,
- 0xf3, 0x08, 0xa8, 0xb1, 0x85, 0xb6, 0x34, 0x3f,
- 0x87, 0x42, 0xa5, 0x42, 0x3b, 0x0e, 0xd6, 0x83,
- 0x6a, 0xfd, 0x5d, 0xc9, 0x67, 0xd5, 0x51, 0xc9,
- 0x2a, 0x4e, 0x91, 0xb0, 0x59, 0xb2, 0x0f, 0xa2,
- 0xe6, 0x47, 0x73, 0xc2, 0xa2, 0xae, 0xbb, 0xc8,
- 0x42, 0xa3, 0x2a, 0x27, 0x29, 0x48, 0x8c, 0x54,
- 0x6c, 0xec, 0x00, 0x2a, 0x42, 0xa3, 0x7a, 0x0f,
- 0x12, 0x66, 0x6b, 0x96, 0xf6, 0xd0, 0x56, 0x4f,
- 0x49, 0x5c, 0x47, 0xec, 0x05, 0x62, 0x54, 0xb2,
- 0x64, 0x5a, 0x69, 0x1f, 0x19, 0xb4, 0x84, 0x5c,
- 0xbe, 0x48, 0x8e, 0xfc, 0x58, 0x21, 0xce, 0xfa,
- 0xaa, 0x84, 0xd2, 0xc1, 0x08, 0xb3, 0x87, 0x0f,
- 0x4f, 0xa3, 0x3a, 0xb6, 0x44, 0xbe, 0x2e, 0x9a,
- 0xdd, 0xb5, 0x44, 0x80, 0xca, 0xf4, 0xc3, 0x6e,
- 0xba, 0x93, 0x77, 0xe0, 0x53, 0xfb, 0x37, 0xfb,
- 0x88, 0xc3, 0x1f, 0x25, 0xde, 0x3e, 0x11, 0xf4,
- 0x89, 0xe7, 0xd1, 0x3b, 0xb4, 0x23, 0xcb, 0x70,
- 0xba, 0x35, 0x97, 0x7c, 0xbe, 0x84, 0x13, 0xcf,
- 0xe0, 0x4d, 0x33, 0x91, 0x71, 0x85, 0xbb, 0x4b,
- 0x97, 0x32, 0x5d, 0xa0, 0xb9, 0x8f, 0xdc, 0x27,
- 0x5a, 0xeb, 0x71, 0xf1, 0xd5, 0x0d, 0x65, 0xb4,
- 0x22, 0x81, 0xde, 0xa7, 0x58, 0x20, 0x0b, 0x18,
- 0x11, 0x76, 0x5c, 0xe6, 0x6a, 0x2c, 0x99, 0x69,
- 0xdc, 0xed, 0x67, 0x08, 0x5d, 0x5e, 0xe9, 0x1e,
- 0x55, 0x70, 0xc1, 0x5a, 0x76, 0x1b, 0x8d, 0x2e,
- 0x0d, 0xf9, 0xcc, 0x30, 0x8c, 0x44, 0x0f, 0x63,
- 0x8c, 0x42, 0x8a, 0x9f, 0x4c, 0xd1, 0x48, 0x28,
- 0x8a, 0xf5, 0x56, 0x2e, 0x23, 0x12, 0xfe, 0x67,
- 0x9a, 0x13, 0x65, 0x75, 0x83, 0xf1, 0x3c, 0x98,
- 0x07, 0x6b, 0xb7, 0x27, 0x5b, 0xf0, 0x70, 0xda,
- 0x30, 0xf8, 0x74, 0x4e, 0x7a, 0x32, 0x84, 0xcc,
- 0x0e, 0xcd, 0x80, 0x8b, 0x82, 0x31, 0x9a, 0x48,
- 0xcf, 0x75, 0x00, 0x1f, 0x4f, 0xe0, 0x8e, 0xa3,
- 0x6a, 0x2c, 0xd4, 0x73, 0x4c, 0x63, 0x7c, 0xa6,
- 0x4d, 0x5e, 0xfd, 0x43, 0x3b, 0x27, 0xe1, 0x5e,
- 0xa3, 0xa9, 0x5c, 0x3b, 0x60, 0xdd, 0xc6, 0x8d,
- 0x5a, 0xf1, 0x3e, 0x89, 0x4b, 0x24, 0xcf, 0x01,
- 0x3a, 0x2d, 0x44, 0xe7, 0xda, 0xe7, 0xa1, 0xac,
- 0x11, 0x05, 0x0c, 0xa9, 0x7a, 0x82, 0x8c, 0x5c,
- 0x29, 0x68, 0x9c, 0x73, 0x13, 0xcc, 0x67, 0x32,
- 0x11, 0x5e, 0xe5, 0xcc, 0x8c, 0xf5, 0xa7, 0x52,
- 0x83, 0x9a, 0x70, 0xef, 0xde, 0x55, 0x9c, 0xc7,
- 0x8a, 0xed, 0xad, 0x28, 0x4a, 0xc5, 0x92, 0x6d,
- 0x8e, 0x47, 0xca, 0xe3, 0xf8, 0x77, 0xb5, 0x26,
- 0x64, 0x84, 0xc2, 0xf1, 0xd7, 0xae, 0x0c, 0xb9,
- 0x39, 0x0f, 0x43, 0x6b, 0xe9, 0xe0, 0x09, 0x4b,
- 0xe5, 0xe3, 0x17, 0xa6, 0x68, 0x69, 0x46, 0xf4,
- 0xf0, 0x68, 0x7f, 0x2f, 0x1c, 0x7e, 0x4c, 0xd2,
- 0xb5, 0xc6, 0x16, 0x85, 0xcf, 0x02, 0x4c, 0x89,
- 0x0b, 0x25, 0xb0, 0xeb, 0xf3, 0x77, 0x08, 0x6a,
- 0x46, 0x5c, 0xf6, 0x2f, 0xf1, 0x24, 0xc3, 0x4d,
- 0x80, 0x60, 0x4d, 0x69, 0x98, 0xde, 0xc7, 0xa1,
- 0xf6, 0x4e, 0x18, 0x0c, 0x2a, 0xb0, 0xb2, 0xe0,
- 0x46, 0xe7, 0x49, 0x37, 0xc8, 0x5a, 0x23, 0x24,
- 0xe3, 0x0f, 0xcc, 0x92, 0xb4, 0x8d, 0xdc, 0x9e
-};
-
-static const uint8_t AES_CBC_ciphertext_1280B[] = {
- 0x91, 0x99, 0x5e, 0x9e, 0x84, 0xff, 0x59, 0x45,
- 0xc1, 0xf4, 0xbc, 0x9c, 0xb9, 0x30, 0x6c, 0x51,
- 0x73, 0x52, 0xb4, 0x44, 0x09, 0x79, 0xe2, 0x89,
- 0x75, 0xeb, 0x54, 0x26, 0xce, 0xd8, 0x24, 0x98,
- 0xaa, 0xf8, 0x13, 0x16, 0x68, 0x58, 0xc4, 0x82,
- 0x0e, 0x31, 0xd3, 0x6a, 0x13, 0x58, 0x31, 0xe9,
- 0x3a, 0xc1, 0x8b, 0xc5, 0x3f, 0x50, 0x42, 0xd1,
- 0x93, 0xe4, 0x9b, 0x65, 0x2b, 0xf4, 0x1d, 0x9e,
- 0x2d, 0xdb, 0x48, 0xef, 0x9a, 0x01, 0x68, 0xb6,
- 0xea, 0x7a, 0x2b, 0xad, 0xfe, 0x77, 0x44, 0x7e,
- 0x5a, 0xc5, 0x64, 0xb4, 0xfe, 0x5c, 0x80, 0xf3,
- 0x20, 0x7e, 0xaf, 0x5b, 0xf8, 0xd1, 0x38, 0xa0,
- 0x8d, 0x09, 0x77, 0x06, 0xfe, 0xf5, 0xf4, 0xe4,
- 0xee, 0xb8, 0x95, 0x27, 0xed, 0x07, 0xb8, 0xaa,
- 0x25, 0xb4, 0xe1, 0x4c, 0xeb, 0x3f, 0xdb, 0x39,
- 0x66, 0x28, 0x1b, 0x60, 0x42, 0x8b, 0x99, 0xd9,
- 0x49, 0xd6, 0x8c, 0xa4, 0x9d, 0xd8, 0x93, 0x58,
- 0x8f, 0xfa, 0xd3, 0xf7, 0x37, 0x9c, 0x88, 0xab,
- 0x16, 0x50, 0xfe, 0x01, 0x1f, 0x88, 0x48, 0xbe,
- 0x21, 0xa9, 0x90, 0x9e, 0x73, 0xe9, 0x82, 0xf7,
- 0xbf, 0x4b, 0x43, 0xf4, 0xbf, 0x22, 0x3c, 0x45,
- 0x47, 0x95, 0x5b, 0x49, 0x71, 0x07, 0x1c, 0x8b,
- 0x49, 0xa4, 0xa3, 0x49, 0xc4, 0x5f, 0xb1, 0xf5,
- 0xe3, 0x6b, 0xf1, 0xdc, 0xea, 0x92, 0x7b, 0x29,
- 0x40, 0xc9, 0x39, 0x5f, 0xdb, 0xbd, 0xf3, 0x6a,
- 0x09, 0x9b, 0x2a, 0x5e, 0xc7, 0x0b, 0x25, 0x94,
- 0x55, 0x71, 0x9c, 0x7e, 0x0e, 0xb4, 0x08, 0x12,
- 0x8c, 0x6e, 0x77, 0xb8, 0x29, 0xf1, 0xc6, 0x71,
- 0x04, 0x40, 0x77, 0x18, 0x3f, 0x01, 0x09, 0x9c,
- 0x23, 0x2b, 0x5d, 0x2a, 0x88, 0x20, 0x23, 0x59,
- 0x74, 0x2a, 0x67, 0x8f, 0xb7, 0xba, 0x38, 0x9f,
- 0x0f, 0xcf, 0x94, 0xdf, 0xe1, 0x8f, 0x35, 0x5e,
- 0x34, 0x0c, 0x32, 0x92, 0x2b, 0x23, 0x81, 0xf4,
- 0x73, 0xa0, 0x5a, 0x2a, 0xbd, 0xa6, 0x6b, 0xae,
- 0x43, 0xe2, 0xdc, 0x01, 0xc1, 0xc6, 0xc3, 0x04,
- 0x06, 0xbb, 0xb0, 0x89, 0xb3, 0x4e, 0xbd, 0x81,
- 0x1b, 0x03, 0x63, 0x93, 0xed, 0x4e, 0xf6, 0xe5,
- 0x94, 0x6f, 0xd6, 0xf3, 0x20, 0xf3, 0xbc, 0x30,
- 0xc5, 0xd6, 0xbe, 0x1c, 0x05, 0x34, 0x26, 0x4d,
- 0x46, 0x5e, 0x56, 0x63, 0xfb, 0xdb, 0xcd, 0xed,
- 0xb0, 0x7f, 0x83, 0x94, 0x55, 0x54, 0x2f, 0xab,
- 0xc9, 0xb7, 0x16, 0x4f, 0x9e, 0x93, 0x25, 0xd7,
- 0x9f, 0x39, 0x2b, 0x63, 0xcf, 0x1e, 0xa3, 0x0e,
- 0x28, 0x47, 0x8a, 0x5f, 0x40, 0x02, 0x89, 0x1f,
- 0x83, 0xe7, 0x87, 0xd1, 0x90, 0x17, 0xb8, 0x27,
- 0x64, 0xe1, 0xe1, 0x48, 0x5a, 0x55, 0x74, 0x99,
- 0x27, 0x9d, 0x05, 0x67, 0xda, 0x70, 0x12, 0x8f,
- 0x94, 0x96, 0xfd, 0x36, 0xa4, 0x1d, 0x22, 0xe5,
- 0x0b, 0xe5, 0x2f, 0x38, 0x55, 0xa3, 0x5d, 0x0b,
- 0xcf, 0xd4, 0xa9, 0xb8, 0xd6, 0x9a, 0x16, 0x2e,
- 0x6c, 0x4a, 0x25, 0x51, 0x7a, 0x09, 0x48, 0xdd,
- 0xf0, 0xa3, 0x5b, 0x08, 0x1e, 0x2f, 0x03, 0x91,
- 0x80, 0xe8, 0x0f, 0xe9, 0x5a, 0x2f, 0x90, 0xd3,
- 0x64, 0xed, 0xd7, 0x51, 0x17, 0x66, 0x53, 0x40,
- 0x43, 0x74, 0xef, 0x0a, 0x0d, 0x49, 0x41, 0xf2,
- 0x67, 0x6e, 0xea, 0x14, 0xc8, 0x74, 0xd6, 0xa9,
- 0xb9, 0x6a, 0xe3, 0xec, 0x7d, 0xe8, 0x6a, 0x21,
- 0x3a, 0x52, 0x42, 0xfe, 0x9a, 0x15, 0x6d, 0x60,
- 0x64, 0x88, 0xc5, 0xb2, 0x8b, 0x15, 0x2c, 0xff,
- 0xe2, 0x35, 0xc3, 0xee, 0x9f, 0xcd, 0x82, 0xd9,
- 0x14, 0x35, 0x2a, 0xb7, 0xf5, 0x2f, 0x7b, 0xbc,
- 0x01, 0xfd, 0xa8, 0xe0, 0x21, 0x4e, 0x73, 0xf9,
- 0xf2, 0xb0, 0x79, 0xc9, 0x10, 0x52, 0x8f, 0xa8,
- 0x3e, 0x3b, 0xbe, 0xc5, 0xde, 0xf6, 0x53, 0xe3,
- 0x1c, 0x25, 0x3a, 0x1f, 0x13, 0xbf, 0x13, 0xbb,
- 0x94, 0xc2, 0x97, 0x43, 0x64, 0x47, 0x8f, 0x76,
- 0xd7, 0xaa, 0xeb, 0xa4, 0x03, 0x50, 0x0c, 0x10,
- 0x50, 0xd8, 0xf7, 0x75, 0x52, 0x42, 0xe2, 0x94,
- 0x67, 0xf4, 0x60, 0xfb, 0x21, 0x9b, 0x7a, 0x05,
- 0x50, 0x7c, 0x1b, 0x4a, 0x8b, 0x29, 0xe1, 0xac,
- 0xd7, 0x99, 0xfd, 0x0d, 0x65, 0x92, 0xcd, 0x23,
- 0xa7, 0x35, 0x8e, 0x13, 0xf2, 0xe4, 0x10, 0x74,
- 0xc6, 0x4f, 0x19, 0xf7, 0x01, 0x0b, 0x46, 0xab,
- 0xef, 0x8d, 0x4a, 0x4a, 0xfa, 0xda, 0xf3, 0xfb,
- 0x40, 0x28, 0x88, 0xa2, 0x65, 0x98, 0x4d, 0x88,
- 0xc7, 0xbf, 0x00, 0xc8, 0xd0, 0x91, 0xcb, 0x89,
- 0x2f, 0xb0, 0x85, 0xfc, 0xa1, 0xc1, 0x9e, 0x83,
- 0x88, 0xad, 0x95, 0xc0, 0x31, 0xa0, 0xad, 0xa2,
- 0x42, 0xb5, 0xe7, 0x55, 0xd4, 0x93, 0x5a, 0x74,
- 0x4e, 0x41, 0xc3, 0xcf, 0x96, 0x83, 0x46, 0xa1,
- 0xb7, 0x5b, 0xb1, 0x34, 0x67, 0x4e, 0xb1, 0xd7,
- 0x40, 0x20, 0x72, 0xe9, 0xc8, 0x74, 0xb7, 0xde,
- 0x72, 0x29, 0x77, 0x4c, 0x74, 0x7e, 0xcc, 0x18,
- 0xa5, 0x8d, 0x79, 0x8c, 0xd6, 0x6e, 0xcb, 0xd9,
- 0xe1, 0x61, 0xe7, 0x36, 0xbc, 0x37, 0xea, 0xee,
- 0xd8, 0x3c, 0x5e, 0x7c, 0x47, 0x50, 0xd5, 0xec,
- 0x37, 0xc5, 0x63, 0xc3, 0xc9, 0x99, 0x23, 0x9f,
- 0x64, 0x39, 0xdf, 0x13, 0x96, 0x6d, 0xea, 0x08,
- 0x0c, 0x27, 0x2d, 0xfe, 0x0f, 0xc2, 0xa3, 0x97,
- 0x04, 0x12, 0x66, 0x0d, 0x94, 0xbf, 0xbe, 0x3e,
- 0xb9, 0xcf, 0x8e, 0xc1, 0x9d, 0xb1, 0x64, 0x17,
- 0x54, 0x92, 0x3f, 0x0a, 0x51, 0xc8, 0xf5, 0x82,
- 0x98, 0x73, 0x03, 0xc0, 0x5a, 0x51, 0x01, 0x67,
- 0xb4, 0x01, 0x04, 0x06, 0xbc, 0x37, 0xde, 0x96,
- 0x23, 0x3c, 0xce, 0x98, 0x3f, 0xd6, 0x51, 0x1b,
- 0x01, 0x83, 0x0a, 0x1c, 0xf9, 0xeb, 0x7e, 0x72,
- 0xa9, 0x51, 0x23, 0xc8, 0xd7, 0x2f, 0x12, 0xbc,
- 0x08, 0xac, 0x07, 0xe7, 0xa7, 0xe6, 0x46, 0xae,
- 0x54, 0xa3, 0xc2, 0xf2, 0x05, 0x2d, 0x06, 0x5e,
- 0xfc, 0xe2, 0xa2, 0x23, 0xac, 0x86, 0xf2, 0x54,
- 0x83, 0x4a, 0xb6, 0x48, 0x93, 0xa1, 0x78, 0xc2,
- 0x07, 0xec, 0x82, 0xf0, 0x74, 0xa9, 0x18, 0xe9,
- 0x53, 0x44, 0x49, 0xc2, 0x94, 0xf8, 0x94, 0x92,
- 0x08, 0x3f, 0xbf, 0xa6, 0xe5, 0xc6, 0x03, 0x8a,
- 0xc6, 0x90, 0x48, 0x6c, 0xee, 0xbd, 0x44, 0x92,
- 0x1f, 0x2a, 0xce, 0x1d, 0xb8, 0x31, 0xa2, 0x9d,
- 0x24, 0x93, 0xa8, 0x9f, 0x36, 0x00, 0x04, 0x7b,
- 0xcb, 0x93, 0x59, 0xa1, 0x53, 0xdb, 0x13, 0x7a,
- 0x54, 0xb1, 0x04, 0xdb, 0xce, 0x48, 0x4f, 0xe5,
- 0x2f, 0xcb, 0xdf, 0x8f, 0x50, 0x7c, 0xfc, 0x76,
- 0x80, 0xb4, 0xdc, 0x3b, 0xc8, 0x98, 0x95, 0xf5,
- 0x50, 0xba, 0x70, 0x5a, 0x97, 0xd5, 0xfc, 0x98,
- 0x4d, 0xf3, 0x61, 0x0f, 0xcf, 0xac, 0x49, 0x0a,
- 0xdb, 0xc1, 0x42, 0x8f, 0xb6, 0x29, 0xd5, 0x65,
- 0xef, 0x83, 0xf1, 0x30, 0x4b, 0x84, 0xd0, 0x69,
- 0xde, 0xd2, 0x99, 0xe5, 0xec, 0xd3, 0x90, 0x86,
- 0x39, 0x2a, 0x6e, 0xd5, 0x32, 0xe3, 0x0d, 0x2d,
- 0x01, 0x8b, 0x17, 0x55, 0x1d, 0x65, 0x57, 0xbf,
- 0xd8, 0x75, 0xa4, 0x85, 0xb6, 0x4e, 0x35, 0x14,
- 0x58, 0xe4, 0x89, 0xb8, 0x7a, 0x58, 0x86, 0x0c,
- 0xbd, 0x8b, 0x05, 0x7b, 0x63, 0xc0, 0x86, 0x80,
- 0x33, 0x46, 0xd4, 0x9b, 0xb6, 0x0a, 0xeb, 0x6c,
- 0xae, 0xd6, 0x57, 0x7a, 0xc7, 0x59, 0x33, 0xa0,
- 0xda, 0xa4, 0x12, 0xbf, 0x52, 0x22, 0x05, 0x8d,
- 0xeb, 0xee, 0xd5, 0xec, 0xea, 0x29, 0x9b, 0x76,
- 0x95, 0x50, 0x6d, 0x99, 0xe1, 0x45, 0x63, 0x09,
- 0x16, 0x5f, 0xb0, 0xf2, 0x5b, 0x08, 0x33, 0xdd,
- 0x8f, 0xb7, 0x60, 0x7a, 0x8e, 0xc6, 0xfc, 0xac,
- 0xa9, 0x56, 0x2c, 0xa9, 0x8b, 0x74, 0x33, 0xad,
- 0x2a, 0x7e, 0x96, 0xb6, 0xba, 0x22, 0x28, 0xcf,
- 0x4d, 0x96, 0xb7, 0xd1, 0xfa, 0x99, 0x4a, 0x61,
- 0xe6, 0x84, 0xd1, 0x94, 0xca, 0xf5, 0x86, 0xb0,
- 0xba, 0x34, 0x7a, 0x04, 0xcc, 0xd4, 0x81, 0xcd,
- 0xd9, 0x86, 0xb6, 0xe0, 0x5a, 0x6f, 0x9b, 0x99,
- 0xf0, 0xdf, 0x49, 0xae, 0x6d, 0xc2, 0x54, 0x67,
- 0xe0, 0xb4, 0x34, 0x2d, 0x1c, 0x46, 0xdf, 0x73,
- 0x3b, 0x45, 0x43, 0xe7, 0x1f, 0xa3, 0x36, 0x35,
- 0x25, 0x33, 0xd9, 0xc0, 0x54, 0x38, 0x6e, 0x6b,
- 0x80, 0xcf, 0x50, 0xa4, 0xb6, 0x21, 0x17, 0xfd,
- 0x9b, 0x5c, 0x36, 0xca, 0xcc, 0x73, 0x73, 0xad,
- 0xe0, 0x57, 0x77, 0x90, 0x0e, 0x7f, 0x0f, 0x87,
- 0x7f, 0xdb, 0x73, 0xbf, 0xda, 0xc2, 0xb3, 0x05,
- 0x22, 0x06, 0xf5, 0xa3, 0xfc, 0x1e, 0x8f, 0xda,
- 0xcf, 0x49, 0xd6, 0xb3, 0x66, 0x2c, 0xb5, 0x00,
- 0xaf, 0x85, 0x6e, 0xb8, 0x5b, 0x8c, 0xa1, 0xa4,
- 0x21, 0xce, 0x40, 0xf3, 0x98, 0xac, 0xec, 0x88,
- 0x62, 0x43, 0x2a, 0xac, 0xca, 0xcf, 0xb9, 0x30,
- 0xeb, 0xfc, 0xef, 0xf0, 0x6e, 0x64, 0x6d, 0xe7,
- 0x54, 0x88, 0x6b, 0x22, 0x29, 0xbe, 0xa5, 0x8c,
- 0x31, 0x23, 0x3b, 0x4a, 0x80, 0x37, 0xe6, 0xd0,
- 0x05, 0xfc, 0x10, 0x0e, 0xdd, 0xbb, 0x00, 0xc5,
- 0x07, 0x20, 0x59, 0xd3, 0x41, 0x17, 0x86, 0x46,
- 0xab, 0x68, 0xf6, 0x48, 0x3c, 0xea, 0x5a, 0x06,
- 0x30, 0x21, 0x19, 0xed, 0x74, 0xbe, 0x0b, 0x97,
- 0xee, 0x91, 0x35, 0x94, 0x1f, 0xcb, 0x68, 0x7f,
- 0xe4, 0x48, 0xb0, 0x16, 0xfb, 0xf0, 0x74, 0xdb,
- 0x06, 0x59, 0x2e, 0x5a, 0x9c, 0xce, 0x8f, 0x7d,
- 0xba, 0x48, 0xd5, 0x3f, 0x5c, 0xb0, 0xc2, 0x33,
- 0x48, 0x60, 0x17, 0x08, 0x85, 0xba, 0xff, 0xb9,
- 0x34, 0x0a, 0x3d, 0x8f, 0x21, 0x13, 0x12, 0x1b
-};
-
-static const uint8_t AES_CBC_ciphertext_1536B[] = {
- 0x89, 0x93, 0x05, 0x99, 0xa9, 0xed, 0xea, 0x62,
- 0xc9, 0xda, 0x51, 0x15, 0xce, 0x42, 0x91, 0xc3,
- 0x80, 0xc8, 0x03, 0x88, 0xc2, 0x63, 0xda, 0x53,
- 0x1a, 0xf3, 0xeb, 0xd5, 0xba, 0x6f, 0x23, 0xb2,
- 0xed, 0x8f, 0x89, 0xb1, 0xb3, 0xca, 0x90, 0x7a,
- 0xdd, 0x3f, 0xf6, 0xca, 0x86, 0x58, 0x54, 0xbc,
- 0xab, 0x0f, 0xf4, 0xab, 0x6d, 0x5d, 0x42, 0xd0,
- 0x17, 0x49, 0x17, 0xd1, 0x93, 0xea, 0xe8, 0x22,
- 0xc1, 0x34, 0x9f, 0x3a, 0x3b, 0xaa, 0xe9, 0x1b,
- 0x93, 0xff, 0x6b, 0x68, 0xba, 0xe6, 0xd2, 0x39,
- 0x3d, 0x55, 0x34, 0x8f, 0x98, 0x86, 0xb4, 0xd8,
- 0x7c, 0x0d, 0x3e, 0x01, 0x63, 0x04, 0x01, 0xff,
- 0x16, 0x0f, 0x51, 0x5f, 0x73, 0x53, 0xf0, 0x3a,
- 0x38, 0xb4, 0x4d, 0x8d, 0xaf, 0xa3, 0xca, 0x2f,
- 0x6f, 0xdf, 0xc0, 0x41, 0x6c, 0x48, 0x60, 0x1a,
- 0xe4, 0xe7, 0x8a, 0x65, 0x6f, 0x8d, 0xd7, 0xe1,
- 0x10, 0xab, 0x78, 0x5b, 0xb9, 0x69, 0x1f, 0xe0,
- 0x5c, 0xf1, 0x19, 0x12, 0x21, 0xc7, 0x51, 0xbc,
- 0x61, 0x5f, 0xc0, 0x36, 0x17, 0xc0, 0x28, 0xd9,
- 0x51, 0xcb, 0x43, 0xd9, 0xfa, 0xd1, 0xad, 0x79,
- 0x69, 0x86, 0x49, 0xc5, 0xe5, 0x69, 0x27, 0xce,
- 0x22, 0xd0, 0xe1, 0x6a, 0xf9, 0x02, 0xca, 0x6c,
- 0x34, 0xc7, 0xb8, 0x02, 0xc1, 0x38, 0x7f, 0xd5,
- 0x15, 0xf5, 0xd6, 0xeb, 0xf9, 0x30, 0x40, 0x43,
- 0xea, 0x87, 0xde, 0x35, 0xf6, 0x83, 0x59, 0x09,
- 0x68, 0x62, 0x00, 0x87, 0xb8, 0xe7, 0xca, 0x05,
- 0x0f, 0xac, 0x42, 0x58, 0x45, 0xaa, 0xc9, 0x9b,
- 0xfd, 0x2a, 0xda, 0x65, 0x33, 0x93, 0x9d, 0xc6,
- 0x93, 0x8d, 0xe2, 0xc5, 0x71, 0xc1, 0x5c, 0x13,
- 0xde, 0x7b, 0xd4, 0xb9, 0x4c, 0x35, 0x61, 0x85,
- 0x90, 0x78, 0xf7, 0x81, 0x98, 0x45, 0x99, 0x24,
- 0x58, 0x73, 0x28, 0xf8, 0x31, 0xab, 0x54, 0x2e,
- 0xc0, 0x38, 0x77, 0x25, 0x5c, 0x06, 0x9c, 0xc3,
- 0x69, 0x21, 0x92, 0x76, 0xe1, 0x16, 0xdc, 0xa9,
- 0xee, 0xb6, 0x80, 0x66, 0x43, 0x11, 0x24, 0xb3,
- 0x07, 0x17, 0x89, 0x0f, 0xcb, 0xe0, 0x60, 0xa8,
- 0x9d, 0x06, 0x4b, 0x6e, 0x72, 0xb7, 0xbc, 0x4f,
- 0xb8, 0xc0, 0x80, 0xa2, 0xfb, 0x46, 0x5b, 0x8f,
- 0x11, 0x01, 0x92, 0x9d, 0x37, 0x09, 0x98, 0xc8,
- 0x0a, 0x46, 0xae, 0x12, 0xac, 0x61, 0x3f, 0xe7,
- 0x41, 0x1a, 0xaa, 0x2e, 0xdc, 0xd7, 0x2a, 0x47,
- 0xee, 0xdf, 0x08, 0xd1, 0xff, 0xea, 0x13, 0xc6,
- 0x05, 0xdb, 0x29, 0xcc, 0x03, 0xba, 0x7b, 0x6d,
- 0x40, 0xc1, 0xc9, 0x76, 0x75, 0x03, 0x7a, 0x71,
- 0xc9, 0x5f, 0xd9, 0xe0, 0x61, 0x69, 0x36, 0x8f,
- 0xb2, 0xbc, 0x28, 0xf3, 0x90, 0x71, 0xda, 0x5f,
- 0x08, 0xd5, 0x0d, 0xc1, 0xe6, 0xbd, 0x2b, 0xc6,
- 0x6c, 0x42, 0xfd, 0xbf, 0x10, 0xe8, 0x5f, 0x87,
- 0x3d, 0x21, 0x42, 0x85, 0x01, 0x0a, 0xbf, 0x8e,
- 0x49, 0xd3, 0x9c, 0x89, 0x3b, 0xea, 0xe1, 0xbf,
- 0xe9, 0x9b, 0x5e, 0x0e, 0xb8, 0xeb, 0xcd, 0x3a,
- 0xf6, 0x29, 0x41, 0x35, 0xdd, 0x9b, 0x13, 0x24,
- 0xe0, 0x1d, 0x8a, 0xcb, 0x20, 0xf8, 0x41, 0x51,
- 0x3e, 0x23, 0x8c, 0x67, 0x98, 0x39, 0x53, 0x77,
- 0x2a, 0x68, 0xf4, 0x3c, 0x7e, 0xd6, 0xc4, 0x6e,
- 0xf1, 0x53, 0xe9, 0xd8, 0x5c, 0xc1, 0xa9, 0x38,
- 0x6f, 0x5e, 0xe4, 0xd4, 0x29, 0x1c, 0x6c, 0xee,
- 0x2f, 0xea, 0xde, 0x61, 0x71, 0x5a, 0xea, 0xce,
- 0x23, 0x6e, 0x1b, 0x16, 0x43, 0xb7, 0xc0, 0xe3,
- 0x87, 0xa1, 0x95, 0x1e, 0x97, 0x4d, 0xea, 0xa6,
- 0xf7, 0x25, 0xac, 0x82, 0x2a, 0xd3, 0xa6, 0x99,
- 0x75, 0xdd, 0xc1, 0x55, 0x32, 0x6b, 0xea, 0x33,
- 0x88, 0xce, 0x06, 0xac, 0x15, 0x39, 0x19, 0xa3,
- 0x59, 0xaf, 0x7a, 0x1f, 0xd9, 0x72, 0x5e, 0xf7,
- 0x4c, 0xf3, 0x5d, 0x6b, 0xf2, 0x16, 0x92, 0xa8,
- 0x9e, 0x3d, 0xd4, 0x4c, 0x72, 0x55, 0x4e, 0x4a,
- 0xf7, 0x8b, 0x2f, 0x67, 0x5a, 0x90, 0xb7, 0xcf,
- 0x16, 0xd3, 0x7b, 0x5a, 0x9a, 0xc8, 0x9f, 0xbf,
- 0x01, 0x76, 0x3b, 0x86, 0x2c, 0x2a, 0x78, 0x10,
- 0x70, 0x05, 0x38, 0xf9, 0xdd, 0x2a, 0x1d, 0x00,
- 0x25, 0xb7, 0x10, 0xac, 0x3b, 0x3c, 0x4d, 0x3c,
- 0x01, 0x68, 0x3c, 0x5a, 0x29, 0xc2, 0xa0, 0x1b,
- 0x95, 0x67, 0xf9, 0x0a, 0x60, 0xb7, 0x11, 0x9c,
- 0x40, 0x45, 0xd7, 0xb0, 0xda, 0x49, 0x87, 0xcd,
- 0xb0, 0x9b, 0x61, 0x8c, 0xf4, 0x0d, 0x94, 0x1d,
- 0x79, 0x66, 0x13, 0x0b, 0xc6, 0x6b, 0x19, 0xee,
- 0xa0, 0x6b, 0x64, 0x7d, 0xc4, 0xff, 0x98, 0x72,
- 0x60, 0xab, 0x7f, 0x0f, 0x4d, 0x5d, 0x6b, 0xc3,
- 0xba, 0x5e, 0x0d, 0x04, 0xd9, 0x59, 0x17, 0xd0,
- 0x64, 0xbe, 0xfb, 0x58, 0xfc, 0xed, 0x18, 0xf6,
- 0xac, 0x19, 0xa4, 0xfd, 0x16, 0x59, 0x80, 0x58,
- 0xb8, 0x0f, 0x79, 0x24, 0x60, 0x18, 0x62, 0xa9,
- 0xa3, 0xa0, 0xe8, 0x81, 0xd6, 0xec, 0x5b, 0xfe,
- 0x5b, 0xb8, 0xa4, 0x00, 0xa9, 0xd0, 0x90, 0x17,
- 0xe5, 0x50, 0x3d, 0x2b, 0x12, 0x6e, 0x2a, 0x13,
- 0x65, 0x7c, 0xdf, 0xdf, 0xa7, 0xdd, 0x9f, 0x78,
- 0x5f, 0x8f, 0x4e, 0x90, 0xa6, 0x10, 0xe4, 0x7b,
- 0x68, 0x6b, 0xfd, 0xa9, 0x6d, 0x47, 0xfa, 0xec,
- 0x42, 0x35, 0x07, 0x12, 0x3e, 0x78, 0x23, 0x15,
- 0xff, 0xe2, 0x65, 0xc7, 0x47, 0x89, 0x2f, 0x97,
- 0x7c, 0xd7, 0x6b, 0x69, 0x35, 0x79, 0x6f, 0x85,
- 0xb4, 0xa9, 0x75, 0x04, 0x32, 0x9a, 0xfe, 0xf0,
- 0xce, 0xe3, 0xf1, 0xab, 0x15, 0x47, 0xe4, 0x9c,
- 0xc1, 0x48, 0x32, 0x3c, 0xbe, 0x44, 0x72, 0xc9,
- 0xaa, 0x50, 0x37, 0xa6, 0xbe, 0x41, 0xcf, 0xe8,
- 0x17, 0x4e, 0x37, 0xbe, 0xf1, 0x34, 0x2c, 0xd9,
- 0x60, 0x48, 0x09, 0xa5, 0x26, 0x00, 0x31, 0x77,
- 0x4e, 0xac, 0x7c, 0x89, 0x75, 0xe3, 0xde, 0x26,
- 0x4c, 0x32, 0x54, 0x27, 0x8e, 0x92, 0x26, 0x42,
- 0x85, 0x76, 0x01, 0x76, 0x62, 0x4c, 0x29, 0xe9,
- 0x38, 0x05, 0x51, 0x54, 0x97, 0xa3, 0x03, 0x59,
- 0x5e, 0xec, 0x0c, 0xe4, 0x96, 0xb7, 0x15, 0xa8,
- 0x41, 0x06, 0x2b, 0x78, 0x95, 0x24, 0xf6, 0x32,
- 0xc5, 0xec, 0xd7, 0x89, 0x28, 0x1e, 0xec, 0xb1,
- 0xc7, 0x21, 0x0c, 0xd3, 0x80, 0x7c, 0x5a, 0xe6,
- 0xb1, 0x3a, 0x52, 0x33, 0x84, 0x4e, 0x32, 0x6e,
- 0x7a, 0xf6, 0x43, 0x15, 0x5b, 0xa6, 0xba, 0xeb,
- 0xa8, 0xe4, 0xff, 0x4f, 0xbd, 0xbd, 0xa8, 0x5e,
- 0xbe, 0x27, 0xaf, 0xc5, 0xf7, 0x9e, 0xdf, 0x48,
- 0x22, 0xca, 0x6a, 0x0b, 0x3c, 0xd7, 0xe0, 0xdc,
- 0xf3, 0x71, 0x08, 0xdc, 0x28, 0x13, 0x08, 0xf2,
- 0x08, 0x1d, 0x9d, 0x7b, 0xd9, 0xde, 0x6f, 0xe6,
- 0xe8, 0x88, 0x18, 0xc2, 0xcd, 0x93, 0xc5, 0x38,
- 0x21, 0x68, 0x4c, 0x9a, 0xfb, 0xb6, 0x18, 0x16,
- 0x73, 0x2c, 0x1d, 0x6f, 0x95, 0xfb, 0x65, 0x4f,
- 0x7c, 0xec, 0x8d, 0x6c, 0xa8, 0xc0, 0x55, 0x28,
- 0xc6, 0xc3, 0xea, 0xeb, 0x05, 0xf5, 0x65, 0xeb,
- 0x53, 0xe1, 0x54, 0xef, 0xb8, 0x64, 0x98, 0x2d,
- 0x98, 0x9e, 0xc8, 0xfe, 0xa2, 0x07, 0x30, 0xf7,
- 0xf7, 0xae, 0xdb, 0x32, 0xf8, 0x71, 0x9d, 0x06,
- 0xdf, 0x9b, 0xda, 0x61, 0x7d, 0xdb, 0xae, 0x06,
- 0x24, 0x63, 0x74, 0xb6, 0xf3, 0x1b, 0x66, 0x09,
- 0x60, 0xff, 0x2b, 0x29, 0xf5, 0xa9, 0x9d, 0x61,
- 0x5d, 0x55, 0x10, 0x82, 0x21, 0xbb, 0x64, 0x0d,
- 0xef, 0x5c, 0xe3, 0x30, 0x1b, 0x60, 0x1e, 0x5b,
- 0xfe, 0x6c, 0xf5, 0x15, 0xa3, 0x86, 0x27, 0x58,
- 0x46, 0x00, 0x20, 0xcb, 0x86, 0x9a, 0x52, 0x29,
- 0x20, 0x68, 0x4d, 0x67, 0x88, 0x70, 0xc2, 0x31,
- 0xd8, 0xbb, 0xa5, 0xa7, 0x88, 0x7f, 0x66, 0xbc,
- 0xaa, 0x0f, 0xe1, 0x78, 0x7b, 0x97, 0x3c, 0xb7,
- 0xd7, 0xd8, 0x04, 0xe0, 0x09, 0x60, 0xc8, 0xd0,
- 0x9e, 0xe5, 0x6b, 0x31, 0x7f, 0x88, 0xfe, 0xc3,
- 0xfd, 0x89, 0xec, 0x76, 0x4b, 0xb3, 0xa7, 0x37,
- 0x03, 0xb7, 0xc6, 0x10, 0x7c, 0x9d, 0x0c, 0x75,
- 0xd3, 0x08, 0x14, 0x94, 0x03, 0x42, 0x25, 0x26,
- 0x85, 0xf7, 0xf0, 0x90, 0x06, 0x3e, 0x6f, 0x60,
- 0x52, 0x55, 0xd5, 0x0f, 0x79, 0x64, 0x69, 0x69,
- 0x46, 0xf9, 0x7f, 0x7f, 0x03, 0xf1, 0x1f, 0xdb,
- 0x39, 0x05, 0xba, 0x4a, 0x8f, 0x17, 0xe7, 0xba,
- 0xe2, 0x07, 0x7c, 0x1d, 0x9e, 0xbc, 0x94, 0xc0,
- 0x61, 0x59, 0x8e, 0x72, 0xaf, 0xfc, 0x99, 0xe4,
- 0xd5, 0xa8, 0xee, 0x0a, 0x48, 0x2d, 0x82, 0x8b,
- 0x34, 0x54, 0x8a, 0xce, 0xc7, 0xfa, 0xdd, 0xba,
- 0x54, 0xdf, 0xb3, 0x30, 0x33, 0x73, 0x2e, 0xd5,
- 0x52, 0xab, 0x49, 0x91, 0x4e, 0x0a, 0xd6, 0x2f,
- 0x67, 0xe4, 0xdd, 0x64, 0x48, 0x16, 0xd9, 0x85,
- 0xaa, 0x52, 0xa5, 0x0b, 0xd3, 0xb4, 0x2d, 0x77,
- 0x5e, 0x52, 0x77, 0x17, 0xcf, 0xbe, 0x88, 0x04,
- 0x01, 0x52, 0xe2, 0xf1, 0x46, 0xe2, 0x91, 0x30,
- 0x65, 0xcf, 0xc0, 0x65, 0x45, 0xc3, 0x7e, 0xf4,
- 0x2e, 0xb5, 0xaf, 0x6f, 0xab, 0x1a, 0xfa, 0x70,
- 0x35, 0xb8, 0x4f, 0x2d, 0x78, 0x90, 0x33, 0xb5,
- 0x9a, 0x67, 0xdb, 0x2f, 0x28, 0x32, 0xb6, 0x54,
- 0xab, 0x4c, 0x6b, 0x85, 0xed, 0x6c, 0x3e, 0x05,
- 0x2a, 0xc7, 0x32, 0xe8, 0xf5, 0xa3, 0x7b, 0x4e,
- 0x7b, 0x58, 0x24, 0x73, 0xf7, 0xfd, 0xc7, 0xc8,
- 0x6c, 0x71, 0x68, 0xb1, 0xf6, 0xc5, 0x9e, 0x1e,
- 0xe3, 0x5c, 0x25, 0xc0, 0x5b, 0x3e, 0x59, 0xa1,
- 0x18, 0x5a, 0xe8, 0xb5, 0xd1, 0x44, 0x13, 0xa3,
- 0xe6, 0x05, 0x76, 0xd2, 0x8d, 0x6e, 0x54, 0x68,
- 0x0c, 0xa4, 0x7b, 0x8b, 0xd3, 0x8c, 0x42, 0x13,
- 0x87, 0xda, 0xdf, 0x8f, 0xa5, 0x83, 0x7a, 0x42,
- 0x99, 0xb7, 0xeb, 0xe2, 0x79, 0xe0, 0xdb, 0xda,
- 0x33, 0xa8, 0x50, 0x3a, 0xd7, 0xe7, 0xd3, 0x61,
- 0x18, 0xb8, 0xaa, 0x2d, 0xc8, 0xd8, 0x2c, 0x28,
- 0xe5, 0x97, 0x0a, 0x7c, 0x6c, 0x7f, 0x09, 0xd7,
- 0x88, 0x80, 0xac, 0x12, 0xed, 0xf8, 0xc6, 0xb5,
- 0x2d, 0xd6, 0x63, 0x9b, 0x98, 0x35, 0x26, 0xde,
- 0xf6, 0x31, 0xee, 0x7e, 0xa0, 0xfb, 0x16, 0x98,
- 0xb1, 0x96, 0x1d, 0xee, 0xe3, 0x2f, 0xfb, 0x41,
- 0xdd, 0xea, 0x10, 0x1e, 0x03, 0x89, 0x18, 0xd2,
- 0x47, 0x0c, 0xa0, 0x57, 0xda, 0x76, 0x3a, 0x37,
- 0x2c, 0xe4, 0xf9, 0x77, 0xc8, 0x43, 0x5f, 0xcb,
- 0xd6, 0x85, 0xf7, 0x22, 0xe4, 0x32, 0x25, 0xa8,
- 0xdc, 0x21, 0xc0, 0xf5, 0x95, 0xb2, 0xf8, 0x83,
- 0xf0, 0x65, 0x61, 0x15, 0x48, 0x94, 0xb7, 0x03,
- 0x7f, 0x66, 0xa1, 0x39, 0x1f, 0xdd, 0xce, 0x96,
- 0xfe, 0x58, 0x81, 0x3d, 0x41, 0x11, 0x87, 0x13,
- 0x26, 0x1b, 0x6d, 0xf3, 0xca, 0x2e, 0x2c, 0x76,
- 0xd3, 0x2f, 0x6d, 0x49, 0x70, 0x53, 0x05, 0x96,
- 0xcc, 0x30, 0x2b, 0x83, 0xf2, 0xc6, 0xb2, 0x4b,
- 0x22, 0x13, 0x95, 0x42, 0xeb, 0x56, 0x4d, 0x22,
- 0xe6, 0x43, 0x6f, 0xba, 0xe7, 0x3b, 0xe5, 0x59,
- 0xce, 0x57, 0x88, 0x85, 0xb6, 0xbf, 0x15, 0x37,
- 0xb3, 0x7a, 0x7e, 0xc4, 0xbc, 0x99, 0xfc, 0xe4,
- 0x89, 0x00, 0x68, 0x39, 0xbc, 0x5a, 0xba, 0xab,
- 0x52, 0xab, 0xe6, 0x81, 0xfd, 0x93, 0x62, 0xe9,
- 0xb7, 0x12, 0xd1, 0x18, 0x1a, 0xb9, 0x55, 0x4a,
- 0x0f, 0xae, 0x35, 0x11, 0x04, 0x27, 0xf3, 0x42,
- 0x4e, 0xca, 0xdf, 0x9f, 0x12, 0x62, 0xea, 0x03,
- 0xc0, 0xa9, 0x22, 0x7b, 0x6c, 0x6c, 0xe3, 0xdf,
- 0x16, 0xad, 0x03, 0xc9, 0xfe, 0xa4, 0xdd, 0x4f
-};
-
-static const uint8_t AES_CBC_ciphertext_1792B[] = {
- 0x59, 0xcc, 0xfe, 0x8f, 0xb4, 0x9d, 0x0e, 0xd1,
- 0x85, 0xfc, 0x9b, 0x43, 0xc1, 0xb7, 0x54, 0x67,
- 0x01, 0xef, 0xb8, 0x71, 0x36, 0xdb, 0x50, 0x48,
- 0x7a, 0xea, 0xcf, 0xce, 0xba, 0x30, 0x10, 0x2e,
- 0x96, 0x2b, 0xfd, 0xcf, 0x00, 0xe3, 0x1f, 0xac,
- 0x66, 0x14, 0x30, 0x86, 0x49, 0xdb, 0x01, 0x8b,
- 0x07, 0xdd, 0x00, 0x9d, 0x0d, 0x5c, 0x19, 0x11,
- 0xe8, 0x44, 0x2b, 0x25, 0x70, 0xed, 0x7c, 0x33,
- 0x0d, 0xe3, 0x34, 0x93, 0x63, 0xad, 0x26, 0xb1,
- 0x11, 0x91, 0x34, 0x2e, 0x1d, 0x50, 0xaa, 0xd4,
- 0xef, 0x3a, 0x6d, 0xd7, 0x33, 0x20, 0x0d, 0x3f,
- 0x9b, 0xdd, 0xc3, 0xa5, 0xc5, 0xf1, 0x99, 0xdc,
- 0xea, 0x52, 0xda, 0x55, 0xea, 0xa2, 0x7a, 0xc5,
- 0x78, 0x44, 0x4a, 0x02, 0x33, 0x19, 0x62, 0x37,
- 0xf8, 0x8b, 0xd1, 0x0c, 0x21, 0xdf, 0x40, 0x19,
- 0x81, 0xea, 0xfb, 0x1c, 0xa7, 0xcc, 0x60, 0xfe,
- 0x63, 0x25, 0x8f, 0xf3, 0x73, 0x0f, 0x45, 0xe6,
- 0x6a, 0x18, 0xbf, 0xbe, 0xad, 0x92, 0x2a, 0x1e,
- 0x15, 0x65, 0x6f, 0xef, 0x92, 0xcd, 0x0e, 0x19,
- 0x3d, 0x42, 0xa8, 0xfc, 0x0d, 0x32, 0x58, 0xe0,
- 0x56, 0x9f, 0xd6, 0x9b, 0x8b, 0xec, 0xe0, 0x45,
- 0x4d, 0x7e, 0x73, 0x87, 0xff, 0x74, 0x92, 0x59,
- 0x60, 0x13, 0x93, 0xda, 0xec, 0xbf, 0xfa, 0x20,
- 0xb6, 0xe7, 0xdf, 0xc7, 0x10, 0xf5, 0x79, 0xb4,
- 0xd7, 0xac, 0xaf, 0x2b, 0x37, 0x52, 0x30, 0x1d,
- 0xbe, 0x0f, 0x60, 0x77, 0x3d, 0x03, 0x63, 0xa9,
- 0xae, 0xb1, 0xf3, 0xca, 0xca, 0xb4, 0x21, 0xd7,
- 0x6f, 0x2e, 0x5e, 0x9b, 0x68, 0x53, 0x80, 0xab,
- 0x30, 0x23, 0x0a, 0x72, 0x6b, 0xb1, 0xd8, 0x25,
- 0x5d, 0x3a, 0x62, 0x9b, 0x4f, 0x59, 0x3b, 0x79,
- 0xa8, 0x9e, 0x08, 0x6d, 0x37, 0xb0, 0xfc, 0x42,
- 0x51, 0x25, 0x86, 0xbd, 0x54, 0x5a, 0x95, 0x20,
- 0x6c, 0xac, 0xb9, 0x30, 0x1c, 0x03, 0xc9, 0x49,
- 0x38, 0x55, 0x31, 0x49, 0xed, 0xa9, 0x0e, 0xc3,
- 0x65, 0xb4, 0x68, 0x6b, 0x07, 0x4c, 0x0a, 0xf9,
- 0x21, 0x69, 0x7c, 0x9f, 0x28, 0x80, 0xe9, 0x49,
- 0x22, 0x7c, 0xec, 0x97, 0xf7, 0x70, 0xb4, 0xb8,
- 0x25, 0xe7, 0x80, 0x2c, 0x43, 0x24, 0x8a, 0x2e,
- 0xac, 0xa2, 0x84, 0x20, 0xe7, 0xf4, 0x6b, 0x86,
- 0x37, 0x05, 0xc7, 0x59, 0x04, 0x49, 0x2a, 0x99,
- 0x80, 0x46, 0x32, 0x19, 0xe6, 0x30, 0xce, 0xc0,
- 0xef, 0x6e, 0xec, 0xe5, 0x2f, 0x24, 0xc1, 0x78,
- 0x45, 0x02, 0xd3, 0x64, 0x99, 0xf5, 0xc7, 0xbc,
- 0x8f, 0x8c, 0x75, 0xb1, 0x0a, 0xc8, 0xc3, 0xbd,
- 0x5e, 0x7e, 0xbd, 0x0e, 0xdf, 0x4b, 0x96, 0x6a,
- 0xfd, 0x03, 0xdb, 0xd1, 0x31, 0x1e, 0x27, 0xf9,
- 0xe5, 0x83, 0x9a, 0xfc, 0x13, 0x4c, 0xd3, 0x04,
- 0xdb, 0xdb, 0x3f, 0x35, 0x93, 0x4e, 0x14, 0x6b,
- 0x00, 0x5c, 0xb6, 0x11, 0x50, 0xee, 0x61, 0x5c,
- 0x10, 0x5c, 0xd0, 0x90, 0x02, 0x2e, 0x12, 0xe0,
- 0x50, 0x44, 0xad, 0x75, 0xcd, 0x94, 0xcf, 0x92,
- 0xcb, 0xe3, 0xe8, 0x77, 0x4b, 0xd7, 0x1a, 0x7c,
- 0xdd, 0x6b, 0x49, 0x21, 0x7c, 0xe8, 0x2c, 0x25,
- 0x49, 0x86, 0x1e, 0x54, 0xae, 0xfc, 0x0e, 0x80,
- 0xb1, 0xd5, 0xa5, 0x23, 0xcf, 0xcc, 0x0e, 0x11,
- 0xe2, 0x7c, 0x3c, 0x25, 0x78, 0x64, 0x03, 0xa1,
- 0xdd, 0x9f, 0x74, 0x12, 0x7b, 0x21, 0xb5, 0x73,
- 0x15, 0x3c, 0xed, 0xad, 0x07, 0x62, 0x21, 0x79,
- 0xd4, 0x2f, 0x0d, 0x72, 0xe9, 0x7c, 0x6b, 0x96,
- 0x6e, 0xe5, 0x36, 0x4a, 0xd2, 0x38, 0xe1, 0xff,
- 0x6e, 0x26, 0xa4, 0xac, 0x83, 0x07, 0xe6, 0x67,
- 0x74, 0x6c, 0xec, 0x8b, 0x4b, 0x79, 0x33, 0x50,
- 0x2f, 0x8f, 0xa0, 0x8f, 0xfa, 0x38, 0x6a, 0xa2,
- 0x3a, 0x42, 0x85, 0x15, 0x90, 0xd0, 0xb3, 0x0d,
- 0x8a, 0xe4, 0x60, 0x03, 0xef, 0xf9, 0x65, 0x8a,
- 0x4e, 0x50, 0x8c, 0x65, 0xba, 0x61, 0x16, 0xc3,
- 0x93, 0xb7, 0x75, 0x21, 0x98, 0x25, 0x60, 0x6e,
- 0x3d, 0x68, 0xba, 0x7c, 0xe4, 0xf3, 0xd9, 0x9b,
- 0xfb, 0x7a, 0xed, 0x1f, 0xb3, 0x4b, 0x88, 0x74,
- 0x2c, 0xb8, 0x8c, 0x22, 0x95, 0xce, 0x90, 0xf1,
- 0xdb, 0x80, 0xa6, 0x39, 0xae, 0x82, 0xa1, 0xef,
- 0x75, 0xec, 0xfe, 0xf1, 0xe8, 0x04, 0xfd, 0x99,
- 0x1b, 0x5f, 0x45, 0x87, 0x4f, 0xfa, 0xa2, 0x3e,
- 0x3e, 0xb5, 0x01, 0x4b, 0x46, 0xeb, 0x13, 0x9a,
- 0xe4, 0x7d, 0x03, 0x87, 0xb1, 0x59, 0x91, 0x8e,
- 0x37, 0xd3, 0x16, 0xce, 0xef, 0x4b, 0xe9, 0x46,
- 0x8d, 0x2a, 0x50, 0x2f, 0x41, 0xd3, 0x7b, 0xcf,
- 0xf0, 0xb7, 0x8b, 0x65, 0x0f, 0xa3, 0x27, 0x10,
- 0xe9, 0xa9, 0xe9, 0x2c, 0xbe, 0xbb, 0x82, 0xe3,
- 0x7b, 0x0b, 0x81, 0x3e, 0xa4, 0x6a, 0x4f, 0x3b,
- 0xd5, 0x61, 0xf8, 0x47, 0x04, 0x99, 0x5b, 0xff,
- 0xf3, 0x14, 0x6e, 0x57, 0x5b, 0xbf, 0x1b, 0xb4,
- 0x3f, 0xf9, 0x31, 0xf6, 0x95, 0xd5, 0x10, 0xa9,
- 0x72, 0x28, 0x23, 0xa9, 0x6a, 0xa2, 0xcf, 0x7d,
- 0xe3, 0x18, 0x95, 0xda, 0xbc, 0x6f, 0xe9, 0xd8,
- 0xef, 0x49, 0x3f, 0xd3, 0xef, 0x1f, 0xe1, 0x50,
- 0xe8, 0x8a, 0xc0, 0xce, 0xcc, 0xb7, 0x5e, 0x0e,
- 0x8b, 0x95, 0x80, 0xfd, 0x58, 0x2a, 0x9b, 0xc8,
- 0xb4, 0x17, 0x04, 0x46, 0x74, 0xd4, 0x68, 0x91,
- 0x33, 0xc8, 0x31, 0x15, 0x84, 0x16, 0x35, 0x03,
- 0x64, 0x6d, 0xa9, 0x4e, 0x20, 0xeb, 0xa9, 0x3f,
- 0x21, 0x5e, 0x9b, 0x09, 0xc3, 0x45, 0xf8, 0x7c,
- 0x59, 0x62, 0x29, 0x9a, 0x5c, 0xcf, 0xb4, 0x27,
- 0x5e, 0x13, 0xea, 0xb3, 0xef, 0xd9, 0x01, 0x2a,
- 0x65, 0x5f, 0x14, 0xf4, 0xbf, 0x28, 0x89, 0x3d,
- 0xdd, 0x9d, 0x52, 0xbd, 0x9e, 0x5b, 0x3b, 0xd2,
- 0xc2, 0x81, 0x35, 0xb6, 0xac, 0xdd, 0x27, 0xc3,
- 0x7b, 0x01, 0x5a, 0x6d, 0x4c, 0x5e, 0x2c, 0x30,
- 0xcb, 0x3a, 0xfa, 0xc1, 0xd7, 0x31, 0x67, 0x3e,
- 0x08, 0x6a, 0xe8, 0x8c, 0x75, 0xac, 0x1a, 0x6a,
- 0x52, 0xf7, 0x51, 0xcd, 0x85, 0x3f, 0x3c, 0xa7,
- 0xea, 0xbc, 0xd7, 0x18, 0x9e, 0x27, 0x73, 0xe6,
- 0x2b, 0x58, 0xb6, 0xd2, 0x29, 0x68, 0xd5, 0x8f,
- 0x00, 0x4d, 0x55, 0xf6, 0x61, 0x5a, 0xcc, 0x51,
- 0xa6, 0x5e, 0x85, 0xcb, 0x0b, 0xfd, 0x06, 0xca,
- 0xf5, 0xbf, 0x0d, 0x13, 0x74, 0x78, 0x6d, 0x9e,
- 0x20, 0x11, 0x84, 0x3e, 0x78, 0x17, 0x04, 0x4f,
- 0x64, 0x2c, 0x3b, 0x3e, 0x93, 0x7b, 0x58, 0x33,
- 0x07, 0x52, 0xf7, 0x60, 0x6a, 0xa8, 0x3b, 0x19,
- 0x27, 0x7a, 0x93, 0xc5, 0x53, 0xad, 0xec, 0xf6,
- 0xc8, 0x94, 0xee, 0x92, 0xea, 0xee, 0x7e, 0xea,
- 0xb9, 0x5f, 0xac, 0x59, 0x5d, 0x2e, 0x78, 0x53,
- 0x72, 0x81, 0x92, 0xdd, 0x1c, 0x63, 0xbe, 0x02,
- 0xeb, 0xa8, 0x1b, 0x2a, 0x6e, 0x72, 0xe3, 0x2d,
- 0x84, 0x0d, 0x8a, 0x22, 0xf6, 0xba, 0xab, 0x04,
- 0x8e, 0x04, 0x24, 0xdb, 0xcc, 0xe2, 0x69, 0xeb,
- 0x4e, 0xfa, 0x6b, 0x5b, 0xc8, 0xc0, 0xd9, 0x25,
- 0xcb, 0x40, 0x8d, 0x4b, 0x8e, 0xa0, 0xd4, 0x72,
- 0x98, 0x36, 0x46, 0x3b, 0x4f, 0x5f, 0x96, 0x84,
- 0x03, 0x28, 0x86, 0x4d, 0xa1, 0x8a, 0xd7, 0xb2,
- 0x5b, 0x27, 0x01, 0x80, 0x62, 0x49, 0x56, 0xb9,
- 0xa0, 0xa1, 0xe3, 0x6e, 0x22, 0x2a, 0x5d, 0x03,
- 0x86, 0x40, 0x36, 0x22, 0x5e, 0xd2, 0xe5, 0xc0,
- 0x6b, 0xfa, 0xac, 0x80, 0x4e, 0x09, 0x99, 0xbc,
- 0x2f, 0x9b, 0xcc, 0xf3, 0x4e, 0xf7, 0x99, 0x98,
- 0x11, 0x6e, 0x6f, 0x62, 0x22, 0x6b, 0x92, 0x95,
- 0x3b, 0xc3, 0xd2, 0x8e, 0x0f, 0x07, 0xc2, 0x51,
- 0x5c, 0x4d, 0xb2, 0x6e, 0xc0, 0x27, 0x73, 0xcd,
- 0x57, 0xb7, 0xf0, 0xe9, 0x2e, 0xc8, 0xe2, 0x0c,
- 0xd1, 0xb5, 0x0f, 0xff, 0xf9, 0xec, 0x38, 0xba,
- 0x97, 0xd6, 0x94, 0x9b, 0xd1, 0x79, 0xb6, 0x6a,
- 0x01, 0x17, 0xe4, 0x7e, 0xa6, 0xd5, 0x86, 0x19,
- 0xae, 0xf3, 0xf0, 0x62, 0x73, 0xc0, 0xf0, 0x0a,
- 0x7a, 0x96, 0x93, 0x72, 0x89, 0x7e, 0x25, 0x57,
- 0xf8, 0xf7, 0xd5, 0x1e, 0xe5, 0xac, 0xd6, 0x38,
- 0x4f, 0xe8, 0x81, 0xd1, 0x53, 0x41, 0x07, 0x2d,
- 0x58, 0x34, 0x1c, 0xef, 0x74, 0x2e, 0x61, 0xca,
- 0xd3, 0xeb, 0xd6, 0x93, 0x0a, 0xf2, 0xf2, 0x86,
- 0x9c, 0xe3, 0x7a, 0x52, 0xf5, 0x42, 0xf1, 0x8b,
- 0x10, 0xf2, 0x25, 0x68, 0x7e, 0x61, 0xb1, 0x19,
- 0xcf, 0x8f, 0x5a, 0x53, 0xb7, 0x68, 0x4f, 0x1a,
- 0x71, 0xe9, 0x83, 0x91, 0x3a, 0x78, 0x0f, 0xf7,
- 0xd4, 0x74, 0xf5, 0x06, 0xd2, 0x88, 0xb0, 0x06,
- 0xe5, 0xc0, 0xfb, 0xb3, 0x91, 0xad, 0xc0, 0x84,
- 0x31, 0xf2, 0x3a, 0xcf, 0x63, 0xe6, 0x4a, 0xd3,
- 0x78, 0xbe, 0xde, 0x73, 0x3e, 0x02, 0x8e, 0xb8,
- 0x3a, 0xf6, 0x55, 0xa7, 0xf8, 0x5a, 0xb5, 0x0e,
- 0x0c, 0xc5, 0xe5, 0x66, 0xd5, 0xd2, 0x18, 0xf3,
- 0xef, 0xa5, 0xc9, 0x68, 0x69, 0xe0, 0xcd, 0x00,
- 0x33, 0x99, 0x6e, 0xea, 0xcb, 0x06, 0x7a, 0xe1,
- 0xe1, 0x19, 0x0b, 0xe7, 0x08, 0xcd, 0x09, 0x1b,
- 0x85, 0xec, 0xc4, 0xd4, 0x75, 0xf0, 0xd6, 0xfb,
- 0x84, 0x95, 0x07, 0x44, 0xca, 0xa5, 0x2a, 0x6c,
- 0xc2, 0x00, 0x58, 0x08, 0x87, 0x9e, 0x0a, 0xd4,
- 0x06, 0xe2, 0x91, 0x5f, 0xb7, 0x1b, 0x11, 0xfa,
- 0x85, 0xfc, 0x7c, 0xf2, 0x0f, 0x6e, 0x3c, 0x8a,
- 0xe1, 0x0f, 0xa0, 0x33, 0x84, 0xce, 0x81, 0x4d,
- 0x32, 0x4d, 0xeb, 0x41, 0xcf, 0x5a, 0x05, 0x60,
- 0x47, 0x6c, 0x2a, 0xc4, 0x17, 0xd5, 0x16, 0x3a,
- 0xe4, 0xe7, 0xab, 0x84, 0x94, 0x22, 0xff, 0x56,
- 0xb0, 0x0c, 0x92, 0x6c, 0x19, 0x11, 0x4c, 0xb3,
- 0xed, 0x58, 0x48, 0x84, 0x2a, 0xe2, 0x19, 0x2a,
- 0xe1, 0xc0, 0x56, 0x82, 0x3c, 0x83, 0xb4, 0x58,
- 0x2d, 0xf0, 0xb5, 0x1e, 0x76, 0x85, 0x51, 0xc2,
- 0xe4, 0x95, 0x27, 0x96, 0xd1, 0x90, 0xc3, 0x17,
- 0x75, 0xa1, 0xbb, 0x46, 0x5f, 0xa6, 0xf2, 0xef,
- 0x71, 0x56, 0x92, 0xc5, 0x8a, 0x85, 0x52, 0xe4,
- 0x63, 0x21, 0x6f, 0x55, 0x85, 0x2b, 0x6b, 0x0d,
- 0xc9, 0x92, 0x77, 0x67, 0xe3, 0xff, 0x2a, 0x2b,
- 0x90, 0x01, 0x3d, 0x74, 0x63, 0x04, 0x61, 0x3c,
- 0x8e, 0xf8, 0xfc, 0x04, 0xdd, 0x21, 0x85, 0x92,
- 0x1e, 0x4d, 0x51, 0x8d, 0xb5, 0x6b, 0xf1, 0xda,
- 0x96, 0xf5, 0x8e, 0x3c, 0x38, 0x5a, 0xac, 0x9b,
- 0xba, 0x0c, 0x84, 0x5d, 0x50, 0x12, 0xc7, 0xc5,
- 0x7a, 0xcb, 0xb1, 0xfa, 0x16, 0x93, 0xdf, 0x98,
- 0xda, 0x3f, 0x49, 0xa3, 0x94, 0x78, 0x70, 0xc7,
- 0x0b, 0xb6, 0x91, 0xa6, 0x16, 0x2e, 0xcf, 0xfd,
- 0x51, 0x6a, 0x5b, 0xad, 0x7a, 0xdd, 0xa9, 0x48,
- 0x48, 0xac, 0xd6, 0x45, 0xbc, 0x23, 0x31, 0x1d,
- 0x86, 0x54, 0x8a, 0x7f, 0x04, 0x97, 0x71, 0x9e,
- 0xbc, 0x2e, 0x6b, 0xd9, 0x33, 0xc8, 0x20, 0xc9,
- 0xe0, 0x25, 0x86, 0x59, 0x15, 0xcf, 0x63, 0xe5,
- 0x99, 0xf1, 0x24, 0xf1, 0xba, 0xc4, 0x15, 0x02,
- 0xe2, 0xdb, 0xfe, 0x4a, 0xf8, 0x3b, 0x91, 0x13,
- 0x8d, 0x03, 0x81, 0x9f, 0xb3, 0x3f, 0x04, 0x03,
- 0x58, 0xc0, 0xef, 0x27, 0x82, 0x14, 0xd2, 0x7f,
- 0x93, 0x70, 0xb7, 0xb2, 0x02, 0x21, 0xb3, 0x07,
- 0x7f, 0x1c, 0xef, 0x88, 0xee, 0x29, 0x7a, 0x0b,
- 0x3d, 0x75, 0x5a, 0x93, 0xfe, 0x7f, 0x14, 0xf7,
- 0x4e, 0x4b, 0x7f, 0x21, 0x02, 0xad, 0xf9, 0x43,
- 0x29, 0x1a, 0xe8, 0x1b, 0xf5, 0x32, 0xb2, 0x96,
- 0xe6, 0xe8, 0x96, 0x20, 0x9b, 0x96, 0x8e, 0x7b,
- 0xfe, 0xd8, 0xc9, 0x9c, 0x65, 0x16, 0xd6, 0x68,
- 0x95, 0xf8, 0x22, 0xe2, 0xae, 0x84, 0x03, 0xfd,
- 0x87, 0xa2, 0x72, 0x79, 0x74, 0x95, 0xfa, 0xe1,
- 0xfe, 0xd0, 0x4e, 0x3d, 0x39, 0x2e, 0x67, 0x55,
- 0x71, 0x6c, 0x89, 0x33, 0x49, 0x0c, 0x1b, 0x46,
- 0x92, 0x31, 0x6f, 0xa6, 0xf0, 0x09, 0xbd, 0x2d,
- 0xe2, 0xca, 0xda, 0x18, 0x33, 0xce, 0x67, 0x37,
- 0xfd, 0x6f, 0xcb, 0x9d, 0xbd, 0x42, 0xbc, 0xb2,
- 0x9c, 0x28, 0xcd, 0x65, 0x3c, 0x61, 0xbc, 0xde,
- 0x9d, 0xe1, 0x2a, 0x3e, 0xbf, 0xee, 0x3c, 0xcb,
- 0xb1, 0x50, 0xa9, 0x2c, 0xbe, 0xb5, 0x43, 0xd0,
- 0xec, 0x29, 0xf9, 0x16, 0x6f, 0x31, 0xd9, 0x9b,
- 0x92, 0xb1, 0x32, 0xae, 0x0f, 0xb6, 0x9d, 0x0e,
- 0x25, 0x7f, 0x89, 0x1f, 0x1d, 0x01, 0x68, 0xab,
- 0x3d, 0xd1, 0x74, 0x5b, 0x4c, 0x38, 0x7f, 0x3d,
- 0x33, 0xa5, 0xa2, 0x9f, 0xda, 0x84, 0xa5, 0x82,
- 0x2d, 0x16, 0x66, 0x46, 0x08, 0x30, 0x14, 0x48,
- 0x5e, 0xca, 0xe3, 0xf4, 0x8c, 0xcb, 0x32, 0xc6,
- 0xf1, 0x43, 0x62, 0xc6, 0xef, 0x16, 0xfa, 0x43,
- 0xae, 0x9c, 0x53, 0xe3, 0x49, 0x45, 0x80, 0xfd,
- 0x1d, 0x8c, 0xa9, 0x6d, 0x77, 0x76, 0xaa, 0x40,
- 0xc4, 0x4e, 0x7b, 0x78, 0x6b, 0xe0, 0x1d, 0xce,
- 0x56, 0x3d, 0xf0, 0x11, 0xfe, 0x4f, 0x6a, 0x6d,
- 0x0f, 0x4f, 0x90, 0x38, 0x92, 0x17, 0xfa, 0x56,
- 0x12, 0xa6, 0xa1, 0x0a, 0xea, 0x2f, 0x50, 0xf9,
- 0x60, 0x66, 0x6c, 0x7d, 0x5a, 0x08, 0x8e, 0x3c,
- 0xf3, 0xf0, 0x33, 0x02, 0x11, 0x02, 0xfe, 0x4c,
- 0x56, 0x2b, 0x9f, 0x0c, 0xbd, 0x65, 0x8a, 0x83,
- 0xde, 0x7c, 0x05, 0x26, 0x93, 0x19, 0xcc, 0xf3,
- 0x71, 0x0e, 0xad, 0x2f, 0xb3, 0xc9, 0x38, 0x50,
- 0x64, 0xd5, 0x4c, 0x60, 0x5f, 0x02, 0x13, 0x34,
- 0xc9, 0x75, 0xc4, 0x60, 0xab, 0x2e, 0x17, 0x7d
-};
-
-static const uint8_t AES_CBC_ciphertext_2048B[] = {
- 0x8b, 0x55, 0xbd, 0xfd, 0x2b, 0x35, 0x76, 0x5c,
- 0xd1, 0x90, 0xd7, 0x6a, 0x63, 0x1e, 0x39, 0x71,
- 0x0d, 0x5c, 0xd8, 0x03, 0x00, 0x75, 0xf1, 0x07,
- 0x03, 0x8d, 0x76, 0xeb, 0x3b, 0x00, 0x1e, 0x33,
- 0x88, 0xfc, 0x8f, 0x08, 0x4d, 0x33, 0xf1, 0x3c,
- 0xee, 0xd0, 0x5d, 0x19, 0x8b, 0x3c, 0x50, 0x86,
- 0xfd, 0x8d, 0x58, 0x21, 0xb4, 0xae, 0x0f, 0x81,
- 0xe9, 0x9f, 0xc9, 0xc0, 0x90, 0xf7, 0x04, 0x6f,
- 0x39, 0x1d, 0x8a, 0x3f, 0x8d, 0x32, 0x23, 0xb5,
- 0x1f, 0xcc, 0x8a, 0x12, 0x2d, 0x46, 0x82, 0x5e,
- 0x6a, 0x34, 0x8c, 0xb1, 0x93, 0x70, 0x3b, 0xde,
- 0x55, 0xaf, 0x16, 0x35, 0x99, 0x84, 0xd5, 0x88,
- 0xc9, 0x54, 0xb1, 0xb2, 0xd3, 0xeb, 0x9e, 0x55,
- 0x9a, 0xa9, 0xa7, 0xf5, 0xda, 0x29, 0xcf, 0xe1,
- 0x98, 0x64, 0x45, 0x77, 0xf2, 0x12, 0x69, 0x8f,
- 0x78, 0xd8, 0x82, 0x41, 0xb2, 0x9f, 0xe2, 0x1c,
- 0x63, 0x9b, 0x24, 0x81, 0x67, 0x95, 0xa2, 0xff,
- 0x26, 0x9d, 0x65, 0x48, 0x61, 0x30, 0x66, 0x41,
- 0x68, 0x84, 0xbb, 0x59, 0x14, 0x8e, 0x9a, 0x62,
- 0xb6, 0xca, 0xda, 0xbe, 0x7c, 0x41, 0x52, 0x6e,
- 0x1b, 0x86, 0xbf, 0x08, 0xeb, 0x37, 0x84, 0x60,
- 0xe4, 0xc4, 0x1e, 0xa8, 0x4c, 0x84, 0x60, 0x2f,
- 0x70, 0x90, 0xf2, 0x26, 0xe7, 0x65, 0x0c, 0xc4,
- 0x58, 0x36, 0x8e, 0x4d, 0xdf, 0xff, 0x9a, 0x39,
- 0x93, 0x01, 0xcf, 0x6f, 0x6d, 0xde, 0xef, 0x79,
- 0xb0, 0xce, 0xe2, 0x98, 0xdb, 0x85, 0x8d, 0x62,
- 0x9d, 0xb9, 0x63, 0xfd, 0xf0, 0x35, 0xb5, 0xa9,
- 0x1b, 0xf9, 0xe5, 0xd4, 0x2e, 0x22, 0x2d, 0xcc,
- 0x42, 0xbf, 0x0e, 0x51, 0xf7, 0x15, 0x07, 0x32,
- 0x75, 0x5b, 0x74, 0xbb, 0x00, 0xef, 0xd4, 0x66,
- 0x8b, 0xad, 0x71, 0x53, 0x94, 0xd7, 0x7d, 0x2c,
- 0x40, 0x3e, 0x69, 0xa0, 0x4c, 0x86, 0x5e, 0x06,
- 0xed, 0xdf, 0x22, 0xe2, 0x24, 0x25, 0x4e, 0x9b,
- 0x5f, 0x49, 0x74, 0xba, 0xed, 0xb1, 0xa6, 0xeb,
- 0xae, 0x3f, 0xc6, 0x9e, 0x0b, 0x29, 0x28, 0x9a,
- 0xb6, 0xb2, 0x74, 0x58, 0xec, 0xa6, 0x4a, 0xed,
- 0xe5, 0x10, 0x00, 0x85, 0xe1, 0x63, 0x41, 0x61,
- 0x30, 0x7c, 0x97, 0xcf, 0x75, 0xcf, 0xb6, 0xf3,
- 0xf7, 0xda, 0x35, 0x3f, 0x85, 0x8c, 0x64, 0xca,
- 0xb7, 0xea, 0x7f, 0xe4, 0xa3, 0x4d, 0x30, 0x84,
- 0x8c, 0x9c, 0x80, 0x5a, 0x50, 0xa5, 0x64, 0xae,
- 0x26, 0xd3, 0xb5, 0x01, 0x73, 0x36, 0x8a, 0x92,
- 0x49, 0xc4, 0x1a, 0x94, 0x81, 0x9d, 0xf5, 0x6c,
- 0x50, 0xe1, 0x58, 0x0b, 0x75, 0xdd, 0x6b, 0x6a,
- 0xca, 0x69, 0xea, 0xc3, 0x33, 0x90, 0x9f, 0x3b,
- 0x65, 0x5d, 0x5e, 0xee, 0x31, 0xb7, 0x32, 0xfd,
- 0x56, 0x83, 0xb6, 0xfb, 0xa8, 0x04, 0xfc, 0x1e,
- 0x11, 0xfb, 0x02, 0x23, 0x53, 0x49, 0x45, 0xb1,
- 0x07, 0xfc, 0xba, 0xe7, 0x5f, 0x5d, 0x2d, 0x7f,
- 0x9e, 0x46, 0xba, 0xe9, 0xb0, 0xdb, 0x32, 0x04,
- 0xa4, 0xa7, 0x98, 0xab, 0x91, 0xcd, 0x02, 0x05,
- 0xf5, 0x74, 0x31, 0x98, 0x83, 0x3d, 0x33, 0x11,
- 0x0e, 0xe3, 0x8d, 0xa8, 0xc9, 0x0e, 0xf3, 0xb9,
- 0x47, 0x67, 0xe9, 0x79, 0x2b, 0x34, 0xcd, 0x9b,
- 0x45, 0x75, 0x29, 0xf0, 0xbf, 0xcc, 0xda, 0x3a,
- 0x91, 0xb2, 0x15, 0x27, 0x7a, 0xe5, 0xf5, 0x6a,
- 0x5e, 0xbe, 0x2c, 0x98, 0xe8, 0x40, 0x96, 0x4f,
- 0x8a, 0x09, 0xfd, 0xf6, 0xb2, 0xe7, 0x45, 0xb6,
- 0x08, 0xc1, 0x69, 0xe1, 0xb3, 0xc4, 0x24, 0x34,
- 0x07, 0x85, 0xd5, 0xa9, 0x78, 0xca, 0xfa, 0x4b,
- 0x01, 0x19, 0x4d, 0x95, 0xdc, 0xa5, 0xc1, 0x9c,
- 0xec, 0x27, 0x5b, 0xa6, 0x54, 0x25, 0xbd, 0xc8,
- 0x0a, 0xb7, 0x11, 0xfb, 0x4e, 0xeb, 0x65, 0x2e,
- 0xe1, 0x08, 0x9c, 0x3a, 0x45, 0x44, 0x33, 0xef,
- 0x0d, 0xb9, 0xff, 0x3e, 0x68, 0x9c, 0x61, 0x2b,
- 0x11, 0xb8, 0x5c, 0x47, 0x0f, 0x94, 0xf2, 0xf8,
- 0x0b, 0xbb, 0x99, 0x18, 0x85, 0xa3, 0xba, 0x44,
- 0xf3, 0x79, 0xb3, 0x63, 0x2c, 0x1f, 0x2a, 0x35,
- 0x3b, 0x23, 0x98, 0xab, 0xf4, 0x16, 0x36, 0xf8,
- 0xde, 0x86, 0xa4, 0xd4, 0x75, 0xff, 0x51, 0xf9,
- 0xeb, 0x42, 0x5f, 0x55, 0xe2, 0xbe, 0xd1, 0x5b,
- 0xb5, 0x38, 0xeb, 0xb4, 0x4d, 0xec, 0xec, 0x99,
- 0xe1, 0x39, 0x43, 0xaa, 0x64, 0xf7, 0xc9, 0xd8,
- 0xf2, 0x9a, 0x71, 0x43, 0x39, 0x17, 0xe8, 0xa8,
- 0xa2, 0xe2, 0xa4, 0x2c, 0x18, 0x11, 0x49, 0xdf,
- 0x18, 0xdd, 0x85, 0x6e, 0x65, 0x96, 0xe2, 0xba,
- 0xa1, 0x0a, 0x2c, 0xca, 0xdc, 0x5f, 0xe4, 0xf4,
- 0x35, 0x03, 0xb2, 0xa9, 0xda, 0xcf, 0xb7, 0x6d,
- 0x65, 0x82, 0x82, 0x67, 0x9d, 0x0e, 0xf3, 0xe8,
- 0x85, 0x6c, 0x69, 0xb8, 0x4c, 0xa6, 0xc6, 0x2e,
- 0x40, 0xb5, 0x54, 0x28, 0x95, 0xe4, 0x57, 0xe0,
- 0x5b, 0xf8, 0xde, 0x59, 0xe0, 0xfd, 0x89, 0x48,
- 0xac, 0x56, 0x13, 0x54, 0xb9, 0x1b, 0xf5, 0x59,
- 0x97, 0xb6, 0xb3, 0xe8, 0xac, 0x2d, 0xfc, 0xd2,
- 0xea, 0x57, 0x96, 0x57, 0xa8, 0x26, 0x97, 0x2c,
- 0x01, 0x89, 0x56, 0xea, 0xec, 0x8c, 0x53, 0xd5,
- 0xd7, 0x9e, 0xc9, 0x98, 0x0b, 0xad, 0x03, 0x75,
- 0xa0, 0x6e, 0x98, 0x8b, 0x97, 0x8d, 0x8d, 0x85,
- 0x7d, 0x74, 0xa7, 0x2d, 0xde, 0x67, 0x0c, 0xcd,
- 0x54, 0xb8, 0x15, 0x7b, 0xeb, 0xf5, 0x84, 0xb9,
- 0x78, 0xab, 0xd8, 0x68, 0x91, 0x1f, 0x6a, 0xa6,
- 0x28, 0x22, 0xf7, 0x00, 0x49, 0x00, 0xbe, 0x41,
- 0x71, 0x0a, 0xf5, 0xe7, 0x9f, 0xb4, 0x11, 0x41,
- 0x3f, 0xcd, 0xa9, 0xa9, 0x01, 0x8b, 0x6a, 0xeb,
- 0x54, 0x4c, 0x58, 0x92, 0x68, 0x02, 0x0e, 0xe9,
- 0xed, 0x65, 0x4c, 0xfb, 0x95, 0x48, 0x58, 0xa2,
- 0xaa, 0x57, 0x69, 0x13, 0x82, 0x0c, 0x2c, 0x4b,
- 0x5d, 0x4e, 0x18, 0x30, 0xef, 0x1c, 0xb1, 0x9d,
- 0x05, 0x05, 0x02, 0x1c, 0x97, 0xc9, 0x48, 0xfe,
- 0x5e, 0x7b, 0x77, 0xa3, 0x1f, 0x2a, 0x81, 0x42,
- 0xf0, 0x4b, 0x85, 0x12, 0x9c, 0x1f, 0x44, 0xb1,
- 0x14, 0x91, 0x92, 0x65, 0x77, 0xb1, 0x87, 0xa2,
- 0xfc, 0xa4, 0xe7, 0xd2, 0x9b, 0xf2, 0x17, 0xf0,
- 0x30, 0x1c, 0x8d, 0x33, 0xbc, 0x25, 0x28, 0x48,
- 0xfd, 0x30, 0x79, 0x0a, 0x99, 0x3e, 0xb4, 0x0f,
- 0x1e, 0xa6, 0x68, 0x76, 0x19, 0x76, 0x29, 0xac,
- 0x5d, 0xb8, 0x1e, 0x42, 0xd6, 0x85, 0x04, 0xbf,
- 0x64, 0x1c, 0x2d, 0x53, 0xe9, 0x92, 0x78, 0xf8,
- 0xc3, 0xda, 0x96, 0x92, 0x10, 0x6f, 0x45, 0x85,
- 0xaf, 0x5e, 0xcc, 0xa8, 0xc0, 0xc6, 0x2e, 0x73,
- 0x51, 0x3f, 0x5e, 0xd7, 0x52, 0x33, 0x71, 0x12,
- 0x6d, 0x85, 0xee, 0xea, 0x85, 0xa8, 0x48, 0x2b,
- 0x40, 0x64, 0x6d, 0x28, 0x73, 0x16, 0xd7, 0x82,
- 0xd9, 0x90, 0xed, 0x1f, 0xa7, 0x5c, 0xb1, 0x5c,
- 0x27, 0xb9, 0x67, 0x8b, 0xb4, 0x17, 0x13, 0x83,
- 0x5f, 0x09, 0x72, 0x0a, 0xd7, 0xa0, 0xec, 0x81,
- 0x59, 0x19, 0xb9, 0xa6, 0x5a, 0x37, 0x34, 0x14,
- 0x47, 0xf6, 0xe7, 0x6c, 0xd2, 0x09, 0x10, 0xe7,
- 0xdd, 0xbb, 0x02, 0xd1, 0x28, 0xfa, 0x01, 0x2c,
- 0x93, 0x64, 0x2e, 0x1b, 0x4c, 0x02, 0x52, 0xcb,
- 0x07, 0xa1, 0xb6, 0x46, 0x02, 0x80, 0xd9, 0x8f,
- 0x5c, 0x62, 0xbe, 0x78, 0x9e, 0x75, 0xc4, 0x97,
- 0x91, 0x39, 0x12, 0x65, 0xb9, 0x3b, 0xc2, 0xd1,
- 0xaf, 0xf2, 0x1f, 0x4e, 0x4d, 0xd1, 0xf0, 0x9f,
- 0xb7, 0x12, 0xfd, 0xe8, 0x75, 0x18, 0xc0, 0x9d,
- 0x8c, 0x70, 0xff, 0x77, 0x05, 0xb6, 0x1a, 0x1f,
- 0x96, 0x48, 0xf6, 0xfe, 0xd5, 0x5d, 0x98, 0xa5,
- 0x72, 0x1c, 0x84, 0x76, 0x3e, 0xb8, 0x87, 0x37,
- 0xdd, 0xd4, 0x3a, 0x45, 0xdd, 0x09, 0xd8, 0xe7,
- 0x09, 0x2f, 0x3e, 0x33, 0x9e, 0x7b, 0x8c, 0xe4,
- 0x85, 0x12, 0x4e, 0xf8, 0x06, 0xb7, 0xb1, 0x85,
- 0x24, 0x96, 0xd8, 0xfe, 0x87, 0x92, 0x81, 0xb1,
- 0xa3, 0x38, 0xb9, 0x56, 0xe1, 0xf6, 0x36, 0x41,
- 0xbb, 0xd6, 0x56, 0x69, 0x94, 0x57, 0xb3, 0xa4,
- 0xca, 0xa4, 0xe1, 0x02, 0x3b, 0x96, 0x71, 0xe0,
- 0xb2, 0x2f, 0x85, 0x48, 0x1b, 0x4a, 0x41, 0x80,
- 0x4b, 0x9c, 0xe0, 0xc9, 0x39, 0xb8, 0xb1, 0xca,
- 0x64, 0x77, 0x46, 0x58, 0xe6, 0x84, 0xd5, 0x2b,
- 0x65, 0xce, 0xe9, 0x09, 0xa3, 0xaa, 0xfb, 0x83,
- 0xa9, 0x28, 0x68, 0xfd, 0xcd, 0xfd, 0x76, 0x83,
- 0xe1, 0x20, 0x22, 0x77, 0x3a, 0xa3, 0xb2, 0x93,
- 0x14, 0x91, 0xfc, 0xe2, 0x17, 0x63, 0x2b, 0xa6,
- 0x29, 0x38, 0x7b, 0x9b, 0x8b, 0x15, 0x77, 0xd6,
- 0xaa, 0x92, 0x51, 0x53, 0x50, 0xff, 0xa0, 0x35,
- 0xa0, 0x59, 0x7d, 0xf0, 0x11, 0x23, 0x49, 0xdf,
- 0x5a, 0x21, 0xc2, 0xfe, 0x35, 0xa0, 0x1d, 0xe2,
- 0xae, 0xa2, 0x8a, 0x61, 0x5b, 0xf7, 0xf1, 0x1c,
- 0x1c, 0xec, 0xc4, 0xf6, 0xdc, 0xaa, 0xc8, 0xc2,
- 0xe5, 0xa1, 0x2e, 0x14, 0xe5, 0xc6, 0xc9, 0x73,
- 0x03, 0x78, 0xeb, 0xed, 0xe0, 0x3e, 0xc5, 0xf4,
- 0xf1, 0x50, 0xb2, 0x01, 0x91, 0x96, 0xf5, 0xbb,
- 0xe1, 0x32, 0xcd, 0xa8, 0x66, 0xbf, 0x73, 0x85,
- 0x94, 0xd6, 0x7e, 0x68, 0xc5, 0xe4, 0xed, 0xd5,
- 0xe3, 0x67, 0x4c, 0xa5, 0xb3, 0x1f, 0xdf, 0xf8,
- 0xb3, 0x73, 0x5a, 0xac, 0xeb, 0x46, 0x16, 0x24,
- 0xab, 0xca, 0xa4, 0xdd, 0x87, 0x0e, 0x24, 0x83,
- 0x32, 0x04, 0x4c, 0xd8, 0xda, 0x7d, 0xdc, 0xe3,
- 0x01, 0x93, 0xf3, 0xc1, 0x5b, 0xbd, 0xc3, 0x1d,
- 0x40, 0x62, 0xde, 0x94, 0x03, 0x85, 0x91, 0x2a,
- 0xa0, 0x25, 0x10, 0xd3, 0x32, 0x9f, 0x93, 0x00,
- 0xa7, 0x8a, 0xfa, 0x77, 0x7c, 0xaf, 0x4d, 0xc8,
- 0x7a, 0xf3, 0x16, 0x2b, 0xba, 0xeb, 0x74, 0x51,
- 0xb8, 0xdd, 0x32, 0xad, 0x68, 0x7d, 0xdd, 0xca,
- 0x60, 0x98, 0xc9, 0x9b, 0xb6, 0x5d, 0x4d, 0x3a,
- 0x66, 0x8a, 0xbe, 0x05, 0xf9, 0x0c, 0xc5, 0xba,
- 0x52, 0x82, 0x09, 0x1f, 0x5a, 0x66, 0x89, 0x69,
- 0xa3, 0x5d, 0x93, 0x50, 0x7d, 0x44, 0xc3, 0x2a,
- 0xb8, 0xab, 0xec, 0xa6, 0x5a, 0xae, 0x4a, 0x6a,
- 0xcd, 0xfd, 0xb6, 0xff, 0x3d, 0x98, 0x05, 0xd9,
- 0x5b, 0x29, 0xc4, 0x6f, 0xe0, 0x76, 0xe2, 0x3f,
- 0xec, 0xd7, 0xa4, 0x91, 0x63, 0xf5, 0x4e, 0x4b,
- 0xab, 0x20, 0x8c, 0x3a, 0x41, 0xed, 0x8b, 0x4b,
- 0xb9, 0x01, 0x21, 0xc0, 0x6d, 0xfd, 0x70, 0x5b,
- 0x20, 0x92, 0x41, 0x89, 0x74, 0xb7, 0xe9, 0x8b,
- 0xfc, 0x6d, 0x17, 0x3f, 0x7f, 0x89, 0x3d, 0x6b,
- 0x8f, 0xbc, 0xd2, 0x57, 0xe9, 0xc9, 0x6e, 0xa7,
- 0x19, 0x26, 0x18, 0xad, 0xef, 0xb5, 0x87, 0xbf,
- 0xb8, 0xa8, 0xd6, 0x7d, 0xdd, 0x5f, 0x94, 0x54,
- 0x09, 0x92, 0x2b, 0xf5, 0x04, 0xf7, 0x36, 0x69,
- 0x8e, 0xf4, 0xdc, 0x1d, 0x6e, 0x55, 0xbb, 0xe9,
- 0x13, 0x05, 0x83, 0x35, 0x9c, 0xed, 0xcf, 0x8c,
- 0x26, 0x8c, 0x7b, 0xc7, 0x0b, 0xba, 0xfd, 0xe2,
- 0x84, 0x5c, 0x2a, 0x79, 0x43, 0x99, 0xb2, 0xc3,
- 0x82, 0x87, 0xc8, 0xcd, 0x37, 0x6d, 0xa1, 0x2b,
- 0x39, 0xb2, 0x38, 0x99, 0xd9, 0xfc, 0x02, 0x15,
- 0x55, 0x21, 0x62, 0x59, 0xeb, 0x00, 0x86, 0x08,
- 0x20, 0xbe, 0x1a, 0x62, 0x4d, 0x7e, 0xdf, 0x68,
- 0x73, 0x5b, 0x5f, 0xaf, 0x84, 0x96, 0x2e, 0x1f,
- 0x6b, 0x03, 0xc9, 0xa6, 0x75, 0x18, 0xe9, 0xd4,
- 0xbd, 0xc8, 0xec, 0x9a, 0x5a, 0xb3, 0x99, 0xab,
- 0x5f, 0x7c, 0x08, 0x7f, 0x69, 0x4d, 0x52, 0xa2,
- 0x30, 0x17, 0x3b, 0x16, 0x15, 0x1b, 0x11, 0x62,
- 0x3e, 0x80, 0x4b, 0x85, 0x7c, 0x9c, 0xd1, 0x3a,
- 0x13, 0x01, 0x5e, 0x45, 0xf1, 0xc8, 0x5f, 0xcd,
- 0x0e, 0x21, 0xf5, 0x82, 0xd4, 0x7b, 0x5c, 0x45,
- 0x27, 0x6b, 0xef, 0xfe, 0xb8, 0xc0, 0x6f, 0xdc,
- 0x60, 0x7b, 0xe4, 0xd5, 0x75, 0x71, 0xe6, 0xe8,
- 0x7d, 0x6b, 0x6d, 0x80, 0xaf, 0x76, 0x41, 0x58,
- 0xb7, 0xac, 0xb7, 0x13, 0x2f, 0x81, 0xcc, 0xf9,
- 0x19, 0x97, 0xe8, 0xee, 0x40, 0x91, 0xfc, 0x89,
- 0x13, 0x1e, 0x67, 0x9a, 0xdb, 0x8f, 0x8f, 0xc7,
- 0x4a, 0xc9, 0xaf, 0x2f, 0x67, 0x01, 0x3c, 0xb8,
- 0xa8, 0x3e, 0x78, 0x93, 0x1b, 0xdf, 0xbb, 0x34,
- 0x0b, 0x1a, 0xfa, 0xc2, 0x2d, 0xc5, 0x1c, 0xec,
- 0x97, 0x4f, 0x48, 0x41, 0x15, 0x0e, 0x75, 0xed,
- 0x66, 0x8c, 0x17, 0x7f, 0xb1, 0x48, 0x13, 0xc1,
- 0xfb, 0x60, 0x06, 0xf9, 0x72, 0x41, 0x3e, 0xcf,
- 0x6e, 0xb6, 0xc8, 0xeb, 0x4b, 0x5a, 0xd2, 0x0c,
- 0x28, 0xda, 0x02, 0x7a, 0x46, 0x21, 0x42, 0xb5,
- 0x34, 0xda, 0xcb, 0x5e, 0xbd, 0x66, 0x5c, 0xca,
- 0xff, 0x52, 0x43, 0x89, 0xf9, 0x10, 0x9a, 0x9e,
- 0x9b, 0xe3, 0xb0, 0x51, 0xe9, 0xf3, 0x0a, 0x35,
- 0x77, 0x54, 0xcc, 0xac, 0xa6, 0xf1, 0x2e, 0x36,
- 0x89, 0xac, 0xc5, 0xc6, 0x62, 0x5a, 0xc0, 0x6d,
- 0xc4, 0xe1, 0xf7, 0x64, 0x30, 0xff, 0x11, 0x40,
- 0x13, 0x89, 0xd8, 0xd7, 0x73, 0x3f, 0x93, 0x08,
- 0x68, 0xab, 0x66, 0x09, 0x1a, 0xea, 0x78, 0xc9,
- 0x52, 0xf2, 0xfd, 0x93, 0x1b, 0x94, 0xbe, 0x5c,
- 0xe5, 0x00, 0x6e, 0x00, 0xb9, 0xea, 0x27, 0xaa,
- 0xb3, 0xee, 0xe3, 0xc8, 0x6a, 0xb0, 0xc1, 0x8e,
- 0x9b, 0x54, 0x40, 0x10, 0x96, 0x06, 0xe8, 0xb3,
- 0xf5, 0x55, 0x77, 0xd7, 0x5c, 0x94, 0xc1, 0x74,
- 0xf3, 0x07, 0x64, 0xac, 0x1c, 0xde, 0xc7, 0x22,
- 0xb0, 0xbf, 0x2a, 0x5a, 0xc0, 0x8f, 0x8a, 0x83,
- 0x50, 0xc2, 0x5e, 0x97, 0xa0, 0xbe, 0x49, 0x7e,
- 0x47, 0xaf, 0xa7, 0x20, 0x02, 0x35, 0xa4, 0x57,
- 0xd9, 0x26, 0x63, 0xdb, 0xf1, 0x34, 0x42, 0x89,
- 0x36, 0xd1, 0x77, 0x6f, 0xb1, 0xea, 0x79, 0x7e,
- 0x95, 0x10, 0x5a, 0xee, 0xa3, 0xae, 0x6f, 0xba,
- 0xa9, 0xef, 0x5a, 0x7e, 0x34, 0x03, 0x04, 0x07,
- 0x92, 0xd6, 0x07, 0x79, 0xaa, 0x14, 0x90, 0x97,
- 0x05, 0x4d, 0xa6, 0x27, 0x10, 0x5c, 0x25, 0x24,
- 0xcb, 0xcc, 0xf6, 0x77, 0x9e, 0x43, 0x23, 0xd4,
- 0x98, 0xef, 0x22, 0xa8, 0xad, 0xf2, 0x26, 0x08,
- 0x59, 0x69, 0xa4, 0xc3, 0x97, 0xe0, 0x5c, 0x6f,
- 0xeb, 0x3d, 0xd4, 0x62, 0x6e, 0x80, 0x61, 0x02,
- 0xf4, 0xfc, 0x94, 0x79, 0xbb, 0x4e, 0x6d, 0xd7,
- 0x30, 0x5b, 0x10, 0x11, 0x5a, 0x3d, 0xa7, 0x50,
- 0x1d, 0x9a, 0x13, 0x5f, 0x4f, 0xa8, 0xa7, 0xb6,
- 0x39, 0xc7, 0xea, 0xe6, 0x19, 0x61, 0x69, 0xc7,
- 0x9a, 0x3a, 0xeb, 0x9d, 0xdc, 0xf7, 0x06, 0x37,
- 0xbd, 0xac, 0xe3, 0x18, 0xff, 0xfe, 0x11, 0xdb,
- 0x67, 0x42, 0xb4, 0xea, 0xa8, 0xbd, 0xb0, 0x76,
- 0xd2, 0x74, 0x32, 0xc2, 0xa4, 0x9c, 0xe7, 0x60,
- 0xc5, 0x30, 0x9a, 0x57, 0x66, 0xcd, 0x0f, 0x02,
- 0x4c, 0xea, 0xe9, 0xd3, 0x2a, 0x5c, 0x09, 0xc2,
- 0xff, 0x6a, 0xde, 0x5d, 0xb7, 0xe9, 0x75, 0x6b,
- 0x29, 0x94, 0xd6, 0xf7, 0xc3, 0xdf, 0xfb, 0x70,
- 0xec, 0xb5, 0x8c, 0xb0, 0x78, 0x7a, 0xee, 0x52,
- 0x5f, 0x8c, 0xae, 0x85, 0xe5, 0x98, 0xa2, 0xb7,
- 0x7c, 0x02, 0x2a, 0xcc, 0x9e, 0xde, 0x99, 0x5f,
- 0x84, 0x20, 0xbb, 0xdc, 0xf2, 0xd2, 0x13, 0x46,
- 0x3c, 0xd6, 0x4d, 0xe7, 0x50, 0xef, 0x55, 0xc3,
- 0x96, 0x9f, 0xec, 0x6c, 0xd8, 0xe2, 0xea, 0xed,
- 0xc7, 0x33, 0xc9, 0xb3, 0x1c, 0x4f, 0x1d, 0x83,
- 0x1d, 0xe4, 0xdd, 0xb2, 0x24, 0x8f, 0xf9, 0xf5
-};
-
-
-static const uint8_t HMAC_SHA256_ciphertext_64B_digest[] = {
- 0xc5, 0x6d, 0x4f, 0x29, 0xf4, 0xd2, 0xcc, 0x87,
- 0x3c, 0x81, 0x02, 0x6d, 0x38, 0x7a, 0x67, 0x3e,
- 0x95, 0x9c, 0x5c, 0x8f, 0xda, 0x5c, 0x06, 0xe0,
- 0x65, 0xf1, 0x6c, 0x51, 0x52, 0x49, 0x3e, 0x5f
-};
-
-static const uint8_t HMAC_SHA256_ciphertext_128B_digest[] = {
- 0x76, 0x64, 0x2d, 0x69, 0x71, 0x5d, 0x6a, 0xd8,
- 0x9f, 0x74, 0x11, 0x2f, 0x58, 0xe0, 0x4a, 0x2f,
- 0x6c, 0x88, 0x5e, 0x4d, 0x9c, 0x79, 0x83, 0x1c,
- 0x8a, 0x14, 0xd0, 0x07, 0xfb, 0xbf, 0x6c, 0x8f
-};
-
-static const uint8_t HMAC_SHA256_ciphertext_256B_digest[] = {
- 0x05, 0xa7, 0x44, 0xcd, 0x91, 0x8c, 0x95, 0xcf,
- 0x7b, 0x8f, 0xd3, 0x90, 0x86, 0x7e, 0x7b, 0xb9,
- 0x05, 0xd6, 0x6e, 0x7a, 0xc1, 0x7b, 0x26, 0xff,
- 0xd3, 0x4b, 0xe0, 0x22, 0x8b, 0xa8, 0x47, 0x52
-};
-
-static const uint8_t HMAC_SHA256_ciphertext_512B_digest[] = {
- 0x08, 0xb7, 0x29, 0x54, 0x18, 0x7e, 0x97, 0x49,
- 0xc6, 0x7c, 0x9f, 0x94, 0xa5, 0x4f, 0xa2, 0x25,
- 0xd0, 0xe2, 0x30, 0x7b, 0xad, 0x93, 0xc9, 0x12,
- 0x0f, 0xf0, 0xf0, 0x71, 0xc2, 0xf6, 0x53, 0x8f
-};
-
-static const uint8_t HMAC_SHA256_ciphertext_768B_digest[] = {
- 0xe4, 0x3e, 0x73, 0x93, 0x03, 0xaf, 0x6f, 0x9c,
- 0xca, 0x57, 0x3b, 0x4a, 0x6e, 0x83, 0x58, 0xf5,
- 0x66, 0xc2, 0xb4, 0xa7, 0xe0, 0xee, 0x63, 0x6b,
- 0x48, 0xb7, 0x50, 0x45, 0x69, 0xdf, 0x5c, 0x5b
-};
-
-static const uint8_t HMAC_SHA256_ciphertext_1024B_digest[] = {
- 0x03, 0xb9, 0x96, 0x26, 0xdc, 0x1c, 0xab, 0xe2,
- 0xf5, 0x70, 0x55, 0x15, 0x67, 0x6e, 0x48, 0x11,
- 0xe7, 0x67, 0xea, 0xfa, 0x5c, 0x6b, 0x28, 0x22,
- 0xc9, 0x0e, 0x67, 0x04, 0xb3, 0x71, 0x7f, 0x88
-};
-
-static const uint8_t HMAC_SHA256_ciphertext_1280B_digest[] = {
- 0x01, 0x91, 0xb8, 0x78, 0xd3, 0x21, 0x74, 0xa5,
- 0x1c, 0x8b, 0xd4, 0xd2, 0xc0, 0x49, 0xd7, 0xd2,
- 0x16, 0x46, 0x66, 0x85, 0x50, 0x6d, 0x08, 0xcc,
- 0xc7, 0x0a, 0xa3, 0x71, 0xcc, 0xde, 0xee, 0xdc
-};
-
-static const uint8_t HMAC_SHA256_ciphertext_1536B_digest[] = {
- 0xf2, 0xe5, 0xe9, 0x57, 0x53, 0xd7, 0x69, 0x28,
- 0x7b, 0x69, 0xb5, 0x49, 0xa3, 0x31, 0x56, 0x5f,
- 0xa4, 0xe9, 0x87, 0x26, 0x2f, 0xe0, 0x2d, 0xd6,
- 0x08, 0x44, 0x01, 0x71, 0x0c, 0x93, 0x85, 0x84
-};
-
-static const uint8_t HMAC_SHA256_ciphertext_1792B_digest[] = {
- 0xf6, 0x57, 0x62, 0x01, 0xbf, 0x2d, 0xea, 0x4a,
- 0xef, 0x43, 0x85, 0x60, 0x18, 0xdf, 0x8b, 0xb4,
- 0x60, 0xc0, 0xfd, 0x2f, 0x90, 0x15, 0xe6, 0x91,
- 0x56, 0x61, 0x68, 0x7f, 0x5e, 0x92, 0xa8, 0xdd
-};
-
-static const uint8_t HMAC_SHA256_ciphertext_2048B_digest[] = {
- 0x81, 0x1a, 0x29, 0xbc, 0x6b, 0x9f, 0xbb, 0xb8,
- 0xef, 0x71, 0x7b, 0x1f, 0x6f, 0xd4, 0x7e, 0x68,
- 0x3a, 0x9c, 0xb9, 0x98, 0x22, 0x81, 0xfa, 0x95,
- 0xee, 0xbc, 0x7f, 0x23, 0x29, 0x88, 0x76, 0xb8
-};
-
-struct crypto_data_params {
- const char *name;
- uint16_t length;
- const char *plaintext;
- struct crypto_expected_output {
- const uint8_t *ciphertext;
- const uint8_t *digest;
- } expected;
-};
-
-#define MAX_PACKET_SIZE_INDEX 10
-
-struct crypto_data_params aes_cbc_hmac_sha256_output[MAX_PACKET_SIZE_INDEX] = {
- { "64B", 64, &plaintext_quote[sizeof(plaintext_quote) - 1 - 64],
- { AES_CBC_ciphertext_64B, HMAC_SHA256_ciphertext_64B_digest } },
- { "128B", 128, &plaintext_quote[sizeof(plaintext_quote) - 1 - 128],
- { AES_CBC_ciphertext_128B, HMAC_SHA256_ciphertext_128B_digest } },
- { "256B", 256, &plaintext_quote[sizeof(plaintext_quote) - 1 - 256],
- { AES_CBC_ciphertext_256B, HMAC_SHA256_ciphertext_256B_digest } },
- { "512B", 512, &plaintext_quote[sizeof(plaintext_quote) - 1 - 512],
- { AES_CBC_ciphertext_512B, HMAC_SHA256_ciphertext_512B_digest } },
- { "768B", 768, &plaintext_quote[sizeof(plaintext_quote) - 1 - 768],
- { AES_CBC_ciphertext_768B, HMAC_SHA256_ciphertext_768B_digest } },
- { "1024B", 1024, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1024],
- { AES_CBC_ciphertext_1024B, HMAC_SHA256_ciphertext_1024B_digest } },
- { "1280B", 1280, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1280],
- { AES_CBC_ciphertext_1280B, HMAC_SHA256_ciphertext_1280B_digest } },
- { "1536B", 1536, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1536],
- { AES_CBC_ciphertext_1536B, HMAC_SHA256_ciphertext_1536B_digest } },
- { "1792B", 1792, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1792],
- { AES_CBC_ciphertext_1792B, HMAC_SHA256_ciphertext_1792B_digest } },
- { "2048B", 2048, &plaintext_quote[sizeof(plaintext_quote) - 1 - 2048],
- { AES_CBC_ciphertext_2048B, HMAC_SHA256_ciphertext_2048B_digest } }
-};
-
-static int
-test_perf_crypto_qp_vary_burst_size(uint16_t dev_num)
-{
- uint32_t num_to_submit = 4096;
- struct rte_crypto_op *c_ops[num_to_submit];
- struct rte_crypto_op *proc_ops[num_to_submit];
- uint64_t failed_polls, retries, start_cycles, end_cycles, total_cycles = 0;
- uint32_t burst_sent, burst_received;
- uint32_t i, burst_size, num_sent, num_received;
- struct crypto_testsuite_params *ts_params = &testsuite_params;
- struct crypto_unittest_params *ut_params = &unittest_params;
- struct crypto_data_params *data_params = aes_cbc_hmac_sha256_output;
-
- if (rte_cryptodev_count() == 0) {
- printf("\nNo crypto devices available. Is kernel driver loaded?\n");
- return TEST_FAILED;
- }
-
- /* Setup Cipher Parameters */
- ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
- ut_params->cipher_xform.next = &ut_params->auth_xform;
-
- ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
- ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
- ut_params->cipher_xform.cipher.key.data = aes_cbc_128_key;
- ut_params->cipher_xform.cipher.key.length = CIPHER_IV_LENGTH_AES_CBC;
- ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
- ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
-
- /* Setup HMAC Parameters */
- ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- ut_params->auth_xform.next = NULL;
-
- ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
- ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA256_HMAC;
- ut_params->auth_xform.auth.key.data = hmac_sha256_key;
- ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA256;
- ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA256;
-
- /* Create Crypto session*/
-
- test_crypto_session = rte_cryptodev_sym_session_create(ts_params->sess_mp);
-
- rte_cryptodev_sym_session_init(ts_params->dev_id, test_crypto_session,
- &ut_params->cipher_xform, ts_params->sess_mp);
-
- TEST_ASSERT_NOT_NULL(test_crypto_session, "Session creation failed");
-
- /* Generate Crypto op data structure(s) */
- for (i = 0; i < num_to_submit ; i++) {
- struct rte_mbuf *m = setup_test_string(ts_params->mbuf_mp,
- data_params[0].expected.ciphertext,
- data_params[0].length, 0);
- TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
-
- ut_params->digest = (uint8_t *)rte_pktmbuf_append(m,
- DIGEST_BYTE_LENGTH_SHA256);
- TEST_ASSERT_NOT_NULL(ut_params->digest,
- "no room to append digest");
-
- rte_memcpy(ut_params->digest, data_params[0].expected.digest,
- DIGEST_BYTE_LENGTH_SHA256);
-
-
- struct rte_crypto_op *op =
- rte_crypto_op_alloc(ts_params->op_mpool,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC);
-
- rte_crypto_op_attach_sym_session(op, test_crypto_session);
-
- op->sym->auth.digest.data = ut_params->digest;
- op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m,
- data_params[0].length);
-
- op->sym->auth.data.offset = 0;
- op->sym->auth.data.length = data_params[0].length;
-
- rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
- aes_cbc_128_iv, CIPHER_IV_LENGTH_AES_CBC);
-
- op->sym->cipher.data.offset = 0;
- op->sym->cipher.data.length = data_params[0].length;
-
- op->sym->m_src = m;
-
- c_ops[i] = op;
- }
-
- printf("\nTest to measure the IA cycle cost using AES128_CBC_SHA256_HMAC "
- "algorithm with a constant request size of %u.",
- data_params[0].length);
- printf("\nThis test will keep retries at 0 and only measure IA cycle "
- "cost for each request.");
- printf("\nDev No\tQP No\tNum Sent\tNum Received\tTx/Rx burst");
- printf("\tRetries (Device Busy)\tAverage IA cycle cost "
- "(assuming 0 retries)");
- for (i = 2; i <= 128 ; i *= 2) {
- num_sent = 0;
- num_received = 0;
- retries = 0;
- failed_polls = 0;
- burst_size = i;
- total_cycles = 0;
- while (num_sent < num_to_submit) {
- start_cycles = rte_rdtsc_precise();
- burst_sent = rte_cryptodev_enqueue_burst(dev_num,
- 0, &c_ops[num_sent],
- ((num_to_submit-num_sent) < burst_size) ?
- num_to_submit-num_sent : burst_size);
- if (burst_sent == 0)
- retries++;
- else
- num_sent += burst_sent;
- end_cycles = rte_rdtsc_precise();
- total_cycles += (end_cycles - start_cycles);
- /*
- * Wait until requests have been sent.
- */
- rte_delay_ms(1);
-
- start_cycles = rte_rdtsc_precise();
- burst_received = rte_cryptodev_dequeue_burst(
- dev_num, 0, proc_ops, burst_size);
- if (burst_received == 0)
- failed_polls++;
- else
- num_received += burst_received;
- end_cycles = rte_rdtsc_precise();
- total_cycles += end_cycles - start_cycles;
- }
-
- while (num_received != num_to_submit) {
- if (gbl_driver_id ==
- rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
- rte_cryptodev_enqueue_burst(dev_num, 0,
- NULL, 0);
-
- burst_received = rte_cryptodev_dequeue_burst(
- dev_num, 0, proc_ops, burst_size);
- if (burst_received == 0)
- failed_polls++;
- else
- num_received += burst_received;
- }
-
- printf("\n%u\t%u\t%u\t\t%u\t\t%u", dev_num, 0,
- num_sent, num_received, burst_size);
- printf("\t\t%"PRIu64, retries);
- printf("\t\t\t%"PRIu64, total_cycles/num_received);
- }
- printf("\n");
-
- for (i = 0; i < num_to_submit ; i++) {
- rte_pktmbuf_free(c_ops[i]->sym->m_src);
- rte_crypto_op_free(c_ops[i]);
- }
- return TEST_SUCCESS;
-}
-
-static int
-test_perf_snow3G_optimise_cyclecount(struct perf_test_params *pparams)
-{
- uint32_t num_to_submit = pparams->total_operations;
- struct rte_crypto_op *c_ops[num_to_submit];
- struct rte_crypto_op *proc_ops[num_to_submit];
- uint64_t failed_polls, retries, start_cycles, end_cycles, total_cycles = 0;
- uint32_t burst_sent = 0, burst_received = 0;
- uint32_t i, burst_size, num_sent, num_ops_received;
- struct crypto_testsuite_params *ts_params = &testsuite_params;
- static struct rte_cryptodev_sym_session *sess;
-
- if (rte_cryptodev_count() == 0) {
- printf("\nNo crypto devices found. Is PMD build configured?\n");
- printf("\nAnd is kernel driver loaded for HW PMDs?\n");
- return TEST_FAILED;
- }
-
- /* Create Crypto session*/
- if (test_perf_create_snow3g_session(ts_params->dev_id,
- pparams->chain, pparams->cipher_algo,
- pparams->key_length, pparams->auth_algo) == 0)
- sess = test_crypto_session;
- else
- sess = NULL;
- TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
-
- /* Generate Crypto op data structure(s)*/
- for (i = 0; i < num_to_submit ; i++) {
- struct rte_mbuf *m = test_perf_create_pktmbuf(
- ts_params->mbuf_mp,
- pparams->buf_size);
- TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
-
- struct rte_crypto_op *op =
- rte_crypto_op_alloc(ts_params->op_mpool,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC);
- TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
-
- op = test_perf_set_crypto_op_snow3g(op, m, sess, pparams->buf_size);
- TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
-
- c_ops[i] = op;
- }
-
- if (pparams->chain == AEAD)
- printf("\nOn %s dev%u qp%u, %s, aead algo:%s, "
- "Packet Size %u bytes",
- pmd_name(gbl_driver_id),
- ts_params->dev_id, 0,
- chain_mode_name(pparams->chain),
- rte_crypto_aead_algorithm_strings[pparams->aead_algo],
- pparams->buf_size);
- else
- printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, auth_algo:%s, "
- "Packet Size %u bytes",
- pmd_name(gbl_driver_id),
- ts_params->dev_id, 0,
- chain_mode_name(pparams->chain),
- rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
- rte_crypto_auth_algorithm_strings[pparams->auth_algo],
- pparams->buf_size);
- printf("\nOps Tx\tOps Rx\tOps/burst ");
- printf("Retries EmptyPolls\tIACycles/CyOp\tIACycles/Burst\tIACycles/Byte");
-
- for (i = 2; i <= 128 ; i *= 2) {
- num_sent = 0;
- num_ops_received = 0;
- retries = 0;
- failed_polls = 0;
- burst_size = i;
- total_cycles = 0;
- while (num_sent < num_to_submit) {
- start_cycles = rte_rdtsc_precise();
- burst_sent = rte_cryptodev_enqueue_burst(ts_params->dev_id,
- 0, &c_ops[num_sent],
- ((num_to_submit-num_sent) < burst_size) ?
- num_to_submit-num_sent : burst_size);
- end_cycles = rte_rdtsc_precise();
- if (burst_sent == 0)
- retries++;
- num_sent += burst_sent;
- total_cycles += (end_cycles - start_cycles);
-
- /* Wait until requests have been sent. */
-
- rte_delay_ms(1);
-
- start_cycles = rte_rdtsc_precise();
- burst_received = rte_cryptodev_dequeue_burst(
- ts_params->dev_id, 0, proc_ops, burst_size);
- end_cycles = rte_rdtsc_precise();
- if (burst_received < burst_sent)
- failed_polls++;
- num_ops_received += burst_received;
-
- total_cycles += end_cycles - start_cycles;
- }
-
- while (num_ops_received != num_to_submit) {
- if (gbl_driver_id ==
- rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
- rte_cryptodev_enqueue_burst(ts_params->dev_id, 0,
- NULL, 0);
- start_cycles = rte_rdtsc_precise();
- burst_received = rte_cryptodev_dequeue_burst(
- ts_params->dev_id, 0, proc_ops, burst_size);
- end_cycles = rte_rdtsc_precise();
- total_cycles += end_cycles - start_cycles;
- if (burst_received == 0)
- failed_polls++;
- num_ops_received += burst_received;
- }
-
- printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
- printf("\t\t%"PRIu64, retries);
- printf("\t%"PRIu64, failed_polls);
- printf("\t\t%"PRIu64, total_cycles/num_ops_received);
- printf("\t\t%"PRIu64, (total_cycles/num_ops_received)*burst_size);
- printf("\t\t%"PRIu64, total_cycles/(num_ops_received*pparams->buf_size));
- }
- printf("\n");
-
- for (i = 0; i < num_to_submit ; i++) {
- rte_pktmbuf_free(c_ops[i]->sym->m_src);
- rte_crypto_op_free(c_ops[i]);
- }
-
- rte_cryptodev_sym_session_clear(ts_params->dev_id,
- sess);
- rte_cryptodev_sym_session_free(sess);
-
- return TEST_SUCCESS;
-}
-
-static int
-test_perf_snow3G_vary_burst_size(void)
-{
- unsigned total_operations = 4096;
- /*no need to vary pkt size for QAT, should have no effect on IA cycles */
- uint16_t buf_lengths[] = {40};
- uint8_t i, j;
-
- struct perf_test_params params_set[] = {
- {
- .chain = CIPHER_ONLY,
- .cipher_algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_NULL,
- },
- {
- .chain = HASH_ONLY,
- .cipher_algo = RTE_CRYPTO_CIPHER_NULL,
- .auth_algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
- .key_length = 16
- },
- };
-
- printf("\n\nStart %s.", __func__);
- printf("\nThis Test measures the average IA cycle cost using a "
- "constant request(packet) size. ");
- printf("Cycle cost is only valid when indicators show device is not busy,"
- " i.e. Retries and EmptyPolls = 0");
-
- for (i = 0; i < RTE_DIM(params_set); i++) {
- printf("\n");
- params_set[i].total_operations = total_operations;
-
- for (j = 0;
- j < RTE_DIM(buf_lengths);
- j++) {
-
- params_set[i].buf_size = buf_lengths[j];
-
- test_perf_snow3G_optimise_cyclecount(¶ms_set[i]);
- }
-
- }
-
- return 0;
-}
-
-static int
-test_perf_openssl_optimise_cyclecount(struct perf_test_params *pparams)
-{
- uint32_t num_to_submit = pparams->total_operations;
- struct rte_crypto_op *c_ops[num_to_submit];
- struct rte_crypto_op *proc_ops[num_to_submit];
- uint64_t failed_polls, retries, start_cycles,
- end_cycles, total_cycles = 0;
- uint32_t burst_sent = 0, burst_received = 0;
- uint32_t i, burst_size, num_sent, num_ops_received;
-
- struct crypto_testsuite_params *ts_params = &testsuite_params;
-
- static struct rte_cryptodev_sym_session *sess;
-
- static struct rte_crypto_op *(*test_perf_set_crypto_op)
- (struct rte_crypto_op *, struct rte_mbuf *,
- struct rte_cryptodev_sym_session *,
- unsigned int,
- enum chain_mode);
-
- if (rte_cryptodev_count() == 0) {
- printf("\nNo crypto devices found. Is PMD build configured?\n");
- return TEST_FAILED;
- }
-
- /* Create Crypto session*/
- if (test_perf_create_openssl_session(ts_params->dev_id,
- pparams->chain, pparams->cipher_algo,
- pparams->key_length, pparams->auth_algo,
- pparams->aead_algo) == 0)
- sess = test_crypto_session;
- else
- sess = NULL;
- TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
-
- /* Generate Crypto op data structure(s)*/
- for (i = 0; i < num_to_submit ; i++) {
- struct rte_mbuf *m = test_perf_create_pktmbuf(
- ts_params->mbuf_mp,
- pparams->buf_size);
- TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
-
- struct rte_crypto_op *op =
- rte_crypto_op_alloc(ts_params->op_mpool,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC);
- TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
-
- if (pparams->chain == AEAD)
- test_perf_set_crypto_op =
- test_perf_set_crypto_op_aes_gcm;
- else {
- switch (pparams->cipher_algo) {
- case RTE_CRYPTO_CIPHER_3DES_CBC:
- case RTE_CRYPTO_CIPHER_3DES_CTR:
- test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
- break;
- case RTE_CRYPTO_CIPHER_AES_CBC:
- case RTE_CRYPTO_CIPHER_AES_CTR:
- test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
- break;
- default:
- return TEST_FAILED;
- }
- }
-
- op = test_perf_set_crypto_op(op, m, sess, pparams->buf_size,
- pparams->chain);
- TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
-
- c_ops[i] = op;
- }
-
- if (pparams->chain == AEAD)
- printf("\nOn %s dev%u qp%u, %s, aead_algo:%s, "
- "key length:%u, Packet Size %u bytes",
- pmd_name(gbl_driver_id),
- ts_params->dev_id, 0,
- chain_mode_name(pparams->chain),
- rte_crypto_aead_algorithm_strings[pparams->aead_algo],
- pparams->key_length,
- pparams->buf_size);
- else
- printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, auth_algo:%s, "
- "key length:%u, Packet Size %u bytes",
- pmd_name(gbl_driver_id),
- ts_params->dev_id, 0,
- chain_mode_name(pparams->chain),
- rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
- rte_crypto_auth_algorithm_strings[pparams->auth_algo],
- pparams->key_length,
- pparams->buf_size);
- printf("\nOps Tx\tOps Rx\tOps/burst ");
- printf("Retries EmptyPolls\tIACycles/CyOp\tIACycles/Burst\t"
- "IACycles/Byte");
-
- for (i = 2; i <= 128 ; i *= 2) {
- num_sent = 0;
- num_ops_received = 0;
- retries = 0;
- failed_polls = 0;
- burst_size = i;
- total_cycles = 0;
- while (num_sent < num_to_submit) {
- start_cycles = rte_rdtsc_precise();
- burst_sent = rte_cryptodev_enqueue_burst(
- ts_params->dev_id,
- 0, &c_ops[num_sent],
- ((num_to_submit - num_sent) <
- burst_size) ?
- num_to_submit - num_sent : burst_size);
- end_cycles = rte_rdtsc_precise();
- if (burst_sent == 0)
- retries++;
- num_sent += burst_sent;
- total_cycles += (end_cycles - start_cycles);
-
- /* Wait until requests have been sent. */
- rte_delay_ms(1);
-
- start_cycles = rte_rdtsc_precise();
- burst_received = rte_cryptodev_dequeue_burst(
- ts_params->dev_id, 0, proc_ops,
- burst_size);
- end_cycles = rte_rdtsc_precise();
- if (burst_received < burst_sent)
- failed_polls++;
- num_ops_received += burst_received;
-
- total_cycles += end_cycles - start_cycles;
- }
-
- while (num_ops_received != num_to_submit) {
- /* Sending 0 length burst to flush sw crypto device */
- rte_cryptodev_enqueue_burst(ts_params->dev_id, 0,
- NULL, 0);
-
- start_cycles = rte_rdtsc_precise();
- burst_received = rte_cryptodev_dequeue_burst(
- ts_params->dev_id, 0, proc_ops,
- burst_size);
- end_cycles = rte_rdtsc_precise();
-
- total_cycles += end_cycles - start_cycles;
- if (burst_received == 0)
- failed_polls++;
- num_ops_received += burst_received;
- }
-
- printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
- printf("\t\t%"PRIu64, retries);
- printf("\t%"PRIu64, failed_polls);
- printf("\t\t%"PRIu64, total_cycles/num_ops_received);
- printf("\t\t%"PRIu64, (total_cycles/num_ops_received) *
- burst_size);
- printf("\t\t%"PRIu64,
- total_cycles /
- (num_ops_received * pparams->buf_size));
- }
- printf("\n");
-
- for (i = 0; i < num_to_submit ; i++) {
- rte_pktmbuf_free(c_ops[i]->sym->m_src);
- rte_crypto_op_free(c_ops[i]);
- }
-
- rte_cryptodev_sym_session_clear(ts_params->dev_id, sess);
- rte_cryptodev_sym_session_free(sess);
-
- return TEST_SUCCESS;
-}
-
-static int
-test_perf_armv8_optimise_cyclecount(struct perf_test_params *pparams)
-{
- uint32_t num_to_submit = pparams->total_operations;
- struct rte_crypto_op *c_ops[num_to_submit];
- struct rte_crypto_op *proc_ops[num_to_submit];
- uint64_t failed_polls, retries, start_cycles, end_cycles,
- total_cycles = 0;
- uint32_t burst_sent = 0, burst_received = 0;
- uint32_t i, burst_size, num_sent, num_ops_received;
- uint32_t nb_ops;
-
- struct crypto_testsuite_params *ts_params = &testsuite_params;
-
- static struct rte_cryptodev_sym_session *sess;
-
- if (rte_cryptodev_count() == 0) {
- printf("\nNo crypto devices found. Is PMD build configured?\n");
- return TEST_FAILED;
- }
-
- /* Create Crypto session*/
- if (test_perf_create_armv8_session(ts_params->dev_id,
- pparams->chain, pparams->cipher_algo,
- pparams->key_length, pparams->auth_algo) == 0)
- sess = test_crypto_session;
- else
- sess = NULL;
-
- /* Generate Crypto op data structure(s)*/
- for (i = 0; i < num_to_submit ; i++) {
- struct rte_mbuf *m = test_perf_create_pktmbuf(
- ts_params->mbuf_mp,
- pparams->buf_size);
- TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
-
- struct rte_crypto_op *op =
- rte_crypto_op_alloc(ts_params->op_mpool,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC);
- TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
-
- op = test_perf_set_crypto_op_aes(op, m, sess, pparams->buf_size,
- pparams->chain);
- TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
-
- c_ops[i] = op;
- }
-
- printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, cipher key length:%u, "
- "auth_algo:%s, Packet Size %u bytes",
- pmd_name(gbl_driver_id),
- ts_params->dev_id, 0,
- chain_mode_name(pparams->chain),
- rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
- pparams->key_length,
- rte_crypto_auth_algorithm_strings[pparams->auth_algo],
- pparams->buf_size);
- printf("\nOps Tx\tOps Rx\tOps/burst ");
- printf("Retries "
- "EmptyPolls\tIACycles/CyOp\tIACycles/Burst\tIACycles/Byte");
-
- for (i = 2; i <= 128 ; i *= 2) {
- num_sent = 0;
- num_ops_received = 0;
- retries = 0;
- failed_polls = 0;
- burst_size = i;
- total_cycles = 0;
- while (num_sent < num_to_submit) {
- if ((num_to_submit - num_sent) < burst_size)
- nb_ops = num_to_submit - num_sent;
- else
- nb_ops = burst_size;
-
- start_cycles = rte_rdtsc();
- burst_sent = rte_cryptodev_enqueue_burst(
- ts_params->dev_id,
- 0, &c_ops[num_sent],
- nb_ops);
- end_cycles = rte_rdtsc();
-
- if (burst_sent == 0)
- retries++;
- num_sent += burst_sent;
- total_cycles += (end_cycles - start_cycles);
-
- start_cycles = rte_rdtsc();
- burst_received = rte_cryptodev_dequeue_burst(
- ts_params->dev_id, 0, proc_ops,
- burst_size);
- end_cycles = rte_rdtsc();
- if (burst_received < burst_sent)
- failed_polls++;
- num_ops_received += burst_received;
-
- total_cycles += end_cycles - start_cycles;
- }
-
- while (num_ops_received != num_to_submit) {
- /* Sending 0 length burst to flush sw crypto device */
- rte_cryptodev_enqueue_burst(
- ts_params->dev_id, 0, NULL, 0);
-
- start_cycles = rte_rdtsc();
- burst_received = rte_cryptodev_dequeue_burst(
- ts_params->dev_id, 0, proc_ops, burst_size);
- end_cycles = rte_rdtsc();
-
- total_cycles += end_cycles - start_cycles;
- if (burst_received == 0)
- failed_polls++;
- num_ops_received += burst_received;
- }
-
- printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
- printf("\t\t%"PRIu64, retries);
- printf("\t%"PRIu64, failed_polls);
- printf("\t\t%"PRIu64, total_cycles/num_ops_received);
- printf("\t\t%"PRIu64,
- (total_cycles/num_ops_received)*burst_size);
- printf("\t\t%"PRIu64,
- total_cycles/(num_ops_received*pparams->buf_size));
- }
- printf("\n");
-
- for (i = 0; i < num_to_submit ; i++) {
- rte_pktmbuf_free(c_ops[i]->sym->m_src);
- rte_crypto_op_free(c_ops[i]);
- }
-
- return TEST_SUCCESS;
-}
-
-static uint32_t get_auth_key_max_length(enum rte_crypto_auth_algorithm algo)
-{
- switch (algo) {
- case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
- return 16;
- case RTE_CRYPTO_AUTH_SHA1_HMAC:
- return 64;
- case RTE_CRYPTO_AUTH_SHA224_HMAC:
- return 64;
- case RTE_CRYPTO_AUTH_SHA256_HMAC:
- return 64;
- case RTE_CRYPTO_AUTH_SHA384_HMAC:
- return 128;
- case RTE_CRYPTO_AUTH_SHA512_HMAC:
- return 128;
- default:
- return 0;
- }
-}
-
-static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo)
-{
- switch (algo) {
- case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
- return 4;
- case RTE_CRYPTO_AUTH_SHA1_HMAC:
- return TRUNCATED_DIGEST_BYTE_LENGTH_SHA1;
- case RTE_CRYPTO_AUTH_SHA224_HMAC:
- return TRUNCATED_DIGEST_BYTE_LENGTH_SHA224;
- case RTE_CRYPTO_AUTH_SHA256_HMAC:
- return TRUNCATED_DIGEST_BYTE_LENGTH_SHA256;
- case RTE_CRYPTO_AUTH_SHA384_HMAC:
- return TRUNCATED_DIGEST_BYTE_LENGTH_SHA384;
- case RTE_CRYPTO_AUTH_SHA512_HMAC:
- return TRUNCATED_DIGEST_BYTE_LENGTH_SHA512;
- default:
- return 0;
- }
-}
-
-static uint32_t get_aead_digest_length(enum rte_crypto_aead_algorithm algo)
-{
- switch (algo) {
- case RTE_CRYPTO_AEAD_AES_GCM:
- return DIGEST_BYTE_LENGTH_AES_GCM;
- default:
- return 0;
- }
-}
-
-static uint8_t aes_key[] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-};
-
-static uint8_t aes_iv[] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-};
-
-static uint8_t aes_gcm_aad[] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-};
-
-static uint8_t triple_des_key[] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-};
-
-static uint8_t triple_des_iv[] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-};
-
-static uint8_t hmac_sha_key[] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-};
-
-static uint8_t snow3g_cipher_key[] = {
- 0x2B, 0xD6, 0x45, 0x9F, 0x82, 0xC5, 0xB3, 0x00,
- 0x95, 0x2C, 0x49, 0x10, 0x48, 0x81, 0xFF, 0x48
-};
-
-static uint8_t snow3g_iv[] = {
- 0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00,
- 0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00
-};
-
-static uint8_t snow3g_hash_key[] = {
- 0xC7, 0x36, 0xC6, 0xAA, 0xB2, 0x2B, 0xFF, 0xF9,
- 0x1E, 0x26, 0x98, 0xD2, 0xE2, 0x2A, 0xD5, 0x7E
-};
-
-static int
-test_perf_create_aes_sha_session(uint8_t dev_id, enum chain_mode chain,
- enum rte_crypto_cipher_algorithm cipher_algo,
- unsigned cipher_key_len,
- enum rte_crypto_auth_algorithm auth_algo)
-{
- struct crypto_testsuite_params *ts_params = &testsuite_params;
- struct rte_crypto_sym_xform cipher_xform = { 0 };
- struct rte_crypto_sym_xform auth_xform = { 0 };
-
-
- /* Setup Cipher Parameters */
- cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
- cipher_xform.cipher.algo = cipher_algo;
- cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
-
- cipher_xform.cipher.key.data = aes_key;
- cipher_xform.cipher.key.length = cipher_key_len;
- cipher_xform.cipher.iv.offset = IV_OFFSET;
- cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH;
- if (chain != CIPHER_ONLY) {
- /* Setup HMAC Parameters */
- auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
- auth_xform.auth.algo = auth_algo;
- auth_xform.auth.key.data = hmac_sha_key;
- auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
- auth_xform.auth.digest_length =
- get_auth_digest_length(auth_algo);
- }
-
- test_crypto_session = rte_cryptodev_sym_session_create(ts_params->sess_mp);
- switch (chain) {
- case CIPHER_HASH:
- cipher_xform.next = &auth_xform;
- auth_xform.next = NULL;
- /* Create Crypto session*/
- return rte_cryptodev_sym_session_init(dev_id,
- test_crypto_session, &cipher_xform,
- ts_params->sess_mp);
- case HASH_CIPHER:
- auth_xform.next = &cipher_xform;
- cipher_xform.next = NULL;
- /* Create Crypto session*/
- return rte_cryptodev_sym_session_init(dev_id,
- test_crypto_session, &auth_xform,
- ts_params->sess_mp);
- case CIPHER_ONLY:
- cipher_xform.next = NULL;
- /* Create Crypto session*/
- return rte_cryptodev_sym_session_init(dev_id,
- test_crypto_session, &cipher_xform,
- ts_params->sess_mp);
- default:
- return -1;
- }
-}
-
-#define SNOW3G_CIPHER_IV_LENGTH 16
-
-static int
-test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
- enum rte_crypto_cipher_algorithm cipher_algo, unsigned cipher_key_len,
- enum rte_crypto_auth_algorithm auth_algo)
-{
- struct crypto_testsuite_params *ts_params = &testsuite_params;
- struct rte_crypto_sym_xform cipher_xform = {0};
- struct rte_crypto_sym_xform auth_xform = {0};
-
-
- /* Setup Cipher Parameters */
- cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
- cipher_xform.cipher.algo = cipher_algo;
- cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
-
- cipher_xform.cipher.key.data = snow3g_cipher_key;
- cipher_xform.cipher.key.length = cipher_key_len;
- cipher_xform.cipher.iv.offset = IV_OFFSET;
- cipher_xform.cipher.iv.length = SNOW3G_CIPHER_IV_LENGTH;
-
-
- /* Setup HMAC Parameters */
- auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
- auth_xform.auth.algo = auth_algo;
-
- auth_xform.auth.key.data = snow3g_hash_key;
- auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
- auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
- /* Auth IV will be after cipher IV */
- auth_xform.auth.iv.offset = IV_OFFSET + SNOW3G_CIPHER_IV_LENGTH;
- auth_xform.auth.iv.length = SNOW3G_CIPHER_IV_LENGTH;
-
- test_crypto_session = rte_cryptodev_sym_session_create(ts_params->sess_mp);
- switch (chain) {
- case CIPHER_HASH:
- cipher_xform.next = &auth_xform;
- auth_xform.next = NULL;
- /* Create Crypto session*/
- return rte_cryptodev_sym_session_init(dev_id,
- test_crypto_session, &cipher_xform,
- ts_params->sess_mp);
- case HASH_CIPHER:
- auth_xform.next = &cipher_xform;
- cipher_xform.next = NULL;
- /* Create Crypto session*/
- return rte_cryptodev_sym_session_init(dev_id,
- test_crypto_session, &auth_xform,
- ts_params->sess_mp);
- case CIPHER_ONLY:
- cipher_xform.next = NULL;
- /* Create Crypto session*/
- return rte_cryptodev_sym_session_init(dev_id,
- test_crypto_session, &cipher_xform,
- ts_params->sess_mp);
- case HASH_ONLY:
- auth_xform.next = NULL;
- /* Create Crypto session */
- return rte_cryptodev_sym_session_init(dev_id,
- test_crypto_session, &auth_xform,
- ts_params->sess_mp);
- default:
- return -1;
- }
-}
-
-static int
-test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain,
- enum rte_crypto_cipher_algorithm cipher_algo,
- unsigned int key_len,
- enum rte_crypto_auth_algorithm auth_algo,
- enum rte_crypto_aead_algorithm aead_algo)
-{
- struct crypto_testsuite_params *ts_params = &testsuite_params;
- struct rte_crypto_sym_xform cipher_xform = { 0 };
- struct rte_crypto_sym_xform auth_xform = { 0 };
- struct rte_crypto_sym_xform aead_xform = { 0 };
-
- if (chain == CIPHER_HASH || chain == HASH_CIPHER) {
- /* Setup Cipher Parameters */
- cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
- cipher_xform.cipher.algo = cipher_algo;
- cipher_xform.cipher.iv.offset = IV_OFFSET;
- cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
-
- switch (cipher_algo) {
- case RTE_CRYPTO_CIPHER_3DES_CBC:
- case RTE_CRYPTO_CIPHER_3DES_CTR:
- cipher_xform.cipher.key.data = triple_des_key;
- cipher_xform.cipher.iv.length = TRIPLE_DES_CIPHER_IV_LENGTH;
- break;
- case RTE_CRYPTO_CIPHER_AES_CBC:
- case RTE_CRYPTO_CIPHER_AES_CTR:
- cipher_xform.cipher.key.data = aes_key;
- cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH;
- break;
- default:
- return -1;
- }
-
- cipher_xform.cipher.key.length = key_len;
-
- /* Setup Auth Parameters */
- auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
- auth_xform.auth.algo = auth_algo;
-
- switch (auth_algo) {
- case RTE_CRYPTO_AUTH_SHA1_HMAC:
- auth_xform.auth.key.data = hmac_sha_key;
- break;
- default:
- return -1;
- }
-
- auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
- auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
- } else if (chain == AEAD) {
- /* Setup AEAD Parameters */
- aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
- aead_xform.aead.op = RTE_CRYPTO_AEAD_OP_ENCRYPT;
- aead_xform.aead.algo = aead_algo;
- aead_xform.aead.iv.offset = IV_OFFSET;
-
- switch (aead_algo) {
- case RTE_CRYPTO_AEAD_AES_GCM:
- aead_xform.aead.key.data = aes_key;
- aead_xform.aead.iv.length = AES_CIPHER_IV_LENGTH;
- aead_xform.aead.aad_length = AES_GCM_AAD_LENGTH;
- aead_xform.aead.digest_length = get_aead_digest_length(aead_algo);
- break;
- default:
- return -1;
- }
-
- aead_xform.aead.key.length = key_len;
- }
-
- test_crypto_session = rte_cryptodev_sym_session_create(ts_params->sess_mp);
- switch (chain) {
- case CIPHER_HASH:
- cipher_xform.next = &auth_xform;
- auth_xform.next = NULL;
- /* Create Crypto session*/
- return rte_cryptodev_sym_session_init(dev_id,
- test_crypto_session, &cipher_xform,
- ts_params->sess_mp);
- case HASH_CIPHER:
- auth_xform.next = &cipher_xform;
- cipher_xform.next = NULL;
- /* Create Crypto session*/
- return rte_cryptodev_sym_session_init(dev_id,
- test_crypto_session, &auth_xform,
- ts_params->sess_mp);
- case AEAD:
- /* Create Crypto session*/
- return rte_cryptodev_sym_session_init(dev_id,
- test_crypto_session, &aead_xform,
- ts_params->sess_mp);
- default:
- return -1;
- }
-}
-
-static int
-test_perf_create_armv8_session(uint8_t dev_id, enum chain_mode chain,
- enum rte_crypto_cipher_algorithm cipher_algo,
- unsigned int cipher_key_len,
- enum rte_crypto_auth_algorithm auth_algo)
-{
- struct crypto_testsuite_params *ts_params = &testsuite_params;
- struct rte_crypto_sym_xform cipher_xform = { 0 };
- struct rte_crypto_sym_xform auth_xform = { 0 };
-
- /* Setup Cipher Parameters */
- cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
- cipher_xform.cipher.algo = cipher_algo;
-
- switch (cipher_algo) {
- case RTE_CRYPTO_CIPHER_AES_CBC:
- cipher_xform.cipher.key.data = aes_cbc_128_key;
- break;
- default:
- return -1;
- }
-
- cipher_xform.cipher.key.length = cipher_key_len;
- cipher_xform.cipher.iv.offset = IV_OFFSET;
- cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH;
-
- /* Setup Auth Parameters */
- auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
- auth_xform.auth.algo = auth_algo;
-
- auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
-
- test_crypto_session = rte_cryptodev_sym_session_create(ts_params->sess_mp);
-
- switch (chain) {
- case CIPHER_HASH:
- cipher_xform.next = &auth_xform;
- auth_xform.next = NULL;
- /* Encrypt and hash the result */
- cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
- /* Create Crypto session*/
- return rte_cryptodev_sym_session_init(dev_id,
- test_crypto_session, &cipher_xform,
- ts_params->sess_mp);
- case HASH_CIPHER:
- auth_xform.next = &cipher_xform;
- cipher_xform.next = NULL;
- /* Hash encrypted message and decrypt */
- cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
- /* Create Crypto session*/
- return rte_cryptodev_sym_session_init(dev_id,
- test_crypto_session, &auth_xform,
- ts_params->sess_mp);
- default:
- return -1;
- }
-}
-
-static struct rte_mbuf *
-test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz)
-{
- struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
-
- if (rte_pktmbuf_append(m, buf_sz) == NULL) {
- rte_pktmbuf_free(m);
- return NULL;
- }
-
- memset(rte_pktmbuf_mtod(m, uint8_t *), 0, buf_sz);
-
- return m;
-}
-
-static inline struct rte_crypto_op *
-test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m,
- struct rte_cryptodev_sym_session *sess, unsigned int data_len,
- enum chain_mode chain)
-{
- if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
- rte_crypto_op_free(op);
- return NULL;
- }
-
- /* Authentication Parameters */
- if (chain == CIPHER_ONLY) {
- op->sym->auth.digest.data = NULL;
- op->sym->auth.digest.phys_addr = 0;
- op->sym->auth.data.offset = 0;
- op->sym->auth.data.length = 0;
- } else {
- op->sym->auth.digest.data = rte_pktmbuf_mtod_offset(m,
- uint8_t *, data_len);
- op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m,
- data_len);
- op->sym->auth.data.offset = 0;
- op->sym->auth.data.length = data_len;
- }
-
-
- /* Copy the IV at the end of the crypto operation */
- rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
- aes_iv, AES_CIPHER_IV_LENGTH);
-
- /* Cipher Parameters */
- op->sym->cipher.data.offset = 0;
- op->sym->cipher.data.length = data_len;
-
- op->sym->m_src = m;
-
- return op;
-}
-
-static inline struct rte_crypto_op *
-test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
- struct rte_cryptodev_sym_session *sess, unsigned int data_len,
- enum chain_mode chain __rte_unused)
-{
- if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
- rte_crypto_op_free(op);
- return NULL;
- }
-
- /* Authentication Parameters */
- op->sym->aead.digest.data = (uint8_t *)m->buf_addr +
- (m->data_off + data_len);
- op->sym->aead.digest.phys_addr =
- rte_pktmbuf_mtophys_offset(m, data_len);
- op->sym->aead.aad.data = aes_gcm_aad;
-
- /* Copy IV at the end of the crypto operation */
- rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
- aes_iv, AES_CIPHER_IV_LENGTH);
-
- /* Data lengths/offsets Parameters */
- op->sym->aead.data.offset = 0;
- op->sym->aead.data.length = data_len;
-
- op->sym->m_src = m;
-
- return op;
-}
-
-static inline struct rte_crypto_op *
-test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
- struct rte_cryptodev_sym_session *sess, unsigned int data_len)
-{
- uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
- uint8_t *, IV_OFFSET);
-
- if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
- rte_crypto_op_free(op);
- return NULL;
- }
-
- rte_memcpy(iv_ptr, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
-
- /* Authentication Parameters */
- op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
- (m->data_off + data_len);
- op->sym->auth.digest.phys_addr =
- rte_pktmbuf_mtophys_offset(m, data_len);
-
- /* Data lengths/offsets Parameters */
- op->sym->auth.data.offset = 0;
- op->sym->auth.data.length = data_len << 3;
-
- op->sym->cipher.data.offset = 0;
- op->sym->cipher.data.length = data_len << 3;
-
- op->sym->m_src = m;
-
- return op;
-}
-
-static inline struct rte_crypto_op *
-test_perf_set_crypto_op_snow3g_cipher(struct rte_crypto_op *op,
- struct rte_mbuf *m,
- struct rte_cryptodev_sym_session *sess,
- unsigned data_len)
-{
- if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
- rte_crypto_op_free(op);
- return NULL;
- }
-
- /* Copy IV at the end of the crypto operation */
- rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
- snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
-
- /* Cipher Parameters */
- op->sym->cipher.data.offset = 0;
- op->sym->cipher.data.length = data_len << 3;
-
- rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
- snow3g_iv,
- SNOW3G_CIPHER_IV_LENGTH);
-
- op->sym->m_src = m;
-
- return op;
-}
-
-
-static inline struct rte_crypto_op *
-test_perf_set_crypto_op_snow3g_hash(struct rte_crypto_op *op,
- struct rte_mbuf *m,
- struct rte_cryptodev_sym_session *sess,
- unsigned int data_len)
-{
- uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
- uint8_t *, IV_OFFSET);
-
- if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
- rte_crypto_op_free(op);
- return NULL;
- }
-
- rte_memcpy(iv_ptr, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
-
- /* Authentication Parameters */
-
- op->sym->auth.digest.data =
- (uint8_t *)rte_pktmbuf_mtod_offset(m, uint8_t *,
- data_len);
- op->sym->auth.digest.phys_addr =
- rte_pktmbuf_mtophys_offset(m, data_len +
- SNOW3G_CIPHER_IV_LENGTH);
-
- /* Data lengths/offsets Parameters */
- op->sym->auth.data.offset = 0;
- op->sym->auth.data.length = data_len << 3;
-
- op->sym->m_src = m;
-
- return op;
-}
-
-
-static inline struct rte_crypto_op *
-test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
- struct rte_cryptodev_sym_session *sess, unsigned int data_len,
- enum chain_mode chain __rte_unused)
-{
- if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
- rte_crypto_op_free(op);
- return NULL;
- }
-
- /* Authentication Parameters */
- op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
- (m->data_off + data_len);
- op->sym->auth.digest.phys_addr =
- rte_pktmbuf_mtophys_offset(m, data_len);
-
- /* Copy IV at the end of the crypto operation */
- rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
- triple_des_iv, TRIPLE_DES_CIPHER_IV_LENGTH);
-
- /* Data lengths/offsets Parameters */
- op->sym->auth.data.offset = 0;
- op->sym->auth.data.length = data_len;
-
- op->sym->cipher.data.offset = 0;
- op->sym->cipher.data.length = data_len;
-
- op->sym->m_src = m;
-
- return op;
-}
-
-/* An mbuf set is used in each burst. An mbuf can be used by multiple bursts at
- * same time, i.e. as they're not dereferenced there's no need to wait until
- * finished with to re-use */
-#define NUM_MBUF_SETS 8
-
-static int
-test_perf_aes_sha(uint8_t dev_id, uint16_t queue_id,
- struct perf_test_params *pparams)
-{
- uint16_t i, k, l, m;
- uint16_t j = 0;
- uint16_t ops_unused = 0;
-
- uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
- uint64_t processed = 0, failed_polls = 0, retries = 0;
- uint64_t tsc_start = 0, tsc_end = 0;
-
- uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
-
- struct rte_crypto_op *ops[pparams->burst_size];
- struct rte_crypto_op *proc_ops[pparams->burst_size];
-
- struct rte_mbuf *mbufs[pparams->burst_size * 8];
-
- struct crypto_testsuite_params *ts_params = &testsuite_params;
-
- static struct rte_cryptodev_sym_session *sess;
-
- if (rte_cryptodev_count() == 0) {
- printf("\nNo crypto devices available. Is kernel driver loaded?\n");
- return TEST_FAILED;
- }
-
- /* Create Crypto session*/
- if (test_perf_create_aes_sha_session(ts_params->dev_id,
- pparams->chain, pparams->cipher_algo,
- pparams->key_length, pparams->auth_algo) == 0)
- sess = test_crypto_session;
- else
- sess = NULL;
- TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
-
- /* Generate a burst of crypto operations */
- for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
- mbufs[i] = test_perf_create_pktmbuf(
- ts_params->mbuf_mp,
- pparams->buf_size);
-
- if (mbufs[i] == NULL) {
- printf("\nFailed to get mbuf - freeing the rest.\n");
- for (k = 0; k < i; k++)
- rte_pktmbuf_free(mbufs[k]);
- return -1;
- }
-
- /* Make room for Digest in mbuf */
- if (pparams->chain != CIPHER_ONLY)
- rte_pktmbuf_append(mbufs[i], digest_length);
- }
-
-
- tsc_start = rte_rdtsc_precise();
-
- while (total_enqueued < pparams->total_operations) {
- uint16_t burst_size =
- total_enqueued+pparams->burst_size <= pparams->total_operations ?
- pparams->burst_size : pparams->total_operations-total_enqueued;
- uint16_t ops_needed = burst_size-ops_unused;
-
- if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
- printf("\nFailed to alloc enough ops, finish dequeuing "
- "and free ops below.");
- } else {
- for (i = 0; i < ops_needed; i++)
- ops[i] = test_perf_set_crypto_op_aes(ops[i],
- mbufs[i + (pparams->burst_size *
- (j % NUM_MBUF_SETS))],
- sess, pparams->buf_size,
- pparams->chain);
-
- /* enqueue burst */
- burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
- queue_id, ops, burst_size);
-
- if (burst_enqueued < burst_size)
- retries++;
-
- ops_unused = burst_size-burst_enqueued;
- total_enqueued += burst_enqueued;
- }
-
- /* dequeue burst */
- burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
- proc_ops, pparams->burst_size);
- if (burst_dequeued == 0)
- failed_polls++;
- else {
- processed += burst_dequeued;
-
- for (l = 0; l < burst_dequeued; l++)
- rte_crypto_op_free(proc_ops[l]);
- }
- j++;
- }
-
- /* Dequeue any operations still in the crypto device */
- while (processed < pparams->total_operations) {
- /* Sending 0 length burst to flush sw crypto device */
- rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
-
- /* dequeue burst */
- burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
- proc_ops, pparams->burst_size);
- if (burst_dequeued == 0)
- failed_polls++;
- else {
- processed += burst_dequeued;
-
- for (m = 0; m < burst_dequeued; m++)
- rte_crypto_op_free(proc_ops[m]);
- }
- }
-
- tsc_end = rte_rdtsc_precise();
-
- double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
- double throughput = (ops_s * pparams->buf_size * 8) / 1000000000;
-
- printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size, ops_s/1000000,
- throughput, retries, failed_polls);
-
- for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
- rte_pktmbuf_free(mbufs[i]);
-
- rte_cryptodev_sym_session_clear(ts_params->dev_id, sess);
- rte_cryptodev_sym_session_free(sess);
-
- printf("\n");
- return TEST_SUCCESS;
-}
-
-
-static int
-test_perf_snow3g(uint8_t dev_id, uint16_t queue_id,
- struct perf_test_params *pparams)
-{
- uint16_t i, k, l, m;
- uint16_t j = 0;
- uint16_t ops_unused = 0;
- uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
- uint64_t processed = 0, failed_polls = 0, retries = 0;
- uint64_t tsc_start = 0, tsc_end = 0;
-
- uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
-
- struct rte_crypto_op *ops[pparams->burst_size];
- struct rte_crypto_op *proc_ops[pparams->burst_size];
-
- struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
-
- struct crypto_testsuite_params *ts_params = &testsuite_params;
-
- static struct rte_cryptodev_sym_session *sess;
-
- if (rte_cryptodev_count() == 0) {
- printf("\nNo crypto devices found. Is PMD build configured?\n");
- printf("\nAnd is kernel driver loaded for HW PMDs?\n");
- return TEST_FAILED;
- }
-
- /* Create Crypto session*/
- if (test_perf_create_snow3g_session(ts_params->dev_id,
- pparams->chain, pparams->cipher_algo,
- pparams->key_length, pparams->auth_algo) == 0)
- sess = test_crypto_session;
- else
- sess = NULL;
- TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
-
- /* Generate a burst of crypto operations */
- for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
- /*
- * Buffer size is allocated, for perf tests they
- * are equal + digest len.
- */
- mbufs[i] = test_perf_create_pktmbuf(
- ts_params->mbuf_mp,
- pparams->buf_size +
- digest_length);
-
- if (mbufs[i] == NULL) {
- printf("\nFailed to get mbuf - freeing the rest.\n");
- for (k = 0; k < i; k++)
- rte_pktmbuf_free(mbufs[k]);
- return -1;
- }
-
- }
-
- tsc_start = rte_rdtsc_precise();
-
- while (total_enqueued < pparams->total_operations) {
- uint16_t burst_size =
- (total_enqueued+pparams->burst_size)
- <= pparams->total_operations ?
- pparams->burst_size : pparams->total_operations-total_enqueued;
- uint16_t ops_needed = burst_size-ops_unused;
- /* Handle the last burst correctly */
- uint16_t op_offset = pparams->burst_size - burst_size;
-
- if (ops_needed !=
- rte_crypto_op_bulk_alloc(ts_params->op_mpool,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC,
- ops+op_offset, ops_needed)) {
- printf("\nFailed to alloc enough ops.");
- /*Don't exit, dequeue, more ops should become available*/
- } else {
- for (i = 0; i < ops_needed; i++) {
- if (pparams->chain == HASH_ONLY)
- ops[i+op_offset] =
- test_perf_set_crypto_op_snow3g_hash(ops[i+op_offset],
- mbufs[i +
- (pparams->burst_size * (j % NUM_MBUF_SETS))],
- sess,
- pparams->buf_size);
- else if (pparams->chain == CIPHER_ONLY)
- ops[i+op_offset] =
- test_perf_set_crypto_op_snow3g_cipher(ops[i+op_offset],
- mbufs[i +
- (pparams->burst_size * (j % NUM_MBUF_SETS))],
- sess,
- pparams->buf_size);
- else
- return 1;
- }
-
- /* enqueue burst */
- burst_enqueued =
- rte_cryptodev_enqueue_burst(dev_id, queue_id,
- ops+op_offset, burst_size);
-
- if (burst_enqueued < burst_size)
- retries++;
-
- ops_unused = burst_size-burst_enqueued;
- total_enqueued += burst_enqueued;
- }
-
- /* dequeue burst */
- burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
- proc_ops, pparams->burst_size);
- if (burst_dequeued == 0) {
- failed_polls++;
- } else {
- processed += burst_dequeued;
- for (l = 0; l < burst_dequeued; l++)
- rte_crypto_op_free(proc_ops[l]);
- }
- j++;
- }
-
- /* Dequeue any operations still in the crypto device */
- while (processed < pparams->total_operations) {
- /* Sending 0 length burst to flush sw crypto device */
- rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
-
- /* dequeue burst */
- burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
- proc_ops, pparams->burst_size);
- if (burst_dequeued == 0)
- failed_polls++;
- else {
- processed += burst_dequeued;
- for (m = 0; m < burst_dequeued; m++)
- rte_crypto_op_free(proc_ops[m]);
- }
- }
-
- tsc_end = rte_rdtsc_precise();
-
- double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
- double cycles_burst = (double) (tsc_end - tsc_start) /
- (double) processed * pparams->burst_size;
- double cycles_buff = (double) (tsc_end - tsc_start) / (double) processed;
- double cycles_B = cycles_buff / pparams->buf_size;
- double throughput = (ops_s * pparams->buf_size * 8) / 1000000;
-
- if (gbl_driver_id == rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD))) {
- /* Cycle count misleading on HW devices for this test, so don't print */
- printf("%4u\t%6.2f\t%10.2f\t n/a \t\t n/a "
- "\t\t n/a \t\t%8"PRIu64"\t%8"PRIu64,
- pparams->buf_size, ops_s/1000000,
- throughput, retries, failed_polls);
- } else {
- printf("%4u\t%6.2f\t%10.2f\t%10.2f\t%8.2f"
- "\t%8.2f\t%8"PRIu64"\t%8"PRIu64,
- pparams->buf_size, ops_s/1000000, throughput, cycles_burst,
- cycles_buff, cycles_B, retries, failed_polls);
- }
-
- for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
- rte_pktmbuf_free(mbufs[i]);
-
- rte_cryptodev_sym_session_clear(ts_params->dev_id, sess);
- rte_cryptodev_sym_session_free(sess);
-
- printf("\n");
- return TEST_SUCCESS;
-}
-
-static int
-test_perf_openssl(uint8_t dev_id, uint16_t queue_id,
- struct perf_test_params *pparams)
-{
- uint16_t i, k, l, m;
- uint16_t j = 0;
- uint16_t ops_unused = 0;
-
- uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
- uint64_t processed = 0, failed_polls = 0, retries = 0;
- uint64_t tsc_start = 0, tsc_end = 0;
-
- struct rte_crypto_op *ops[pparams->burst_size];
- struct rte_crypto_op *proc_ops[pparams->burst_size];
-
- struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
-
- struct crypto_testsuite_params *ts_params = &testsuite_params;
-
- static struct rte_cryptodev_sym_session *sess;
-
- static struct rte_crypto_op *(*test_perf_set_crypto_op)
- (struct rte_crypto_op *, struct rte_mbuf *,
- struct rte_cryptodev_sym_session *,
- unsigned int,
- enum chain_mode);
-
- if (pparams->chain == AEAD)
- test_perf_set_crypto_op =
- test_perf_set_crypto_op_aes_gcm;
- else {
- switch (pparams->cipher_algo) {
- case RTE_CRYPTO_CIPHER_3DES_CBC:
- case RTE_CRYPTO_CIPHER_3DES_CTR:
- test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
- break;
- case RTE_CRYPTO_CIPHER_AES_CBC:
- case RTE_CRYPTO_CIPHER_AES_CTR:
- test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
- break;
- default:
- return TEST_FAILED;
- }
- }
-
- if (rte_cryptodev_count() == 0) {
- printf("\nNo crypto devices found. Is PMD build configured?\n");
- return TEST_FAILED;
- }
-
- /* Create Crypto session*/
- if (test_perf_create_openssl_session(ts_params->dev_id,
- pparams->chain, pparams->cipher_algo,
- pparams->key_length, pparams->auth_algo,
- pparams->aead_algo) == 0)
- sess = test_crypto_session;
- else
- sess = NULL;
- TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
-
- /* Generate a burst of crypto operations */
- for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
- mbufs[i] = test_perf_create_pktmbuf(
- ts_params->mbuf_mp,
- pparams->buf_size);
-
- if (mbufs[i] == NULL) {
- printf("\nFailed to get mbuf - freeing the rest.\n");
- for (k = 0; k < i; k++)
- rte_pktmbuf_free(mbufs[k]);
- return -1;
- }
- }
-
- tsc_start = rte_rdtsc_precise();
-
- while (total_enqueued < pparams->total_operations) {
- uint16_t burst_size =
- total_enqueued + pparams->burst_size <=
- pparams->total_operations ? pparams->burst_size :
- pparams->total_operations - total_enqueued;
- uint16_t ops_needed = burst_size - ops_unused;
-
- if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
- printf("\nFailed to alloc enough ops, finish dequeuing "
- "and free ops below.");
- } else {
- for (i = 0; i < ops_needed; i++)
- ops[i] = test_perf_set_crypto_op(ops[i],
- mbufs[i + (pparams->burst_size *
- (j % NUM_MBUF_SETS))],
- sess, pparams->buf_size,
- pparams->chain);
-
- /* enqueue burst */
- burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
- queue_id, ops, burst_size);
-
- if (burst_enqueued < burst_size)
- retries++;
-
- ops_unused = burst_size - burst_enqueued;
- total_enqueued += burst_enqueued;
- }
-
- /* dequeue burst */
- burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
- proc_ops, pparams->burst_size);
- if (burst_dequeued == 0)
- failed_polls++;
- else {
- processed += burst_dequeued;
-
- for (l = 0; l < burst_dequeued; l++)
- rte_crypto_op_free(proc_ops[l]);
- }
- j++;
- }
-
- /* Dequeue any operations still in the crypto device */
- while (processed < pparams->total_operations) {
- /* Sending 0 length burst to flush sw crypto device */
- rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
-
- /* dequeue burst */
- burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
- proc_ops, pparams->burst_size);
- if (burst_dequeued == 0)
- failed_polls++;
- else {
- processed += burst_dequeued;
-
- for (m = 0; m < burst_dequeued; m++)
- rte_crypto_op_free(proc_ops[m]);
- }
- }
-
- tsc_end = rte_rdtsc_precise();
-
- double ops_s = ((double)processed / (tsc_end - tsc_start))
- * rte_get_tsc_hz();
- double throughput = (ops_s * pparams->buf_size * NUM_MBUF_SETS)
- / 1000000000;
-
- printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size,
- ops_s / 1000000, throughput, retries, failed_polls);
-
- for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
- rte_pktmbuf_free(mbufs[i]);
-
- rte_cryptodev_sym_session_clear(ts_params->dev_id, sess);
- rte_cryptodev_sym_session_free(sess);
-
- printf("\n");
- return TEST_SUCCESS;
-}
-
-static int
-test_perf_armv8(uint8_t dev_id, uint16_t queue_id,
- struct perf_test_params *pparams)
-{
- uint16_t i, k, l, m;
- uint16_t j = 0;
- uint16_t ops_unused = 0;
- uint16_t burst_size;
- uint16_t ops_needed;
-
- uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
- uint64_t processed = 0, failed_polls = 0, retries = 0;
- uint64_t tsc_start = 0, tsc_end = 0;
-
- struct rte_crypto_op *ops[pparams->burst_size];
- struct rte_crypto_op *proc_ops[pparams->burst_size];
-
- struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
-
- struct crypto_testsuite_params *ts_params = &testsuite_params;
-
- static struct rte_cryptodev_sym_session *sess;
-
- if (rte_cryptodev_count() == 0) {
- printf("\nNo crypto devices found. Is PMD build configured?\n");
- return TEST_FAILED;
- }
-
- /* Create Crypto session*/
- if (test_perf_create_armv8_session(ts_params->dev_id,
- pparams->chain, pparams->cipher_algo,
- pparams->key_length, pparams->auth_algo) == 0)
- sess = test_crypto_session;
- else
- sess = NULL;
- TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
-
- /* Generate a burst of crypto operations */
- for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
- mbufs[i] = test_perf_create_pktmbuf(
- ts_params->mbuf_mp,
- pparams->buf_size);
-
- if (mbufs[i] == NULL) {
- printf("\nFailed to get mbuf - freeing the rest.\n");
- for (k = 0; k < i; k++)
- rte_pktmbuf_free(mbufs[k]);
- return -1;
- }
- }
-
- tsc_start = rte_rdtsc();
-
- while (total_enqueued < pparams->total_operations) {
- if ((total_enqueued + pparams->burst_size) <=
- pparams->total_operations)
- burst_size = pparams->burst_size;
- else
- burst_size = pparams->total_operations - total_enqueued;
-
- ops_needed = burst_size - ops_unused;
-
- if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
- printf("\nFailed to alloc enough ops, finish dequeuing "
- "and free ops below.");
- } else {
- for (i = 0; i < ops_needed; i++)
- ops[i] = test_perf_set_crypto_op_aes(ops[i],
- mbufs[i + (pparams->burst_size *
- (j % NUM_MBUF_SETS))], sess,
- pparams->buf_size,
- pparams->chain);
-
- /* enqueue burst */
- burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
- queue_id, ops, burst_size);
-
- if (burst_enqueued < burst_size)
- retries++;
-
- ops_unused = burst_size - burst_enqueued;
- total_enqueued += burst_enqueued;
- }
-
- /* dequeue burst */
- burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
- proc_ops, pparams->burst_size);
- if (burst_dequeued == 0)
- failed_polls++;
- else {
- processed += burst_dequeued;
-
- for (l = 0; l < burst_dequeued; l++)
- rte_crypto_op_free(proc_ops[l]);
- }
- j++;
- }
-
- /* Dequeue any operations still in the crypto device */
- while (processed < pparams->total_operations) {
- /* Sending 0 length burst to flush sw crypto device */
- rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
-
- /* dequeue burst */
- burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
- proc_ops, pparams->burst_size);
- if (burst_dequeued == 0)
- failed_polls++;
- else {
- processed += burst_dequeued;
-
- for (m = 0; m < burst_dequeued; m++)
- rte_crypto_op_free(proc_ops[m]);
- }
- }
-
- tsc_end = rte_rdtsc();
-
- double ops_s = ((double)processed / (tsc_end - tsc_start))
- * rte_get_tsc_hz();
- double throughput = (ops_s * pparams->buf_size * NUM_MBUF_SETS)
- / 1000000000;
-
- printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size,
- ops_s / 1000000, throughput, retries, failed_polls);
-
- for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
- rte_pktmbuf_free(mbufs[i]);
-
- printf("\n");
- return TEST_SUCCESS;
-}
-
-/*
-
- perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA1);
- perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_256);
- perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_512);
-
- perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA1);
- perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_256);
- perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_512);
-
- perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA1);
- perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_256);
- perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_512);
- */
-static int
-test_perf_aes_cbc_encrypt_digest_vary_pkt_size(void)
-{
- unsigned total_operations = 1000000;
- unsigned burst_size = 32;
- unsigned buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536, 1792, 2048 };
- uint8_t i, j;
-
- struct perf_test_params params_set[] = {
- {
- .chain = CIPHER_ONLY,
- .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_NULL
- },
- {
- .chain = CIPHER_HASH,
- .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
- },
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
- },
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
- },
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
- .key_length = 32,
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
- },
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
- .key_length = 32,
- .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
- },
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
- .key_length = 32,
- .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
- },
- };
-
- for (i = 0; i < RTE_DIM(params_set); i++) {
-
- params_set[i].total_operations = total_operations;
- params_set[i].burst_size = burst_size;
- printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
- " burst_size: %d ops\n",
- chain_mode_name(params_set[i].chain),
- rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
- rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
- params_set[i].key_length,
- burst_size);
- printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
- "Retries\tEmptyPolls\n");
- for (j = 0; j < RTE_DIM(buf_lengths); j++) {
- params_set[i].buf_size = buf_lengths[j];
- test_perf_aes_sha(testsuite_params.dev_id, 0,
- ¶ms_set[i]);
- }
- }
- return 0;
-}
-
-static int
-test_perf_snow3G_vary_pkt_size(void)
-{
- unsigned total_operations = 1000000;
- uint8_t i, j;
- unsigned k;
- uint16_t burst_sizes[] = { 64 };
- uint16_t buf_lengths[] = { 40, 64, 80, 120, 240, 256, 400, 512, 600, 1024, 2048 };
-
- struct perf_test_params params_set[] = {
- {
- .chain = CIPHER_ONLY,
- .cipher_algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_NULL,
- },
- {
- .chain = HASH_ONLY,
- .cipher_algo = RTE_CRYPTO_CIPHER_NULL,
- .auth_algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
- .key_length = 16
- },
- };
-
- printf("\n\nStart %s.", __func__);
- printf("\nTest to measure max throughput at various pkt sizes.");
- printf("\nOn HW devices t'put maximised when high Retries and EmptyPolls"
- " so cycle cost not relevant (n/a displayed).");
-
- for (i = 0; i < RTE_DIM(params_set); i++) {
- printf("\n\n");
- params_set[i].total_operations = total_operations;
- for (k = 0; k < RTE_DIM(burst_sizes); k++) {
- enum rte_crypto_cipher_algorithm cipher_algo =
- params_set[i].cipher_algo;
- enum rte_crypto_auth_algorithm auth_algo =
- params_set[i].auth_algo;
- printf("\nOn %s dev%u qp%u, %s, "
- "cipher algo:%s, auth algo:%s, burst_size: %d ops",
- pmd_name(gbl_driver_id),
- testsuite_params.dev_id, 0,
- chain_mode_name(params_set[i].chain),
- rte_crypto_cipher_algorithm_strings[cipher_algo],
- rte_crypto_auth_algorithm_strings[auth_algo],
- burst_sizes[k]);
-
- params_set[i].burst_size = burst_sizes[k];
- printf("\nPktSzB\tOp/s(M)\tThruput(Mbps)\tCycles/Burst\t"
- "Cycles/buf\tCycles/B\tRetries\t\tEmptyPolls\n");
- for (j = 0; j < RTE_DIM(buf_lengths); j++) {
-
- params_set[i].buf_size = buf_lengths[j];
-
- test_perf_snow3g(testsuite_params.dev_id, 0, ¶ms_set[i]);
- }
- }
- }
-
- return 0;
-}
-
-static int
-test_perf_openssl_vary_pkt_size(void)
-{
- unsigned int total_operations = 10000;
- unsigned int burst_size = { 64 };
- unsigned int buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536,
- 1792, 2048 };
- uint8_t i, j;
-
- struct perf_test_params params_set[] = {
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
- },
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
- .key_length = 24,
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
- },
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
- },
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
- .key_length = 32,
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
- },
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
- },
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
- .key_length = 24,
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
- },
- {
- .chain = AEAD,
-
- .aead_algo = RTE_CRYPTO_AEAD_AES_GCM,
- .key_length = 16,
- },
- };
-
- for (i = 0; i < RTE_DIM(params_set); i++) {
- params_set[i].total_operations = total_operations;
- params_set[i].burst_size = burst_size;
- if (params_set[i].chain == AEAD) {
- enum rte_crypto_aead_algorithm aead_algo =
- params_set[i].aead_algo;
- printf("\n%s. aead algo: %s key size=%u."
- " burst_size: %d ops\n",
- chain_mode_name(params_set[i].chain),
- rte_crypto_aead_algorithm_strings[aead_algo],
- params_set[i].key_length,
- burst_size);
- } else {
- enum rte_crypto_cipher_algorithm cipher_algo =
- params_set[i].cipher_algo;
- enum rte_crypto_auth_algorithm auth_algo =
- params_set[i].auth_algo;
- printf("\n%s. cipher algo: %s auth algo: %s key size=%u."
- " burst_size: %d ops\n",
- chain_mode_name(params_set[i].chain),
- rte_crypto_cipher_algorithm_strings[cipher_algo],
- rte_crypto_auth_algorithm_strings[auth_algo],
- params_set[i].key_length,
- burst_size);
- }
- printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t"
- "EmptyPolls\n");
- for (j = 0; j < RTE_DIM(buf_lengths); j++) {
- params_set[i].buf_size = buf_lengths[j];
- test_perf_openssl(testsuite_params.dev_id, 0,
- ¶ms_set[i]);
- }
- }
-
- return 0;
-}
-
-static int
-test_perf_openssl_vary_burst_size(void)
-{
- unsigned int total_operations = 4096;
- uint16_t buf_lengths[] = { 40 };
- uint8_t i, j;
-
- struct perf_test_params params_set[] = {
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
- },
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
- .key_length = 24,
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
- },
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
- },
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
- .key_length = 32,
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
- },
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
- },
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
- .key_length = 24,
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
- },
- {
- .chain = AEAD,
-
- .aead_algo = RTE_CRYPTO_AEAD_AES_GCM,
- .key_length = 16,
- },
- };
-
- printf("\n\nStart %s.", __func__);
- printf("\nThis Test measures the average IA cycle cost using a "
- "constant request(packet) size. ");
- printf("Cycle cost is only valid when indicators show device is not"
- " busy, i.e. Retries and EmptyPolls = 0");
-
- for (i = 0; i < RTE_DIM(params_set); i++) {
- printf("\n");
- params_set[i].total_operations = total_operations;
-
- for (j = 0; j < RTE_DIM(buf_lengths); j++) {
- params_set[i].buf_size = buf_lengths[j];
- test_perf_openssl_optimise_cyclecount(¶ms_set[i]);
- }
- }
-
- return 0;
-}
-
-static int
-test_perf_armv8_vary_pkt_size(void)
-{
- unsigned int total_operations = 100000;
- unsigned int burst_size = { 64 };
- unsigned int buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536,
- 1792, 2048 };
- uint8_t i, j;
-
- struct perf_test_params params_set[] = {
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
- },
- {
- .chain = HASH_CIPHER,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
- },
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
- },
- {
- .chain = HASH_CIPHER,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
- },
- };
-
- for (i = 0; i < RTE_DIM(params_set); i++) {
- params_set[i].total_operations = total_operations;
- params_set[i].burst_size = burst_size;
- printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
- " burst_size: %d ops\n",
- chain_mode_name(params_set[i].chain),
- rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
- rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
- params_set[i].key_length,
- burst_size);
- printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t"
- "EmptyPolls\n");
- for (j = 0; j < RTE_DIM(buf_lengths); j++) {
- params_set[i].buf_size = buf_lengths[j];
- test_perf_armv8(testsuite_params.dev_id, 0,
- ¶ms_set[i]);
- }
- }
-
- return 0;
-}
-
-static int
-test_perf_armv8_vary_burst_size(void)
-{
- unsigned int total_operations = 4096;
- uint16_t buf_lengths[] = { 64 };
- uint8_t i, j;
-
- struct perf_test_params params_set[] = {
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
- },
- {
- .chain = HASH_CIPHER,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
- },
- {
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
- },
- {
- .chain = HASH_CIPHER,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
- },
- };
-
- printf("\n\nStart %s.", __func__);
- printf("\nThis Test measures the average IA cycle cost using a "
- "constant request(packet) size. ");
- printf("Cycle cost is only valid when indicators show device is "
- "not busy, i.e. Retries and EmptyPolls = 0");
-
- for (i = 0; i < RTE_DIM(params_set); i++) {
- printf("\n");
- params_set[i].total_operations = total_operations;
-
- for (j = 0; j < RTE_DIM(buf_lengths); j++) {
- params_set[i].buf_size = buf_lengths[j];
- test_perf_armv8_optimise_cyclecount(¶ms_set[i]);
- }
- }
-
- return 0;
-}
-
-static int
-test_perf_aes_cbc_vary_burst_size(void)
-{
- return test_perf_crypto_qp_vary_burst_size(testsuite_params.dev_id);
-}
-
-
-static struct rte_cryptodev_sym_session *
-test_perf_create_session(uint8_t dev_id, struct perf_test_params *pparams)
-{
- struct crypto_testsuite_params *ts_params = &testsuite_params;
- struct rte_crypto_sym_xform aead_xform = { 0 };
-
- uint8_t aead_key[pparams->session_attrs->key_aead_len];
-
- memcpy(aead_key, pparams->session_attrs->key_aead_data,
- pparams->session_attrs->key_aead_len);
-
- aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
- aead_xform.next = NULL;
-
- aead_xform.aead.algo = pparams->session_attrs->aead_algorithm;
- aead_xform.aead.op = pparams->session_attrs->aead;
- aead_xform.aead.key.data = aead_key;
- aead_xform.aead.key.length = pparams->session_attrs->key_aead_len;
- aead_xform.aead.iv.length = pparams->session_attrs->iv_len;
- aead_xform.aead.iv.offset = IV_OFFSET;
- aead_xform.aead.aad_length = pparams->session_attrs->aad_len;
- aead_xform.aead.digest_length = pparams->session_attrs->digest_len;
-
- test_crypto_session = rte_cryptodev_sym_session_create(ts_params->sess_mp);
-
- rte_cryptodev_sym_session_init(dev_id, test_crypto_session,
- &aead_xform, ts_params->sess_mp);
-
- return test_crypto_session;
-}
-
-static inline struct rte_crypto_op *
-perf_gcm_set_crypto_op(struct rte_crypto_op *op, struct rte_mbuf *m,
- struct rte_cryptodev_sym_session *sess,
- struct crypto_params *m_hlp,
- struct perf_test_params *params)
-{
- uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
- uint8_t *, IV_OFFSET);
-
- if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
- rte_crypto_op_free(op);
- return NULL;
- }
-
- op->sym->aead.digest.data = m_hlp->digest;
- op->sym->aead.digest.phys_addr = rte_pktmbuf_mtophys_offset(
- m,
- params->session_attrs->aad_len +
- params->symmetric_op->p_len);
-
-
- op->sym->aead.aad.data = m_hlp->aad;
- op->sym->aead.aad.phys_addr = rte_pktmbuf_mtophys(m);
-
- rte_memcpy(op->sym->aead.aad.data, params->symmetric_op->aad_data,
- params->session_attrs->aad_len);
-
- rte_memcpy(iv_ptr, params->session_attrs->iv_data,
- params->session_attrs->iv_len);
- if (params->session_attrs->iv_len == 12)
- iv_ptr[15] = 1;
-
- op->sym->aead.data.offset =
- params->session_attrs->aad_len;
- op->sym->aead.data.length = params->symmetric_op->p_len;
-
- op->sym->m_src = m;
-
- return op;
-}
-
-static struct rte_mbuf *
-test_perf_create_pktmbuf_fill(struct rte_mempool *mpool,
- struct perf_test_params *params,
- unsigned buf_sz, struct crypto_params *m_hlp)
-{
- struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
- uint16_t aad_len = params->session_attrs->aad_len;
- uint16_t digest_size = params->symmetric_op->t_len;
- char *p;
-
- p = rte_pktmbuf_append(m, aad_len);
- if (p == NULL) {
- rte_pktmbuf_free(m);
- return NULL;
- }
- m_hlp->aad = (uint8_t *)p;
-
- p = rte_pktmbuf_append(m, buf_sz);
- if (p == NULL) {
- rte_pktmbuf_free(m);
- return NULL;
- }
- rte_memcpy(p, params->symmetric_op->p_data, buf_sz);
-
- p = rte_pktmbuf_append(m, digest_size);
- if (p == NULL) {
- rte_pktmbuf_free(m);
- return NULL;
- }
- m_hlp->digest = (uint8_t *)p;
-
- return m;
-}
-
-static int
-perf_AES_GCM(uint8_t dev_id, uint16_t queue_id,
- struct perf_test_params *pparams, uint32_t test_ops)
-{
- int j = 0;
- struct crypto_testsuite_params *ts_params = &testsuite_params;
- struct rte_cryptodev_sym_session *sess;
- struct rte_crypto_op *ops[pparams->burst_size];
- struct rte_crypto_op *proc_ops[pparams->burst_size];
- uint32_t total_operations = pparams->total_operations;
-
- uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
- uint64_t processed = 0, failed_polls = 0, retries = 0;
- uint64_t tsc_start = 0, tsc_end = 0;
-
- uint16_t i = 0, l = 0, m = 0;
- uint16_t burst = pparams->burst_size * NUM_MBUF_SETS;
- uint16_t ops_unused = 0;
-
- struct rte_mbuf *mbufs[burst];
- struct crypto_params m_hlp[burst];
-
- if (rte_cryptodev_count() == 0) {
- printf("\nNo crypto devices available. "
- "Is kernel driver loaded?\n");
- return TEST_FAILED;
- }
-
- sess = test_perf_create_session(dev_id, pparams);
- TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
-
- for (i = 0; i < burst; i++) {
- mbufs[i] = test_perf_create_pktmbuf_fill(
- ts_params->mbuf_mp,
- pparams, pparams->symmetric_op->p_len,
- &m_hlp[i]);
- }
-
- if (test_ops)
- total_operations = test_ops;
-
- tsc_start = rte_rdtsc_precise();
- while (total_enqueued < total_operations) {
- uint16_t burst_size =
- total_enqueued+pparams->burst_size <= total_operations ?
- pparams->burst_size : total_operations-total_enqueued;
- uint16_t ops_needed = burst_size-ops_unused;
-
- if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
- printf("\nFailed to alloc enough ops, "
- "finish dequeuing");
- } else {
- for (i = 0; i < ops_needed; i++)
- ops[i] = perf_gcm_set_crypto_op(ops[i],
- mbufs[i + (pparams->burst_size *
- (j % NUM_MBUF_SETS))],
- sess, &m_hlp[i + (pparams->burst_size *
- (j % NUM_MBUF_SETS))], pparams);
-
- /* enqueue burst */
- burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
- queue_id, ops, burst_size);
-
- if (burst_enqueued < burst_size)
- retries++;
-
- ops_unused = burst_size-burst_enqueued;
- total_enqueued += burst_enqueued;
- }
-
- /* dequeue burst */
- burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
- proc_ops, pparams->burst_size);
- if (burst_dequeued == 0)
- failed_polls++;
- else {
- processed += burst_dequeued;
-
- for (l = 0; l < burst_dequeued; l++)
- rte_crypto_op_free(proc_ops[l]);
- }
-
- j++;
- }
-
- /* Dequeue any operations still in the crypto device */
- while (processed < total_operations) {
- /* Sending 0 length burst to flush sw crypto device */
- rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
-
- /* dequeue burst */
- burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
- proc_ops, pparams->burst_size);
- if (burst_dequeued == 0)
- failed_polls++;
- else {
- processed += burst_dequeued;
-
- for (m = 0; m < burst_dequeued; m++) {
- if (test_ops) {
- uint8_t *pkt = rte_pktmbuf_mtod(
- proc_ops[m]->sym->m_src,
- uint8_t *);
-
- TEST_ASSERT_BUFFERS_ARE_EQUAL(
- pparams->symmetric_op->c_data,
- pkt +
- pparams->session_attrs->aad_len,
- pparams->symmetric_op->c_len,
- "GCM Ciphertext data not as expected");
-
- TEST_ASSERT_BUFFERS_ARE_EQUAL(
- pparams->symmetric_op->t_data,
- pkt +
- pparams->session_attrs->aad_len +
- pparams->symmetric_op->c_len,
- pparams->symmetric_op->t_len,
- "GCM MAC data not as expected");
-
- }
- rte_crypto_op_free(proc_ops[m]);
- }
- }
- }
-
- tsc_end = rte_rdtsc_precise();
-
- double ops_s = ((double)processed / (tsc_end - tsc_start))
- * rte_get_tsc_hz();
- double throughput = (ops_s * pparams->symmetric_op->p_len * 8)
- / 1000000000;
-
- if (!test_ops) {
- printf("\n%u\t\t%6.2f\t%16.2f\t%8"PRIu64"\t%10"PRIu64,
- pparams->symmetric_op->p_len,
- ops_s/1000000, throughput, retries, failed_polls);
- }
-
- for (i = 0; i < burst; i++)
- rte_pktmbuf_free(mbufs[i]);
-
- rte_cryptodev_sym_session_clear(ts_params->dev_id, sess);
- rte_cryptodev_sym_session_free(sess);
-
- return 0;
-}
-
-static int
-test_perf_AES_GCM(int continual_buf_len, int continual_size)
-{
- uint16_t i, j, k, loops = 1;
-
- uint16_t buf_lengths[] = { 64, 128, 256, 512, 1024, 1536, 2048 };
-
- static const struct cryptodev_perf_test_data *gcm_tests[] = {
- &AES_GCM_128_12IV_0AAD
- };
-
- if (continual_buf_len)
- loops = continual_size;
-
- int TEST_CASES_GCM = RTE_DIM(gcm_tests);
-
- const unsigned burst_size = 32;
-
- struct symmetric_op ops_set[TEST_CASES_GCM];
- struct perf_test_params params_set[TEST_CASES_GCM];
- struct symmetric_session_attrs session_attrs[TEST_CASES_GCM];
- static const struct cryptodev_perf_test_data *gcm_test;
-
- for (i = 0; i < TEST_CASES_GCM; ++i) {
-
- gcm_test = gcm_tests[i];
-
- session_attrs[i].aead =
- RTE_CRYPTO_AEAD_OP_ENCRYPT;
- session_attrs[i].aead_algorithm =
- RTE_CRYPTO_AEAD_AES_GCM;
- session_attrs[i].key_aead_data =
- gcm_test->key.data;
- session_attrs[i].key_aead_len =
- gcm_test->key.len;
- session_attrs[i].aad_len = gcm_test->aad.len;
- session_attrs[i].digest_len =
- gcm_test->auth_tag.len;
- session_attrs[i].iv_len = gcm_test->iv.len;
- session_attrs[i].iv_data = gcm_test->iv.data;
-
- ops_set[i].aad_data = gcm_test->aad.data;
- ops_set[i].p_data = gcm_test->plaintext.data;
- ops_set[i].p_len = buf_lengths[i];
- ops_set[i].c_data = gcm_test->ciphertext.data;
- ops_set[i].c_len = buf_lengths[i];
- ops_set[i].t_data = gcm_test->auth_tags[i].data;
- ops_set[i].t_len = gcm_test->auth_tags[i].len;
-
- params_set[i].chain = AEAD;
- params_set[i].session_attrs = &session_attrs[i];
- params_set[i].symmetric_op = &ops_set[i];
- if (continual_buf_len)
- params_set[i].total_operations = 0xFFFFFF;
- else
- params_set[i].total_operations = 1000000;
-
- params_set[i].burst_size = burst_size;
-
- }
-
- if (continual_buf_len)
- printf("\nCipher algo: %s Cipher hash: %s cipher key size: %ub"
- " burst size: %u", "AES_GCM", "AES_GCM",
- gcm_test->key.len << 3, burst_size);
-
- for (i = 0; i < RTE_DIM(gcm_tests); i++) {
-
- if (!continual_buf_len) {
- printf("\nCipher algo: %s Cipher hash: %s cipher key size: %ub"
- " burst size: %u", "AES_GCM", "AES_GCM",
- gcm_test->key.len << 3, burst_size);
- printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
- " Retries\tEmptyPolls");
- }
-
- uint16_t len = RTE_DIM(buf_lengths);
- uint16_t p = 0;
-
- if (continual_buf_len) {
- for (k = 0; k < RTE_DIM(buf_lengths); k++)
- if (buf_lengths[k] == continual_buf_len) {
- len = k + 1;
- p = k;
- break;
- }
- }
- for (j = p; j < len; ++j) {
-
- params_set[i].symmetric_op->c_len = buf_lengths[j];
- params_set[i].symmetric_op->p_len = buf_lengths[j];
-
- ops_set[i].t_data = gcm_tests[i]->auth_tags[j].data;
- ops_set[i].t_len = gcm_tests[i]->auth_tags[j].len;
-
- /* Run is twice, one for encryption/hash checks,
- * one for perf
- */
- if (perf_AES_GCM(testsuite_params.dev_id, 0,
- ¶ms_set[i], 1))
- return TEST_FAILED;
-
- for (k = 0; k < loops; k++) {
- if (continual_buf_len)
- printf("\n\nBuffer Size(B)\tOPS(M)\t"
- "Throughput(Gbps)\t"
- "Retries\tEmptyPolls");
- if (perf_AES_GCM(testsuite_params.dev_id, 0,
- ¶ms_set[i], 0))
- return TEST_FAILED;
- if (continual_buf_len)
- printf("\n\nCompleted loop %i of %i ...",
- k+1, loops);
- }
- }
-
- }
- printf("\n");
- return 0;
-}
-
-static int test_cryptodev_perf_AES_GCM(void)
-{
- return test_perf_AES_GCM(0, 0);
-}
-/*
- * This function calls AES GCM performance tests providing
- * size of packet as an argument. If size of packet is not
- * in the buf_lengths array, all sizes will be used
- */
-static int test_continual_perf_AES_GCM(void)
-{
- return test_perf_AES_GCM(1024, 10);
-}
-
-static int
-test_perf_continual_performance_test(void)
-{
- unsigned int total_operations = 0xFFFFFF;
- unsigned int total_loops = 10;
- unsigned int burst_size = 32;
- uint8_t i;
-
- struct perf_test_params params_set = {
- .total_operations = total_operations,
- .burst_size = burst_size,
- .buf_size = 1024,
-
- .chain = CIPHER_HASH,
-
- .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
- .key_length = 16,
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
- };
-
- for (i = 1; i <= total_loops; ++i) {
- printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
- " burst_size: %d ops\n",
- chain_mode_name(params_set.chain),
- rte_crypto_cipher_algorithm_strings[params_set.cipher_algo],
- rte_crypto_auth_algorithm_strings[params_set.auth_algo],
- params_set.key_length,
- burst_size);
- printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
- "Retries\tEmptyPolls\n");
- test_perf_aes_sha(testsuite_params.dev_id, 0,
- ¶ms_set);
- printf("\nCompleted loop %i of %i ...", i, total_loops);
- }
- return 0;
-}
-
-static struct unit_test_suite cryptodev_qat_continual_testsuite = {
- .suite_name = "Crypto Device Continual Performance Test",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_perf_continual_performance_test),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_continual_perf_AES_GCM),
- TEST_CASES_END() /**< NULL terminate unit test array */
- }
-};
-
-static struct unit_test_suite cryptodev_testsuite = {
- .suite_name = "Crypto Device Unit Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_cryptodev_perf_AES_GCM),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_perf_aes_cbc_vary_burst_size),
- TEST_CASES_END() /**< NULL terminate unit test array */
- }
-};
-
-static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = {
- .suite_name = "Crypto Device DPAA2_SEC Unit Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
- TEST_CASES_END() /**< NULL terminate unit test array */
- }
-};
-
-static struct unit_test_suite cryptodev_gcm_testsuite = {
- .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_cryptodev_perf_AES_GCM),
- TEST_CASES_END() /**< NULL terminate unit test array */
- }
-};
-
-static struct unit_test_suite cryptodev_aes_testsuite = {
- .suite_name = "Crypto Device AESNI MB Unit Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
- TEST_CASES_END() /**< NULL terminate unit test array */
- }
-};
-
-static struct unit_test_suite cryptodev_snow3g_testsuite = {
- .suite_name = "Crypto Device SNOW3G Unit Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_perf_snow3G_vary_pkt_size),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_perf_snow3G_vary_burst_size),
- TEST_CASES_END() /**< NULL terminate unit test array */
- }
-};
-
-static struct unit_test_suite cryptodev_openssl_testsuite = {
- .suite_name = "Crypto Device OPENSSL Unit Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_perf_openssl_vary_pkt_size),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_perf_openssl_vary_burst_size),
- TEST_CASES_END() /**< NULL terminate unit test array */
- }
-};
-
-static struct unit_test_suite cryptodev_armv8_testsuite = {
- .suite_name = "Crypto Device ARMv8 Unit Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_perf_armv8_vary_pkt_size),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_perf_armv8_vary_burst_size),
- TEST_CASES_END() /**< NULL terminate unit test array */
- }
-};
-
-static int
-perftest_aesni_gcm_cryptodev(void)
-{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded. Check if "
- "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM is enabled "
- "in config file to run this testsuite.\n");
- return TEST_FAILED;
- }
-
- return unit_test_suite_runner(&cryptodev_gcm_testsuite);
-}
-
-static int
-perftest_aesni_mb_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
-{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded. Check if "
- "CONFIG_RTE_LIBRTE_PMD_AESNI_MB is enabled "
- "in config file to run this testsuite.\n");
- return TEST_FAILED;
- }
-
- return unit_test_suite_runner(&cryptodev_aes_testsuite);
-}
-
-static int
-perftest_qat_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
-{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check if "
- "CONFIG_RTE_LIBRTE_PMD_QAT is enabled "
- "in config file to run this testsuite.\n");
- return TEST_FAILED;
- }
-
- return unit_test_suite_runner(&cryptodev_testsuite);
-}
-
-static int
-perftest_sw_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
-{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "SNOW3G PMD must be loaded. Check if "
- "CONFIG_RTE_LIBRTE_PMD_SNOW3G is enabled "
- "in config file to run this testsuite.\n");
- return TEST_FAILED;
- }
-
- return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
-}
-
-static int
-perftest_qat_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
-{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check if "
- "CONFIG_RTE_LIBRTE_PMD_QAT is enabled "
- "in config file to run this testsuite.\n");
- return TEST_FAILED;
- }
-
- return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
-}
-
-static int
-perftest_openssl_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
-{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "OpenSSL PMD must be loaded. Check if "
- "CONFIG_RTE_LIBRTE_PMD_OPENSSL is enabled "
- "in config file to run this testsuite.\n");
- return TEST_FAILED;
- }
-
- return unit_test_suite_runner(&cryptodev_openssl_testsuite);
-}
-
-static int
-perftest_qat_continual_cryptodev(void)
-{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check if "
- "CONFIG_RTE_LIBRTE_PMD_QAT is enabled "
- "in config file to run this testsuite.\n");
- return TEST_FAILED;
- }
-
- return unit_test_suite_runner(&cryptodev_qat_continual_testsuite);
-}
-
-static int
-perftest_sw_armv8_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
-{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "ARMV8 PMD must be loaded. Check if "
- "CONFIG_RTE_LIBRTE_PMD_ARMV8 is enabled "
- "in config file to run this testsuite.\n");
- return TEST_FAILED;
- }
-
- return unit_test_suite_runner(&cryptodev_armv8_testsuite);
-}
-
-static int
-perftest_dpaa2_sec_cryptodev(void)
-{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "DPAA2 SEC PMD must be loaded. Check if "
- "CONFIG_RTE_LIBRTE_PMD_DPAA2_SEC is enabled "
- "in config file to run this testsuite.\n");
- return TEST_FAILED;
- }
-
- return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
-}
-
-REGISTER_TEST_COMMAND(cryptodev_aesni_mb_perftest, perftest_aesni_mb_cryptodev);
-REGISTER_TEST_COMMAND(cryptodev_qat_perftest, perftest_qat_cryptodev);
-REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_perftest, perftest_sw_snow3g_cryptodev);
-REGISTER_TEST_COMMAND(cryptodev_qat_snow3g_perftest, perftest_qat_snow3g_cryptodev);
-REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_perftest, perftest_aesni_gcm_cryptodev);
-REGISTER_TEST_COMMAND(cryptodev_openssl_perftest,
- perftest_openssl_cryptodev);
-REGISTER_TEST_COMMAND(cryptodev_qat_continual_perftest,
- perftest_qat_continual_cryptodev);
-REGISTER_TEST_COMMAND(cryptodev_sw_armv8_perftest,
- perftest_sw_armv8_cryptodev);
-REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_perftest,
- perftest_dpaa2_sec_cryptodev);
--
2.9.4
More information about the dev
mailing list