[dpdk.git] / test / test / test_cryptodev_perf.c

/*-
 *   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;
};

#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 struct rte_cryptodev_sym_session *
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 struct rte_cryptodev_sym_session *
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 struct rte_cryptodev_sym_session *
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, ts_params->sess_mp),
                        "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)),
                                "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_free(ts_params->dev_id,
                                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*/
        ut_params->sess = rte_cryptodev_sym_session_create(ts_params->dev_id,
                &ut_params->cipher_xform);

        TEST_ASSERT_NOT_NULL(ut_params->sess, "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, ut_params->sess);

                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*/
        sess = test_perf_create_snow3g_session(ts_params->dev_id,
                        pparams->chain, pparams->cipher_algo,
                        pparams->key_length, pparams->auth_algo);
        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_free(ts_params->dev_id, 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(&params_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*/
        sess = test_perf_create_openssl_session(ts_params->dev_id,
                        pparams->chain, pparams->cipher_algo,
                        pparams->key_length, pparams->auth_algo,
                        pparams->aead_algo);
        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_free(ts_params->dev_id, 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*/
        sess = test_perf_create_armv8_session(ts_params->dev_id,
                        pparams->chain, pparams->cipher_algo,
                        pparams->key_length, pparams->auth_algo);
        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_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 struct rte_cryptodev_sym_session *
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 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);
        }
        switch (chain) {
        case CIPHER_HASH:
                cipher_xform.next = &auth_xform;
                auth_xform.next = NULL;
                /* Create Crypto session*/
                return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
        case HASH_CIPHER:
                auth_xform.next = &cipher_xform;
                cipher_xform.next = NULL;
                /* Create Crypto session*/
                return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
        case CIPHER_ONLY:
                cipher_xform.next = NULL;
                /* Create Crypto session*/
                return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
        default:
                return NULL;
        }
}

#define SNOW3G_CIPHER_IV_LENGTH 16

static struct rte_cryptodev_sym_session *
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 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;

        switch (chain) {
        case CIPHER_HASH:
                cipher_xform.next = &auth_xform;
                auth_xform.next = NULL;
                /* Create Crypto session*/
                return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
        case HASH_CIPHER:
                auth_xform.next = &cipher_xform;
                cipher_xform.next = NULL;
                /* Create Crypto session*/
                return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
        case CIPHER_ONLY:
                cipher_xform.next = NULL;
                /* Create Crypto session*/
                return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
        case HASH_ONLY:
                auth_xform.next = NULL;
                /* Create Crypto session */
                return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
        default:
                return NULL;
        }
}

static struct rte_cryptodev_sym_session *
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 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 NULL;
                }

                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 NULL;
                }

                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.add_auth_data_length = AES_GCM_AAD_LENGTH;
                        aead_xform.aead.digest_length = get_aead_digest_length(aead_algo);
                        break;
                default:
                        return NULL;
                }

                aead_xform.aead.key.length = key_len;
        }

        switch (chain) {
        case CIPHER_HASH:
                cipher_xform.next = &auth_xform;
                auth_xform.next = NULL;
                /* Create Crypto session*/
                return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
        case HASH_CIPHER:
                auth_xform.next = &cipher_xform;
                cipher_xform.next = NULL;
                /* Create Crypto session*/
                return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
        case AEAD:
                /* Create Crypto session*/
                return rte_cryptodev_sym_session_create(dev_id, &aead_xform);
        default:
                return NULL;
        }
}

static struct rte_cryptodev_sym_session *
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 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 NULL;
        }

        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);

        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_create(dev_id, &cipher_xform);
        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_create(dev_id, &auth_xform);
        default:
                return NULL;
        }
}

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*/
        sess = test_perf_create_aes_sha_session(ts_params->dev_id,
                        pparams->chain, pparams->cipher_algo,
                        pparams->key_length, pparams->auth_algo);
        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_free(dev_id, 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*/
        sess = test_perf_create_snow3g_session(ts_params->dev_id,
                        pparams->chain, pparams->cipher_algo,
                        pparams->key_length, pparams->auth_algo);
        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_free(dev_id, 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*/
        sess = test_perf_create_openssl_session(ts_params->dev_id,
                        pparams->chain, pparams->cipher_algo,
                        pparams->key_length, pparams->auth_algo,
                        pparams->aead_algo);
        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_free(dev_id, 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*/
        sess = test_perf_create_armv8_session(ts_params->dev_id,
                        pparams->chain, pparams->cipher_algo,
                        pparams->key_length, pparams->auth_algo);
        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,
                                        &params_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, &params_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,
                                        &params_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(&params_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,
                                                        &params_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(&params_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)
{
        static struct rte_cryptodev_sym_session *sess;
        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.add_auth_data_length = pparams->session_attrs->aad_len;
        aead_xform.aead.digest_length = pparams->session_attrs->digest_len;

        sess = rte_cryptodev_sym_session_create(dev_id, &aead_xform);

        return sess;
}

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_free(dev_id, 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,
                                        &params_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,
                                                &params_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,
                                        &params_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);