4 * Copyright(c) 2015-2017 Intel Corporation. All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * * Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in
14 * the documentation and/or other materials provided with the
16 * * Neither the name of Intel Corporation nor the names of its
17 * contributors may be used to endorse or promote products derived
18 * from this software without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 #include <rte_common.h>
35 #include <rte_malloc.h>
36 #include <rte_memcpy.h>
38 #include <rte_crypto.h>
39 #include <rte_cryptodev.h>
40 #include <rte_cycles.h>
43 #include "test_cryptodev.h"
44 #include "test_cryptodev_gcm_test_vectors.h"
46 #define AES_CIPHER_IV_LENGTH 16
47 #define TRIPLE_DES_CIPHER_IV_LENGTH 8
48 #define AES_GCM_AAD_LENGTH 16
50 #define PERF_NUM_OPS_INFLIGHT (128)
51 #define DEFAULT_NUM_REQS_TO_SUBMIT (10000000)
53 struct crypto_testsuite_params {
54 struct rte_mempool *mbuf_mp;
55 struct rte_mempool *op_mpool;
56 struct rte_mempool *sess_mp;
58 uint16_t nb_queue_pairs;
60 struct rte_cryptodev_config conf;
61 struct rte_cryptodev_qp_conf qp_conf;
75 const uint8_t *aad_data;
77 const uint8_t *p_data;
80 const uint8_t *c_data;
83 const uint8_t *t_data;
88 struct symmetric_session_attrs {
89 enum rte_crypto_cipher_operation cipher;
90 enum rte_crypto_auth_operation auth;
91 enum rte_crypto_aead_operation aead;
93 enum rte_crypto_cipher_algorithm cipher_algorithm;
94 const uint8_t *key_cipher_data;
95 uint32_t key_cipher_len;
97 enum rte_crypto_auth_algorithm auth_algorithm;
98 const uint8_t *key_auth_data;
99 uint32_t key_auth_len;
101 enum rte_crypto_aead_algorithm aead_algorithm;
102 const uint8_t *key_aead_data;
103 uint32_t key_aead_len;
105 const uint8_t *iv_data;
111 static struct rte_cryptodev_sym_session *test_crypto_session;
113 #define ALIGN_POW2_ROUNDUP(num, align) \
114 (((num) + (align) - 1) & ~((align) - 1))
117 * This struct is needed to avoid unnecessary allocation or checking
118 * of allocation of crypto params with current alloc on the fly
122 struct crypto_params {
127 struct perf_test_params {
129 unsigned total_operations;
133 enum chain_mode chain;
135 enum rte_crypto_cipher_algorithm cipher_algo;
136 unsigned int key_length;
137 enum rte_crypto_auth_algorithm auth_algo;
138 enum rte_crypto_aead_algorithm aead_algo;
140 struct symmetric_session_attrs *session_attrs;
142 struct symmetric_op *symmetric_op;
145 #define MAX_NUM_OF_OPS_PER_UT (128)
147 struct crypto_unittest_params {
148 struct rte_crypto_sym_xform cipher_xform;
149 struct rte_crypto_sym_xform auth_xform;
151 struct rte_cryptodev_sym_session *sess;
153 struct rte_crypto_op *op;
155 struct rte_mbuf *obuf[MAX_NUM_OF_OPS_PER_UT];
156 struct rte_mbuf *ibuf[MAX_NUM_OF_OPS_PER_UT];
162 test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
163 enum rte_crypto_cipher_algorithm cipher_algo,
164 unsigned int cipher_key_len,
165 enum rte_crypto_auth_algorithm auth_algo);
167 test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain,
168 enum rte_crypto_cipher_algorithm cipher_algo,
169 unsigned int cipher_key_len,
170 enum rte_crypto_auth_algorithm auth_algo,
171 enum rte_crypto_aead_algorithm aead_algo);
173 test_perf_create_armv8_session(uint8_t dev_id, enum chain_mode chain,
174 enum rte_crypto_cipher_algorithm cipher_algo,
175 unsigned int cipher_key_len,
176 enum rte_crypto_auth_algorithm auth_algo);
178 static struct rte_mbuf *
179 test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz);
180 static inline struct rte_crypto_op *
181 test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
182 struct rte_cryptodev_sym_session *sess, unsigned int data_len);
183 static inline struct rte_crypto_op *
184 test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m,
185 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
186 enum chain_mode chain);
187 static inline struct rte_crypto_op *
188 test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
189 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
190 enum chain_mode chain __rte_unused);
191 static inline struct rte_crypto_op *
192 test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
193 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
194 enum chain_mode chain __rte_unused);
195 static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo);
198 static const char *chain_mode_name(enum chain_mode mode)
201 case CIPHER_HASH: return "cipher_hash"; break;
202 case HASH_CIPHER: return "hash_cipher"; break;
203 case CIPHER_ONLY: return "cipher_only"; break;
204 case HASH_ONLY: return "hash_only"; break;
205 case AEAD: return "aead"; break;
206 default: return ""; break;
210 static const char *pmd_name(uint8_t driver_id)
212 uint8_t null_pmd = rte_cryptodev_driver_id_get(
213 RTE_STR(CRYPTODEV_NAME_NULL_PMD));
214 uint8_t dpaa2_pmd = rte_cryptodev_driver_id_get(
215 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
216 uint8_t snow3g_pmd = rte_cryptodev_driver_id_get(
217 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
218 uint8_t aesni_gcm_pmd = rte_cryptodev_driver_id_get(
219 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
220 uint8_t aesni_mb_pmd = rte_cryptodev_driver_id_get(
221 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
222 uint8_t qat_pmd = rte_cryptodev_driver_id_get(
223 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
225 if (driver_id == null_pmd)
226 return RTE_STR(CRYPTODEV_NAME_NULL_PMD);
227 else if (driver_id == aesni_gcm_pmd)
228 return RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD);
229 else if (driver_id == aesni_mb_pmd)
230 return RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD);
231 else if (driver_id == qat_pmd)
232 return RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
233 else if (driver_id == snow3g_pmd)
234 return RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD);
235 else if (driver_id == dpaa2_pmd)
236 return RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
241 static struct rte_mbuf *
242 setup_test_string(struct rte_mempool *mpool,
243 const uint8_t *data, size_t len, uint8_t blocksize)
245 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
246 size_t t_len = len - (blocksize ? (len % blocksize) : 0);
249 char *dst = rte_pktmbuf_append(m, t_len);
256 rte_memcpy(dst, (const void *)data, t_len);
261 static struct crypto_testsuite_params testsuite_params = { NULL };
262 static struct crypto_unittest_params unittest_params;
263 static int gbl_driver_id;
266 testsuite_setup(void)
268 struct crypto_testsuite_params *ts_params = &testsuite_params;
269 struct rte_cryptodev_info info;
270 unsigned i, nb_devs, valid_dev_id = 0;
274 ts_params->mbuf_mp = rte_mempool_lookup("CRYPTO_PERF_MBUFPOOL");
275 if (ts_params->mbuf_mp == NULL) {
276 /* Not already created so create */
277 ts_params->mbuf_mp = rte_pktmbuf_pool_create(
278 "CRYPTO_PERF_MBUFPOOL",
279 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
281 if (ts_params->mbuf_mp == NULL) {
282 RTE_LOG(ERR, USER1, "Can't create CRYPTO_PERF_MBUFPOOL\n");
288 ts_params->op_mpool = rte_crypto_op_pool_create("CRYPTO_OP_POOL",
289 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
290 NUM_MBUFS, MBUF_CACHE_SIZE,
292 sizeof(struct rte_crypto_sym_xform) +
295 if (ts_params->op_mpool == NULL) {
296 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
300 /* Create an AESNI MB device if required */
301 if (gbl_driver_id == rte_cryptodev_driver_id_get(
302 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) {
303 nb_devs = rte_cryptodev_device_count_by_driver(
304 rte_cryptodev_driver_id_get(
305 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
308 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
310 TEST_ASSERT(ret == 0,
311 "Failed to create instance of pmd : %s",
312 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
316 /* Create an AESNI GCM device if required */
317 if (gbl_driver_id == rte_cryptodev_driver_id_get(
318 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD))) {
319 nb_devs = rte_cryptodev_device_count_by_driver(
320 rte_cryptodev_driver_id_get(
321 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)));
324 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL);
326 TEST_ASSERT(ret == 0,
327 "Failed to create instance of pmd : %s",
328 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
332 /* Create a SNOW3G device if required */
333 if (gbl_driver_id == rte_cryptodev_driver_id_get(
334 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD))) {
335 nb_devs = rte_cryptodev_device_count_by_driver(
336 rte_cryptodev_driver_id_get(
337 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD)));
340 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL);
342 TEST_ASSERT(ret == 0,
343 "Failed to create instance of pmd : %s",
344 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
348 /* Create an OPENSSL device if required */
349 if (gbl_driver_id == rte_cryptodev_driver_id_get(
350 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))) {
351 nb_devs = rte_cryptodev_device_count_by_driver(
352 rte_cryptodev_driver_id_get(
353 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)));
356 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
359 TEST_ASSERT(ret == 0, "Failed to create "
360 "instance of pmd : %s",
361 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
365 /* Create an ARMv8 device if required */
366 if (gbl_driver_id == rte_cryptodev_driver_id_get(
367 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD))) {
368 nb_devs = rte_cryptodev_device_count_by_driver(
369 rte_cryptodev_driver_id_get(
370 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)));
373 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
376 TEST_ASSERT(ret == 0, "Failed to create "
377 "instance of pmd : %s",
378 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
382 nb_devs = rte_cryptodev_count();
384 RTE_LOG(ERR, USER1, "No crypto devices found?\n");
388 /* Search for the first valid */
389 for (i = 0; i < nb_devs; i++) {
390 rte_cryptodev_info_get(i, &info);
391 if (info.driver_id == (uint8_t) gbl_driver_id) {
392 ts_params->dev_id = i;
402 * Using Crypto Device Id 0 by default.
403 * Set up all the qps on this device
406 rte_cryptodev_info_get(ts_params->dev_id, &info);
408 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
409 ts_params->conf.socket_id = SOCKET_ID_ANY;
411 unsigned int session_size = sizeof(struct rte_cryptodev_sym_session) +
412 rte_cryptodev_get_private_session_size(ts_params->dev_id);
414 ts_params->sess_mp = rte_mempool_create(
416 info.sym.max_nb_sessions,
418 0, 0, NULL, NULL, NULL,
422 TEST_ASSERT_NOT_NULL(ts_params->sess_mp,
423 "session mempool allocation failed");
425 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->dev_id,
427 "Failed to configure cryptodev %u",
430 ts_params->qp_conf.nb_descriptors = PERF_NUM_OPS_INFLIGHT;
431 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
433 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
434 ts_params->dev_id, qp_id,
436 rte_cryptodev_socket_id(ts_params->dev_id),
438 "Failed to setup queue pair %u on cryptodev %u",
439 qp_id, ts_params->dev_id);
445 testsuite_teardown(void)
447 struct crypto_testsuite_params *ts_params =
450 if (ts_params->mbuf_mp != NULL)
451 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_MBUFPOOL count %u\n",
452 rte_mempool_avail_count(ts_params->mbuf_mp));
453 if (ts_params->op_mpool != NULL)
454 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_OP POOL count %u\n",
455 rte_mempool_avail_count(ts_params->op_mpool));
456 /* Free session mempool */
457 if (ts_params->sess_mp != NULL) {
458 rte_mempool_free(ts_params->sess_mp);
459 ts_params->sess_mp = NULL;
467 struct crypto_testsuite_params *ts_params = &testsuite_params;
468 struct crypto_unittest_params *ut_params = &unittest_params;
470 /* Clear unit test parameters before running test */
471 memset(ut_params, 0, sizeof(*ut_params));
473 rte_cryptodev_stats_reset(ts_params->dev_id);
475 /* Start the device */
476 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->dev_id),
477 "Failed to start cryptodev %u",
486 struct crypto_testsuite_params *ts_params = &testsuite_params;
487 struct crypto_unittest_params *ut_params = &unittest_params;
488 struct rte_cryptodev_stats stats;
492 /* free crypto session structure */
493 if (ut_params->sess) {
494 rte_cryptodev_sym_session_clear(ts_params->dev_id,
496 rte_cryptodev_sym_session_free(ut_params->sess);
499 /* free crypto operation structure */
501 rte_crypto_op_free(ut_params->op);
503 for (i = 0; i < MAX_NUM_OF_OPS_PER_UT; i++) {
504 if (ut_params->obuf[i])
505 rte_pktmbuf_free(ut_params->obuf[i]);
506 else if (ut_params->ibuf[i])
507 rte_pktmbuf_free(ut_params->ibuf[i]);
510 if (ts_params->mbuf_mp != NULL)
511 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_MBUFPOOL count %u\n",
512 rte_mempool_avail_count(ts_params->mbuf_mp));
514 rte_cryptodev_stats_get(ts_params->dev_id, &stats);
516 /* Stop the device */
517 rte_cryptodev_stop(ts_params->dev_id);
520 const char plaintext_quote[] =
521 "THE COUNT OF MONTE CRISTO by Alexandre Dumas, Pere Chapter 1. "
522 "Marseilles--The Arrival. On the 24th of February, 1815, the "
523 "look-out at Notre-Dame de la Garde signalled the three-master,"
524 " the Pharaon from Smyrna, Trieste, and Naples. As usual, a "
525 "pilot put off immediately, and rounding the Chateau d'If, got "
526 "on board the vessel between Cape Morgion and Rion island. "
527 "Immediately, and according to custom, the ramparts of Fort "
528 "Saint-Jean were covered with spectators; it is always an event "
529 "at Marseilles for a ship to come into port, especially when "
530 "this ship, like the Pharaon, has been built, rigged, and laden"
531 " at the old Phocee docks, and belongs to an owner of the city."
532 " The ship drew on and had safely passed the strait, which some"
533 " volcanic shock has made between the Calasareigne and Jaros "
534 "islands; had doubled Pomegue, and approached the harbor under"
535 " topsails, jib, and spanker, but so slowly and sedately that"
536 " the idlers, with that instinct which is the forerunner of "
537 "evil, asked one another what misfortune could have happened "
538 "on board. However, those experienced in navigation saw plainly"
539 " that if any accident had occurred, it was not to the vessel "
540 "herself, for she bore down with all the evidence of being "
541 "skilfully handled, the anchor a-cockbill, the jib-boom guys "
542 "already eased off, and standing by the side of the pilot, who"
543 " was steering the Pharaon towards the narrow entrance of the"
544 " inner port, was a young man, who, with activity and vigilant"
545 " eye, watched every motion of the ship, and repeated each "
546 "direction of the pilot. The vague disquietude which prevailed "
547 "among the spectators had so much affected one of the crowd "
548 "that he did not await the arrival of the vessel in harbor, but"
549 " jumping into a small skiff, desired to be pulled alongside "
550 "the Pharaon, which he reached as she rounded into La Reserve "
551 "basin. When the young man on board saw this person approach, "
552 "he left his station by the pilot, and, hat in hand, leaned "
553 "over the ship's bulwarks. He was a fine, tall, slim young "
554 "fellow of eighteen or twenty, with black eyes, and hair as "
555 "dark as a raven's wing; and his whole appearance bespoke that "
556 "calmness and resolution peculiar to men accustomed from their "
557 "cradle to contend with danger. \"Ah, is it you, Dantes?\" "
558 "cried the man in the skiff. \"What's the matter? and why have "
559 "you such an air of sadness aboard?\" \"A great misfortune, M. "
560 "Morrel,\" replied the young man,--\"a great misfortune, for me"
561 " especially! Off Civita Vecchia we lost our brave Captain "
562 "Leclere.\" \"And the cargo?\" inquired the owner, eagerly. "
563 "\"Is all safe, M. Morrel; and I think you will be satisfied on"
564 " that head. But poor Captain Leclere--\" \"What happened to "
565 "him?\" asked the owner, with an air of considerable "
566 "resignation. \"What happened to the worthy captain?\" \"He "
567 "died.\" \"Fell into the sea?\" \"No, sir, he died of "
568 "brain-fever in dreadful agony.\" Then turning to the crew, "
569 "he said, \"Bear a hand there, to take in sail!\" All hands "
570 "obeyed, and at once the eight or ten seamen who composed the "
571 "crew, sprang to their respective stations at the spanker "
572 "brails and outhaul, topsail sheets and halyards, the jib "
573 "downhaul, and the topsail clewlines and buntlines. The young "
574 "sailor gave a look to see that his orders were promptly and "
575 "accurately obeyed, and then turned again to the owner. \"And "
576 "how did this misfortune occur?\" inquired the latter, resuming"
577 " the interrupted conversation. \"Alas, sir, in the most "
578 "unexpected manner. After a long talk with the harbor-master, "
579 "Captain Leclere left Naples greatly disturbed in mind. In "
580 "twenty-four hours he was attacked by a fever, and died three "
581 "days afterwards. We performed the usual burial service, and he"
582 " is at his rest, sewn up in his hammock with a thirty-six "
583 "pound shot at his head and his heels, off El Giglio island. "
584 "We bring to his widow his sword and cross of honor. It was "
585 "worth while, truly,\" added the young man with a melancholy "
586 "smile, \"to make war against the English for ten years, and "
587 "to die in his bed at last, like everybody else.";
589 #define QUOTE_LEN_64B (64)
590 #define QUOTE_LEN_128B (128)
591 #define QUOTE_LEN_256B (256)
592 #define QUOTE_LEN_512B (512)
593 #define QUOTE_LEN_768B (768)
594 #define QUOTE_LEN_1024B (1024)
595 #define QUOTE_LEN_1280B (1280)
596 #define QUOTE_LEN_1536B (1536)
597 #define QUOTE_LEN_1792B (1792)
598 #define QUOTE_LEN_2048B (2048)
601 /* ***** AES-CBC / HMAC-SHA256 Performance Tests ***** */
603 #define HMAC_KEY_LENGTH_SHA256 (DIGEST_BYTE_LENGTH_SHA256)
605 #define CIPHER_KEY_LENGTH_AES_CBC (16)
606 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC)
608 static uint8_t aes_cbc_128_key[] = {
609 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
610 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA };
612 static uint8_t aes_cbc_128_iv[] = {
613 0xf5, 0xd3, 0x89, 0x0f, 0x47, 0x00, 0xcb, 0x52,
614 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1 };
616 static uint8_t hmac_sha256_key[] = {
617 0xff, 0xcb, 0x37, 0x30, 0x1d, 0x4a, 0xc2, 0x41,
618 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
619 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
620 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60 };
623 /* Cipher text output */
625 static const uint8_t AES_CBC_ciphertext_64B[] = {
626 0x05, 0x15, 0x77, 0x32, 0xc9, 0x66, 0x91, 0x50,
627 0x93, 0x9f, 0xbb, 0x4e, 0x2e, 0x5a, 0x02, 0xd0,
628 0x2d, 0x9d, 0x31, 0x5d, 0xc8, 0x9e, 0x86, 0x36,
629 0x54, 0x5c, 0x50, 0xe8, 0x75, 0x54, 0x74, 0x5e,
630 0xd5, 0xa2, 0x84, 0x21, 0x2d, 0xc5, 0xf8, 0x1c,
631 0x55, 0x1a, 0xba, 0x91, 0xce, 0xb5, 0xa3, 0x1e,
632 0x31, 0xbf, 0xe9, 0xa1, 0x97, 0x5c, 0x2b, 0xd6,
633 0x57, 0xa5, 0x9f, 0xab, 0xbd, 0xb0, 0x9b, 0x9c
636 static const uint8_t AES_CBC_ciphertext_128B[] = {
637 0x79, 0x92, 0x65, 0xc8, 0xfb, 0x0a, 0xc7, 0xc4,
638 0x9b, 0x3b, 0xbe, 0x69, 0x7f, 0x7c, 0xf4, 0x4e,
639 0xa5, 0x0d, 0xf6, 0x33, 0xc4, 0xdf, 0xf3, 0x0d,
640 0xdb, 0xb9, 0x68, 0x34, 0xb0, 0x0d, 0xbd, 0xb9,
641 0xa7, 0xf3, 0x86, 0x50, 0x2a, 0xbe, 0x50, 0x5d,
642 0xb3, 0xbe, 0x72, 0xf9, 0x02, 0xb1, 0x69, 0x0b,
643 0x8c, 0x96, 0x4c, 0x3c, 0x0c, 0x1e, 0x76, 0xe5,
644 0x7e, 0x75, 0xdd, 0xd0, 0xa9, 0x75, 0x00, 0x13,
645 0x6b, 0x1e, 0xc0, 0xad, 0xfc, 0x03, 0xb5, 0x99,
646 0xdc, 0x37, 0x35, 0xfc, 0x16, 0x34, 0xfd, 0xb4,
647 0xea, 0x1e, 0xb6, 0x51, 0xdf, 0xab, 0x87, 0xd6,
648 0x87, 0x41, 0xfa, 0x1c, 0xc6, 0x78, 0xa6, 0x3c,
649 0x1d, 0x76, 0xfe, 0xff, 0x65, 0xfc, 0x63, 0x1e,
650 0x1f, 0xe2, 0x7c, 0x9b, 0xa2, 0x72, 0xc3, 0x34,
651 0x23, 0xdf, 0x01, 0xf0, 0xfd, 0x02, 0x8b, 0x97,
652 0x00, 0x2b, 0x97, 0x4e, 0xab, 0x98, 0x21, 0x3c
655 static const uint8_t AES_CBC_ciphertext_256B[] = {
656 0xc7, 0x71, 0x2b, 0xed, 0x2c, 0x97, 0x59, 0xfa,
657 0xcf, 0x5a, 0xb9, 0x31, 0x92, 0xe0, 0xc9, 0x92,
658 0xc0, 0x2d, 0xd5, 0x9c, 0x84, 0xbf, 0x70, 0x36,
659 0x13, 0x48, 0xe0, 0xb1, 0xbf, 0x6c, 0xcd, 0x91,
660 0xa0, 0xc3, 0x57, 0x6c, 0x3f, 0x0e, 0x34, 0x41,
661 0xe7, 0x9c, 0xc0, 0xec, 0x18, 0x0c, 0x05, 0x52,
662 0x78, 0xe2, 0x3c, 0x6e, 0xdf, 0xa5, 0x49, 0xc7,
663 0xf2, 0x55, 0x00, 0x8f, 0x65, 0x6d, 0x4b, 0xd0,
664 0xcb, 0xd4, 0xd2, 0x0b, 0xea, 0xf4, 0xb0, 0x85,
665 0x61, 0x9e, 0x36, 0xc0, 0x71, 0xb7, 0x80, 0xad,
666 0x40, 0x78, 0xb4, 0x70, 0x2b, 0xe8, 0x80, 0xc5,
667 0x19, 0x35, 0x96, 0x55, 0x3b, 0x40, 0x03, 0xbb,
668 0x9f, 0xa6, 0xc2, 0x82, 0x92, 0x04, 0xc3, 0xa6,
669 0x96, 0xc4, 0x7f, 0x4c, 0x3e, 0x3c, 0x79, 0x82,
670 0x88, 0x8b, 0x3f, 0x8b, 0xc5, 0x9f, 0x44, 0xbe,
671 0x71, 0xe7, 0x09, 0xa2, 0x40, 0xa2, 0x23, 0x4e,
672 0x9f, 0x31, 0xab, 0x6f, 0xdf, 0x59, 0x40, 0xe1,
673 0x12, 0x15, 0x55, 0x4b, 0xea, 0x3f, 0xa1, 0x41,
674 0x4f, 0xaf, 0xcd, 0x27, 0x2a, 0x61, 0xa1, 0x9e,
675 0x82, 0x30, 0x05, 0x05, 0x55, 0xce, 0x99, 0xd3,
676 0x8f, 0x3f, 0x86, 0x79, 0xdc, 0x9f, 0x33, 0x07,
677 0x75, 0x26, 0xc8, 0x72, 0x81, 0x0f, 0x9b, 0xf7,
678 0xb1, 0xfb, 0xd3, 0x91, 0x36, 0x08, 0xab, 0x26,
679 0x70, 0x53, 0x0c, 0x99, 0xfd, 0xa9, 0x07, 0xb4,
680 0xe9, 0xce, 0xc1, 0xd6, 0xd2, 0x2c, 0x71, 0x80,
681 0xec, 0x59, 0x61, 0x0b, 0x24, 0xf0, 0x6d, 0x33,
682 0x73, 0x45, 0x6e, 0x80, 0x03, 0x45, 0xf2, 0x76,
683 0xa5, 0x8a, 0xc9, 0xcf, 0xaf, 0x4a, 0xed, 0x35,
684 0xc0, 0x97, 0x52, 0xc5, 0x00, 0xdf, 0xef, 0xc7,
685 0x9f, 0xf2, 0xe8, 0x15, 0x3e, 0xb3, 0x30, 0xe7,
686 0x00, 0xd0, 0x4e, 0xeb, 0x79, 0xf6, 0xf6, 0xcf,
687 0xf0, 0xe7, 0x61, 0xd5, 0x3d, 0x6a, 0x73, 0x9d
690 static const uint8_t AES_CBC_ciphertext_512B[] = {
691 0xb4, 0xc6, 0xc6, 0x5f, 0x7e, 0xca, 0x05, 0x70,
692 0x21, 0x7b, 0x92, 0x9e, 0x23, 0xe7, 0x92, 0xb8,
693 0x27, 0x3d, 0x20, 0x29, 0x57, 0xfa, 0x1f, 0x26,
694 0x0a, 0x04, 0x34, 0xa6, 0xf2, 0xdc, 0x44, 0xb6,
695 0x43, 0x40, 0x62, 0xde, 0x0c, 0xde, 0x1c, 0x30,
696 0x43, 0x85, 0x0b, 0xe8, 0x93, 0x1f, 0xa1, 0x2a,
697 0x8a, 0x27, 0x35, 0x39, 0x14, 0x9f, 0x37, 0x64,
698 0x59, 0xb5, 0x0e, 0x96, 0x82, 0x5d, 0x63, 0x45,
699 0xd6, 0x93, 0x89, 0x46, 0xe4, 0x71, 0x31, 0xeb,
700 0x0e, 0xd1, 0x7b, 0xda, 0x90, 0xb5, 0x81, 0xac,
701 0x76, 0x54, 0x54, 0x85, 0x0b, 0xa9, 0x46, 0x9c,
702 0xf0, 0xfd, 0xde, 0x5d, 0xa8, 0xe3, 0xee, 0xe9,
703 0xf4, 0x9d, 0x34, 0x76, 0x39, 0xe7, 0xc3, 0x4a,
704 0x84, 0x38, 0x92, 0x61, 0xf1, 0x12, 0x9f, 0x05,
705 0xda, 0xdb, 0xc1, 0xd4, 0xb0, 0xa0, 0x27, 0x19,
706 0xa0, 0x56, 0x5d, 0x9b, 0xcc, 0x47, 0x7c, 0x15,
707 0x1d, 0x52, 0x66, 0xd5, 0xff, 0xef, 0x12, 0x23,
708 0x86, 0xe2, 0xee, 0x81, 0x2c, 0x3d, 0x7d, 0x28,
709 0xd5, 0x42, 0xdf, 0xdb, 0x75, 0x1c, 0xeb, 0xdf,
710 0x13, 0x23, 0xd5, 0x17, 0x89, 0xea, 0xd7, 0x01,
711 0xff, 0x57, 0x6a, 0x44, 0x61, 0xf4, 0xea, 0xbe,
712 0x97, 0x9b, 0xc2, 0xb1, 0x9c, 0x5d, 0xff, 0x4f,
713 0x73, 0x2d, 0x3f, 0x57, 0x28, 0x38, 0xbf, 0x3d,
714 0x9f, 0xda, 0x49, 0x55, 0x8f, 0xb2, 0x77, 0xec,
715 0x0f, 0xbc, 0xce, 0xb8, 0xc6, 0xe1, 0x03, 0xed,
716 0x35, 0x9c, 0xf2, 0x4d, 0xa4, 0x29, 0x6c, 0xd6,
717 0x6e, 0x05, 0x53, 0x46, 0xc1, 0x41, 0x09, 0x36,
718 0x0b, 0x7d, 0xf4, 0x9e, 0x0f, 0xba, 0x86, 0x33,
719 0xdd, 0xf1, 0xa7, 0xf7, 0xd5, 0x29, 0xa8, 0xa7,
720 0x4d, 0xce, 0x0c, 0xf5, 0xb4, 0x6c, 0xd8, 0x27,
721 0xb0, 0x87, 0x2a, 0x6f, 0x7f, 0x3f, 0x8f, 0xc3,
722 0xe2, 0x3e, 0x94, 0xcf, 0x61, 0x4a, 0x09, 0x3d,
723 0xf9, 0x55, 0x19, 0x31, 0xf2, 0xd2, 0x4a, 0x3e,
724 0xc1, 0xf5, 0xed, 0x7c, 0x45, 0xb0, 0x0c, 0x7b,
725 0xdd, 0xa6, 0x0a, 0x26, 0x66, 0xec, 0x85, 0x49,
726 0x00, 0x38, 0x05, 0x7c, 0x9c, 0x1c, 0x92, 0xf5,
727 0xf7, 0xdb, 0x5d, 0xbd, 0x61, 0x0c, 0xc9, 0xaf,
728 0xfd, 0x57, 0x3f, 0xee, 0x2b, 0xad, 0x73, 0xef,
729 0xa3, 0xc1, 0x66, 0x26, 0x44, 0x5e, 0xf9, 0x12,
730 0x86, 0x66, 0xa9, 0x61, 0x75, 0xa1, 0xbc, 0x40,
731 0x7f, 0xa8, 0x08, 0x02, 0xc0, 0x76, 0x0e, 0x76,
732 0xb3, 0x26, 0x3d, 0x1c, 0x40, 0x65, 0xe4, 0x18,
733 0x0f, 0x62, 0x17, 0x8f, 0x1e, 0x61, 0xb8, 0x08,
734 0x83, 0x54, 0x42, 0x11, 0x03, 0x30, 0x8e, 0xb7,
735 0xc1, 0x9c, 0xec, 0x69, 0x52, 0x95, 0xfb, 0x7b,
736 0x1a, 0x0c, 0x20, 0x24, 0xf7, 0xb8, 0x38, 0x0c,
737 0xb8, 0x7b, 0xb6, 0x69, 0x70, 0xd0, 0x61, 0xb9,
738 0x70, 0x06, 0xc2, 0x5b, 0x20, 0x47, 0xf7, 0xd9,
739 0x32, 0xc2, 0xf2, 0x90, 0xb6, 0x4d, 0xcd, 0x3c,
740 0x6d, 0x74, 0xea, 0x82, 0x35, 0x1b, 0x08, 0x44,
741 0xba, 0xb7, 0x33, 0x82, 0x33, 0x27, 0x54, 0x77,
742 0x6e, 0x58, 0xfe, 0x46, 0x5a, 0xb4, 0x88, 0x53,
743 0x8d, 0x9b, 0xb1, 0xab, 0xdf, 0x04, 0xe1, 0xfb,
744 0xd7, 0x1e, 0xd7, 0x38, 0x64, 0x54, 0xba, 0xb0,
745 0x6c, 0x84, 0x7a, 0x0f, 0xa7, 0x80, 0x6b, 0x86,
746 0xd9, 0xc9, 0xc6, 0x31, 0x95, 0xfa, 0x8a, 0x2c,
747 0x14, 0xe1, 0x85, 0x66, 0x27, 0xfd, 0x63, 0x3e,
748 0xf0, 0xfa, 0x81, 0xc9, 0x89, 0x4f, 0xe2, 0x6a,
749 0x8c, 0x17, 0xb5, 0xc7, 0x9f, 0x5d, 0x3f, 0x6b,
750 0x3f, 0xcd, 0x13, 0x7a, 0x3c, 0xe6, 0x4e, 0xfa,
751 0x7a, 0x10, 0xb8, 0x7c, 0x40, 0xec, 0x93, 0x11,
752 0x1f, 0xd0, 0x9e, 0xc3, 0x56, 0xb9, 0xf5, 0x21,
753 0x18, 0x41, 0x31, 0xea, 0x01, 0x8d, 0xea, 0x1c,
754 0x95, 0x5e, 0x56, 0x33, 0xbc, 0x7a, 0x3f, 0x6f
757 static const uint8_t AES_CBC_ciphertext_768B[] = {
758 0x3e, 0x7f, 0x9e, 0x4c, 0x88, 0x15, 0x68, 0x69,
759 0x10, 0x09, 0xe1, 0xa7, 0x0f, 0x27, 0x88, 0x2d,
760 0x90, 0x73, 0x4f, 0x67, 0xd3, 0x8b, 0xaf, 0xa1,
761 0x2c, 0x37, 0xa5, 0x6c, 0x7c, 0xbd, 0x95, 0x4c,
762 0x82, 0xcf, 0x05, 0x49, 0x16, 0x5c, 0xe7, 0x06,
763 0xd4, 0xcb, 0x55, 0x65, 0x9a, 0xd0, 0xe1, 0x46,
764 0x3a, 0x37, 0x71, 0xad, 0xb0, 0xb4, 0x99, 0x1e,
765 0x23, 0x57, 0x48, 0x96, 0x9c, 0xc5, 0xc4, 0xdb,
766 0x64, 0x3e, 0xc9, 0x7f, 0x90, 0x5a, 0xa0, 0x08,
767 0x75, 0x4c, 0x09, 0x06, 0x31, 0x6e, 0x59, 0x29,
768 0xfc, 0x2f, 0x72, 0xde, 0xf2, 0x40, 0x5a, 0xfe,
769 0xd3, 0x66, 0x64, 0xb8, 0x9c, 0xc9, 0xa6, 0x1f,
770 0xc3, 0x52, 0xcd, 0xb5, 0xd1, 0x4f, 0x43, 0x3f,
771 0xf4, 0x59, 0x25, 0xc4, 0xdd, 0x3e, 0x58, 0x7c,
772 0x21, 0xd6, 0x21, 0xce, 0xa4, 0xbe, 0x08, 0x23,
773 0x46, 0x68, 0xc0, 0x00, 0x91, 0x47, 0xca, 0x9b,
774 0xe0, 0xb4, 0xe3, 0xab, 0xbf, 0xcf, 0x68, 0x26,
775 0x97, 0x23, 0x09, 0x93, 0x64, 0x8f, 0x57, 0x59,
776 0xe2, 0x41, 0x7c, 0xa2, 0x48, 0x7e, 0xd5, 0x2c,
777 0x54, 0x09, 0x1b, 0x07, 0x94, 0xca, 0x39, 0x83,
778 0xdd, 0xf4, 0x7a, 0x1d, 0x2d, 0xdd, 0x67, 0xf7,
779 0x3c, 0x30, 0x89, 0x3e, 0xc1, 0xdc, 0x1d, 0x8f,
780 0xfc, 0xb1, 0xe9, 0x13, 0x31, 0xb0, 0x16, 0xdb,
781 0x88, 0xf2, 0x32, 0x7e, 0x73, 0xa3, 0xdf, 0x08,
782 0x6b, 0x53, 0x92, 0x08, 0xc9, 0x9d, 0x98, 0xb2,
783 0xf4, 0x8c, 0xb1, 0x95, 0xdc, 0xb6, 0xfc, 0xec,
784 0xf1, 0xc9, 0x0d, 0x6d, 0x42, 0x2c, 0xf5, 0x38,
785 0x29, 0xf4, 0xd8, 0x98, 0x0f, 0xb0, 0x81, 0xa5,
786 0xaa, 0xe6, 0x1f, 0x6e, 0x87, 0x32, 0x1b, 0x02,
787 0x07, 0x57, 0x38, 0x83, 0xf3, 0xe4, 0x54, 0x7c,
788 0xa8, 0x43, 0xdf, 0x3f, 0x42, 0xfd, 0x67, 0x28,
789 0x06, 0x4d, 0xea, 0xce, 0x1f, 0x84, 0x4a, 0xcd,
790 0x8c, 0x61, 0x5e, 0x8f, 0x61, 0xed, 0x84, 0x03,
791 0x53, 0x6a, 0x9e, 0xbf, 0x68, 0x83, 0xa7, 0x42,
792 0x56, 0x57, 0xcd, 0x45, 0x29, 0xfc, 0x7b, 0x07,
793 0xfc, 0xe9, 0xb9, 0x42, 0xfd, 0x29, 0xd5, 0xfd,
794 0x98, 0x11, 0xd1, 0x8d, 0x67, 0x29, 0x47, 0x61,
795 0xd8, 0x27, 0x37, 0x79, 0x29, 0xd1, 0x94, 0x6f,
796 0x8d, 0xf3, 0x1b, 0x3d, 0x6a, 0xb1, 0x59, 0xef,
797 0x1b, 0xd4, 0x70, 0x0e, 0xac, 0xab, 0xa0, 0x2b,
798 0x1f, 0x5e, 0x04, 0xf0, 0x0e, 0x35, 0x72, 0x90,
799 0xfc, 0xcf, 0x86, 0x43, 0xea, 0x45, 0x6d, 0x22,
800 0x63, 0x06, 0x1a, 0x58, 0xd7, 0x2d, 0xc5, 0xb0,
801 0x60, 0x69, 0xe8, 0x53, 0xc2, 0xa2, 0x57, 0x83,
802 0xc4, 0x31, 0xb4, 0xc6, 0xb3, 0xa1, 0x77, 0xb3,
803 0x1c, 0xca, 0x89, 0x3f, 0xf5, 0x10, 0x3b, 0x36,
804 0x31, 0x7d, 0x00, 0x46, 0x00, 0x92, 0xa0, 0xa0,
805 0x34, 0xd8, 0x5e, 0x62, 0xa9, 0xe0, 0x23, 0x37,
806 0x50, 0x85, 0xc7, 0x3a, 0x20, 0xa3, 0x98, 0xc0,
807 0xac, 0x20, 0x06, 0x0f, 0x17, 0x3c, 0xfc, 0x43,
808 0x8c, 0x9d, 0xec, 0xf5, 0x9a, 0x35, 0x96, 0xf7,
809 0xb7, 0x4c, 0xf9, 0x69, 0xf8, 0xd4, 0x1e, 0x9e,
810 0xf9, 0x7c, 0xc4, 0xd2, 0x11, 0x14, 0x41, 0xb9,
811 0x89, 0xd6, 0x07, 0xd2, 0x37, 0x07, 0x5e, 0x5e,
812 0xae, 0x60, 0xdc, 0xe4, 0xeb, 0x38, 0x48, 0x6d,
813 0x95, 0x8d, 0x71, 0xf2, 0xba, 0xda, 0x5f, 0x08,
814 0x9d, 0x4a, 0x0f, 0x56, 0x90, 0x64, 0xab, 0xb6,
815 0x88, 0x22, 0xa8, 0x90, 0x1f, 0x76, 0x2c, 0x83,
816 0x43, 0xce, 0x32, 0x55, 0x45, 0x84, 0x57, 0x43,
817 0xf9, 0xa8, 0xd1, 0x4f, 0xe3, 0xc1, 0x72, 0x9c,
818 0xeb, 0x64, 0xf7, 0xe4, 0x61, 0x2b, 0x93, 0xd1,
819 0x1f, 0xbb, 0x5c, 0xff, 0xa1, 0x59, 0x69, 0xcf,
820 0xf7, 0xaf, 0x58, 0x45, 0xd5, 0x3e, 0x98, 0x7d,
821 0x26, 0x39, 0x5c, 0x75, 0x3c, 0x4a, 0xbf, 0x5e,
822 0x12, 0x10, 0xb0, 0x93, 0x0f, 0x86, 0x82, 0xcf,
823 0xb2, 0xec, 0x70, 0x5c, 0x0b, 0xad, 0x5d, 0x63,
824 0x65, 0x32, 0xa6, 0x04, 0x58, 0x03, 0x91, 0x2b,
825 0xdb, 0x8f, 0xd3, 0xa3, 0x2b, 0x3a, 0xf5, 0xa1,
826 0x62, 0x6c, 0xb6, 0xf0, 0x13, 0x3b, 0x8c, 0x07,
827 0x10, 0x82, 0xc9, 0x56, 0x24, 0x87, 0xfc, 0x56,
828 0xe8, 0xef, 0x90, 0x8b, 0xd6, 0x48, 0xda, 0x53,
829 0x04, 0x49, 0x41, 0xa4, 0x67, 0xe0, 0x33, 0x24,
830 0x6b, 0x9c, 0x07, 0x55, 0x4c, 0x5d, 0xe9, 0x35,
831 0xfa, 0xbd, 0xea, 0xa8, 0x3f, 0xe9, 0xf5, 0x20,
832 0x5c, 0x60, 0x0f, 0x0d, 0x24, 0xcb, 0x1a, 0xd6,
833 0xe8, 0x5c, 0xa8, 0x42, 0xae, 0xd0, 0xd2, 0xf2,
834 0xa8, 0xbe, 0xea, 0x0f, 0x8d, 0xfb, 0x81, 0xa3,
835 0xa4, 0xef, 0xb7, 0x3e, 0x91, 0xbd, 0x26, 0x0f,
836 0x8e, 0xf1, 0xb2, 0xa5, 0x47, 0x06, 0xfa, 0x40,
837 0x8b, 0x31, 0x7a, 0x5a, 0x74, 0x2a, 0x0a, 0x7c,
838 0x62, 0x5d, 0x39, 0xa4, 0xae, 0x14, 0x85, 0x08,
839 0x5b, 0x20, 0x85, 0xf1, 0x57, 0x6e, 0x71, 0x13,
840 0x4e, 0x2b, 0x49, 0x87, 0x01, 0xdf, 0x37, 0xed,
841 0x28, 0xee, 0x4d, 0xa1, 0xf4, 0xb3, 0x3b, 0xba,
842 0x2d, 0xb3, 0x46, 0x17, 0x84, 0x80, 0x9d, 0xd7,
843 0x93, 0x1f, 0x28, 0x7c, 0xf5, 0xf9, 0xd6, 0x85,
844 0x8c, 0xa5, 0x44, 0xe9, 0x2c, 0x65, 0x51, 0x5f,
845 0x53, 0x7a, 0x09, 0xd9, 0x30, 0x16, 0x95, 0x89,
846 0x9c, 0x0b, 0xef, 0x90, 0x6d, 0x23, 0xd3, 0x48,
847 0x57, 0x3b, 0x55, 0x69, 0x96, 0xfc, 0xf7, 0x52,
848 0x92, 0x38, 0x36, 0xbf, 0xa9, 0x0a, 0xbb, 0x68,
849 0x45, 0x08, 0x25, 0xee, 0x59, 0xfe, 0xee, 0xf2,
850 0x2c, 0xd4, 0x5f, 0x78, 0x59, 0x0d, 0x90, 0xf1,
851 0xd7, 0xe4, 0x39, 0x0e, 0x46, 0x36, 0xf5, 0x75,
852 0x03, 0x3c, 0x28, 0xfb, 0xfa, 0x8f, 0xef, 0xc9,
853 0x61, 0x00, 0x94, 0xc3, 0xd2, 0x0f, 0xd9, 0xda
856 static const uint8_t AES_CBC_ciphertext_1024B[] = {
857 0x7d, 0x01, 0x7e, 0x2f, 0x92, 0xb3, 0xea, 0x72,
858 0x4a, 0x3f, 0x10, 0xf9, 0x2b, 0xb0, 0xd5, 0xb9,
859 0x19, 0x68, 0x94, 0xe9, 0x93, 0xe9, 0xd5, 0x26,
860 0x20, 0x44, 0xe2, 0x47, 0x15, 0x8d, 0x75, 0x48,
861 0x8e, 0xe4, 0x40, 0x81, 0xb5, 0x06, 0xa8, 0xb8,
862 0x0e, 0x0f, 0x3b, 0xbc, 0x5b, 0xbe, 0x3b, 0xa2,
863 0x2a, 0x0c, 0x48, 0x98, 0x19, 0xdf, 0xe9, 0x25,
864 0x75, 0xab, 0x93, 0x44, 0xb1, 0x72, 0x70, 0xbb,
865 0x20, 0xcf, 0x78, 0xe9, 0x4d, 0xc6, 0xa9, 0xa9,
866 0x84, 0x78, 0xc5, 0xc0, 0xc4, 0xc9, 0x79, 0x1a,
867 0xbc, 0x61, 0x25, 0x5f, 0xac, 0x01, 0x03, 0xb7,
868 0xef, 0x07, 0xf2, 0x62, 0x98, 0xee, 0xe3, 0xad,
869 0x94, 0x75, 0x30, 0x67, 0xb9, 0x15, 0x00, 0xe7,
870 0x11, 0x32, 0x2e, 0x6b, 0x55, 0x9f, 0xac, 0x68,
871 0xde, 0x61, 0x05, 0x80, 0x01, 0xf3, 0xad, 0xab,
872 0xaf, 0x45, 0xe0, 0xf4, 0x68, 0x5c, 0xc0, 0x52,
873 0x92, 0xc8, 0x21, 0xb6, 0xf5, 0x8a, 0x1d, 0xbb,
874 0xfc, 0x4a, 0x11, 0x62, 0xa2, 0xc4, 0xf1, 0x2d,
875 0x0e, 0xb2, 0xc7, 0x17, 0x34, 0xb4, 0x2a, 0x54,
876 0x81, 0xc2, 0x1e, 0xcf, 0x51, 0x0a, 0x76, 0x54,
877 0xf1, 0x48, 0x0d, 0x5c, 0xcd, 0x38, 0x3e, 0x38,
878 0x3e, 0xf8, 0x46, 0x1d, 0x00, 0xf5, 0x62, 0xe1,
879 0x5c, 0xb7, 0x8d, 0xce, 0xd0, 0x3f, 0xbb, 0x22,
880 0xf1, 0xe5, 0xb1, 0xa0, 0x58, 0x5e, 0x3c, 0x0f,
881 0x15, 0xd1, 0xac, 0x3e, 0xc7, 0x72, 0xc4, 0xde,
882 0x8b, 0x95, 0x3e, 0x91, 0xf7, 0x1d, 0x04, 0x9a,
883 0xc8, 0xe4, 0xbf, 0xd3, 0x22, 0xca, 0x4a, 0xdc,
884 0xb6, 0x16, 0x79, 0x81, 0x75, 0x2f, 0x6b, 0xa7,
885 0x04, 0x98, 0xa7, 0x4e, 0xc1, 0x19, 0x90, 0x33,
886 0x33, 0x3c, 0x7f, 0xdd, 0xac, 0x09, 0x0c, 0xc3,
887 0x91, 0x34, 0x74, 0xab, 0xa5, 0x35, 0x0a, 0x13,
888 0xc3, 0x56, 0x67, 0x6d, 0x1a, 0x3e, 0xbf, 0x56,
889 0x06, 0x67, 0x15, 0x5f, 0xfc, 0x8b, 0xa2, 0x3c,
890 0x5e, 0xaf, 0x56, 0x1f, 0xe3, 0x2e, 0x9d, 0x0a,
891 0xf9, 0x9b, 0xc7, 0xb5, 0x03, 0x1c, 0x68, 0x99,
892 0xfa, 0x3c, 0x37, 0x59, 0xc1, 0xf7, 0x6a, 0x83,
893 0x22, 0xee, 0xca, 0x7f, 0x7d, 0x49, 0xe6, 0x48,
894 0x84, 0x54, 0x7a, 0xff, 0xb3, 0x72, 0x21, 0xd8,
895 0x7a, 0x5d, 0xb1, 0x4b, 0xcc, 0x01, 0x6f, 0x90,
896 0xc6, 0x68, 0x1c, 0x2c, 0xa1, 0xe2, 0x74, 0x40,
897 0x26, 0x9b, 0x57, 0x53, 0xa3, 0x7c, 0x0b, 0x0d,
898 0xcf, 0x05, 0x5d, 0x62, 0x4f, 0x75, 0x06, 0x62,
899 0x1f, 0x26, 0x32, 0xaa, 0x25, 0xcc, 0x26, 0x8d,
900 0xae, 0x01, 0x47, 0xa3, 0x00, 0x42, 0xe2, 0x4c,
901 0xee, 0x29, 0xa2, 0x81, 0xa0, 0xfd, 0xeb, 0xff,
902 0x9a, 0x66, 0x6e, 0x47, 0x5b, 0xab, 0x93, 0x5a,
903 0x02, 0x6d, 0x6f, 0xf2, 0x6e, 0x02, 0x9d, 0xb1,
904 0xab, 0x56, 0xdc, 0x8b, 0x9b, 0x17, 0xa8, 0xfb,
905 0x87, 0x42, 0x7c, 0x91, 0x1e, 0x14, 0xc6, 0x6f,
906 0xdc, 0xf0, 0x27, 0x30, 0xfa, 0x3f, 0xc4, 0xad,
907 0x57, 0x85, 0xd2, 0xc9, 0x32, 0x2c, 0x13, 0xa6,
908 0x04, 0x04, 0x50, 0x05, 0x2f, 0x72, 0xd9, 0x44,
909 0x55, 0x6e, 0x93, 0x40, 0xed, 0x7e, 0xd4, 0x40,
910 0x3e, 0x88, 0x3b, 0x8b, 0xb6, 0xeb, 0xc6, 0x5d,
911 0x9c, 0x99, 0xa1, 0xcf, 0x30, 0xb2, 0xdc, 0x48,
912 0x8a, 0x01, 0xa7, 0x61, 0x77, 0x50, 0x14, 0xf3,
913 0x0c, 0x49, 0x53, 0xb3, 0xb4, 0xb4, 0x28, 0x41,
914 0x4a, 0x2d, 0xd2, 0x4d, 0x2a, 0x30, 0x31, 0x83,
915 0x03, 0x5e, 0xaa, 0xd3, 0xa3, 0xd1, 0xa1, 0xca,
916 0x62, 0xf0, 0xe1, 0xf2, 0xff, 0xf0, 0x19, 0xa6,
917 0xde, 0x22, 0x47, 0xb5, 0x28, 0x7d, 0xf7, 0x07,
918 0x16, 0x0d, 0xb1, 0x55, 0x81, 0x95, 0xe5, 0x1d,
919 0x4d, 0x78, 0xa9, 0x3e, 0xce, 0xe3, 0x1c, 0xf9,
920 0x47, 0xc8, 0xec, 0xc5, 0xc5, 0x93, 0x4c, 0x34,
921 0x20, 0x6b, 0xee, 0x9a, 0xe6, 0x86, 0x57, 0x58,
922 0xd5, 0x58, 0xf1, 0x33, 0x10, 0x29, 0x9e, 0x93,
923 0x2f, 0xf5, 0x90, 0x00, 0x17, 0x67, 0x4f, 0x39,
924 0x18, 0xe1, 0xcf, 0x55, 0x78, 0xbb, 0xe6, 0x29,
925 0x3e, 0x77, 0xd5, 0x48, 0xb7, 0x42, 0x72, 0x53,
926 0x27, 0xfa, 0x5b, 0xe0, 0x36, 0x14, 0x97, 0xb8,
927 0x9b, 0x3c, 0x09, 0x77, 0xc1, 0x0a, 0xe4, 0xa2,
928 0x63, 0xfc, 0xbe, 0x5c, 0x17, 0xcf, 0x01, 0xf5,
929 0x03, 0x0f, 0x17, 0xbc, 0x93, 0xdd, 0x5f, 0xe2,
930 0xf3, 0x08, 0xa8, 0xb1, 0x85, 0xb6, 0x34, 0x3f,
931 0x87, 0x42, 0xa5, 0x42, 0x3b, 0x0e, 0xd6, 0x83,
932 0x6a, 0xfd, 0x5d, 0xc9, 0x67, 0xd5, 0x51, 0xc9,
933 0x2a, 0x4e, 0x91, 0xb0, 0x59, 0xb2, 0x0f, 0xa2,
934 0xe6, 0x47, 0x73, 0xc2, 0xa2, 0xae, 0xbb, 0xc8,
935 0x42, 0xa3, 0x2a, 0x27, 0x29, 0x48, 0x8c, 0x54,
936 0x6c, 0xec, 0x00, 0x2a, 0x42, 0xa3, 0x7a, 0x0f,
937 0x12, 0x66, 0x6b, 0x96, 0xf6, 0xd0, 0x56, 0x4f,
938 0x49, 0x5c, 0x47, 0xec, 0x05, 0x62, 0x54, 0xb2,
939 0x64, 0x5a, 0x69, 0x1f, 0x19, 0xb4, 0x84, 0x5c,
940 0xbe, 0x48, 0x8e, 0xfc, 0x58, 0x21, 0xce, 0xfa,
941 0xaa, 0x84, 0xd2, 0xc1, 0x08, 0xb3, 0x87, 0x0f,
942 0x4f, 0xa3, 0x3a, 0xb6, 0x44, 0xbe, 0x2e, 0x9a,
943 0xdd, 0xb5, 0x44, 0x80, 0xca, 0xf4, 0xc3, 0x6e,
944 0xba, 0x93, 0x77, 0xe0, 0x53, 0xfb, 0x37, 0xfb,
945 0x88, 0xc3, 0x1f, 0x25, 0xde, 0x3e, 0x11, 0xf4,
946 0x89, 0xe7, 0xd1, 0x3b, 0xb4, 0x23, 0xcb, 0x70,
947 0xba, 0x35, 0x97, 0x7c, 0xbe, 0x84, 0x13, 0xcf,
948 0xe0, 0x4d, 0x33, 0x91, 0x71, 0x85, 0xbb, 0x4b,
949 0x97, 0x32, 0x5d, 0xa0, 0xb9, 0x8f, 0xdc, 0x27,
950 0x5a, 0xeb, 0x71, 0xf1, 0xd5, 0x0d, 0x65, 0xb4,
951 0x22, 0x81, 0xde, 0xa7, 0x58, 0x20, 0x0b, 0x18,
952 0x11, 0x76, 0x5c, 0xe6, 0x6a, 0x2c, 0x99, 0x69,
953 0xdc, 0xed, 0x67, 0x08, 0x5d, 0x5e, 0xe9, 0x1e,
954 0x55, 0x70, 0xc1, 0x5a, 0x76, 0x1b, 0x8d, 0x2e,
955 0x0d, 0xf9, 0xcc, 0x30, 0x8c, 0x44, 0x0f, 0x63,
956 0x8c, 0x42, 0x8a, 0x9f, 0x4c, 0xd1, 0x48, 0x28,
957 0x8a, 0xf5, 0x56, 0x2e, 0x23, 0x12, 0xfe, 0x67,
958 0x9a, 0x13, 0x65, 0x75, 0x83, 0xf1, 0x3c, 0x98,
959 0x07, 0x6b, 0xb7, 0x27, 0x5b, 0xf0, 0x70, 0xda,
960 0x30, 0xf8, 0x74, 0x4e, 0x7a, 0x32, 0x84, 0xcc,
961 0x0e, 0xcd, 0x80, 0x8b, 0x82, 0x31, 0x9a, 0x48,
962 0xcf, 0x75, 0x00, 0x1f, 0x4f, 0xe0, 0x8e, 0xa3,
963 0x6a, 0x2c, 0xd4, 0x73, 0x4c, 0x63, 0x7c, 0xa6,
964 0x4d, 0x5e, 0xfd, 0x43, 0x3b, 0x27, 0xe1, 0x5e,
965 0xa3, 0xa9, 0x5c, 0x3b, 0x60, 0xdd, 0xc6, 0x8d,
966 0x5a, 0xf1, 0x3e, 0x89, 0x4b, 0x24, 0xcf, 0x01,
967 0x3a, 0x2d, 0x44, 0xe7, 0xda, 0xe7, 0xa1, 0xac,
968 0x11, 0x05, 0x0c, 0xa9, 0x7a, 0x82, 0x8c, 0x5c,
969 0x29, 0x68, 0x9c, 0x73, 0x13, 0xcc, 0x67, 0x32,
970 0x11, 0x5e, 0xe5, 0xcc, 0x8c, 0xf5, 0xa7, 0x52,
971 0x83, 0x9a, 0x70, 0xef, 0xde, 0x55, 0x9c, 0xc7,
972 0x8a, 0xed, 0xad, 0x28, 0x4a, 0xc5, 0x92, 0x6d,
973 0x8e, 0x47, 0xca, 0xe3, 0xf8, 0x77, 0xb5, 0x26,
974 0x64, 0x84, 0xc2, 0xf1, 0xd7, 0xae, 0x0c, 0xb9,
975 0x39, 0x0f, 0x43, 0x6b, 0xe9, 0xe0, 0x09, 0x4b,
976 0xe5, 0xe3, 0x17, 0xa6, 0x68, 0x69, 0x46, 0xf4,
977 0xf0, 0x68, 0x7f, 0x2f, 0x1c, 0x7e, 0x4c, 0xd2,
978 0xb5, 0xc6, 0x16, 0x85, 0xcf, 0x02, 0x4c, 0x89,
979 0x0b, 0x25, 0xb0, 0xeb, 0xf3, 0x77, 0x08, 0x6a,
980 0x46, 0x5c, 0xf6, 0x2f, 0xf1, 0x24, 0xc3, 0x4d,
981 0x80, 0x60, 0x4d, 0x69, 0x98, 0xde, 0xc7, 0xa1,
982 0xf6, 0x4e, 0x18, 0x0c, 0x2a, 0xb0, 0xb2, 0xe0,
983 0x46, 0xe7, 0x49, 0x37, 0xc8, 0x5a, 0x23, 0x24,
984 0xe3, 0x0f, 0xcc, 0x92, 0xb4, 0x8d, 0xdc, 0x9e
987 static const uint8_t AES_CBC_ciphertext_1280B[] = {
988 0x91, 0x99, 0x5e, 0x9e, 0x84, 0xff, 0x59, 0x45,
989 0xc1, 0xf4, 0xbc, 0x9c, 0xb9, 0x30, 0x6c, 0x51,
990 0x73, 0x52, 0xb4, 0x44, 0x09, 0x79, 0xe2, 0x89,
991 0x75, 0xeb, 0x54, 0x26, 0xce, 0xd8, 0x24, 0x98,
992 0xaa, 0xf8, 0x13, 0x16, 0x68, 0x58, 0xc4, 0x82,
993 0x0e, 0x31, 0xd3, 0x6a, 0x13, 0x58, 0x31, 0xe9,
994 0x3a, 0xc1, 0x8b, 0xc5, 0x3f, 0x50, 0x42, 0xd1,
995 0x93, 0xe4, 0x9b, 0x65, 0x2b, 0xf4, 0x1d, 0x9e,
996 0x2d, 0xdb, 0x48, 0xef, 0x9a, 0x01, 0x68, 0xb6,
997 0xea, 0x7a, 0x2b, 0xad, 0xfe, 0x77, 0x44, 0x7e,
998 0x5a, 0xc5, 0x64, 0xb4, 0xfe, 0x5c, 0x80, 0xf3,
999 0x20, 0x7e, 0xaf, 0x5b, 0xf8, 0xd1, 0x38, 0xa0,
1000 0x8d, 0x09, 0x77, 0x06, 0xfe, 0xf5, 0xf4, 0xe4,
1001 0xee, 0xb8, 0x95, 0x27, 0xed, 0x07, 0xb8, 0xaa,
1002 0x25, 0xb4, 0xe1, 0x4c, 0xeb, 0x3f, 0xdb, 0x39,
1003 0x66, 0x28, 0x1b, 0x60, 0x42, 0x8b, 0x99, 0xd9,
1004 0x49, 0xd6, 0x8c, 0xa4, 0x9d, 0xd8, 0x93, 0x58,
1005 0x8f, 0xfa, 0xd3, 0xf7, 0x37, 0x9c, 0x88, 0xab,
1006 0x16, 0x50, 0xfe, 0x01, 0x1f, 0x88, 0x48, 0xbe,
1007 0x21, 0xa9, 0x90, 0x9e, 0x73, 0xe9, 0x82, 0xf7,
1008 0xbf, 0x4b, 0x43, 0xf4, 0xbf, 0x22, 0x3c, 0x45,
1009 0x47, 0x95, 0x5b, 0x49, 0x71, 0x07, 0x1c, 0x8b,
1010 0x49, 0xa4, 0xa3, 0x49, 0xc4, 0x5f, 0xb1, 0xf5,
1011 0xe3, 0x6b, 0xf1, 0xdc, 0xea, 0x92, 0x7b, 0x29,
1012 0x40, 0xc9, 0x39, 0x5f, 0xdb, 0xbd, 0xf3, 0x6a,
1013 0x09, 0x9b, 0x2a, 0x5e, 0xc7, 0x0b, 0x25, 0x94,
1014 0x55, 0x71, 0x9c, 0x7e, 0x0e, 0xb4, 0x08, 0x12,
1015 0x8c, 0x6e, 0x77, 0xb8, 0x29, 0xf1, 0xc6, 0x71,
1016 0x04, 0x40, 0x77, 0x18, 0x3f, 0x01, 0x09, 0x9c,
1017 0x23, 0x2b, 0x5d, 0x2a, 0x88, 0x20, 0x23, 0x59,
1018 0x74, 0x2a, 0x67, 0x8f, 0xb7, 0xba, 0x38, 0x9f,
1019 0x0f, 0xcf, 0x94, 0xdf, 0xe1, 0x8f, 0x35, 0x5e,
1020 0x34, 0x0c, 0x32, 0x92, 0x2b, 0x23, 0x81, 0xf4,
1021 0x73, 0xa0, 0x5a, 0x2a, 0xbd, 0xa6, 0x6b, 0xae,
1022 0x43, 0xe2, 0xdc, 0x01, 0xc1, 0xc6, 0xc3, 0x04,
1023 0x06, 0xbb, 0xb0, 0x89, 0xb3, 0x4e, 0xbd, 0x81,
1024 0x1b, 0x03, 0x63, 0x93, 0xed, 0x4e, 0xf6, 0xe5,
1025 0x94, 0x6f, 0xd6, 0xf3, 0x20, 0xf3, 0xbc, 0x30,
1026 0xc5, 0xd6, 0xbe, 0x1c, 0x05, 0x34, 0x26, 0x4d,
1027 0x46, 0x5e, 0x56, 0x63, 0xfb, 0xdb, 0xcd, 0xed,
1028 0xb0, 0x7f, 0x83, 0x94, 0x55, 0x54, 0x2f, 0xab,
1029 0xc9, 0xb7, 0x16, 0x4f, 0x9e, 0x93, 0x25, 0xd7,
1030 0x9f, 0x39, 0x2b, 0x63, 0xcf, 0x1e, 0xa3, 0x0e,
1031 0x28, 0x47, 0x8a, 0x5f, 0x40, 0x02, 0x89, 0x1f,
1032 0x83, 0xe7, 0x87, 0xd1, 0x90, 0x17, 0xb8, 0x27,
1033 0x64, 0xe1, 0xe1, 0x48, 0x5a, 0x55, 0x74, 0x99,
1034 0x27, 0x9d, 0x05, 0x67, 0xda, 0x70, 0x12, 0x8f,
1035 0x94, 0x96, 0xfd, 0x36, 0xa4, 0x1d, 0x22, 0xe5,
1036 0x0b, 0xe5, 0x2f, 0x38, 0x55, 0xa3, 0x5d, 0x0b,
1037 0xcf, 0xd4, 0xa9, 0xb8, 0xd6, 0x9a, 0x16, 0x2e,
1038 0x6c, 0x4a, 0x25, 0x51, 0x7a, 0x09, 0x48, 0xdd,
1039 0xf0, 0xa3, 0x5b, 0x08, 0x1e, 0x2f, 0x03, 0x91,
1040 0x80, 0xe8, 0x0f, 0xe9, 0x5a, 0x2f, 0x90, 0xd3,
1041 0x64, 0xed, 0xd7, 0x51, 0x17, 0x66, 0x53, 0x40,
1042 0x43, 0x74, 0xef, 0x0a, 0x0d, 0x49, 0x41, 0xf2,
1043 0x67, 0x6e, 0xea, 0x14, 0xc8, 0x74, 0xd6, 0xa9,
1044 0xb9, 0x6a, 0xe3, 0xec, 0x7d, 0xe8, 0x6a, 0x21,
1045 0x3a, 0x52, 0x42, 0xfe, 0x9a, 0x15, 0x6d, 0x60,
1046 0x64, 0x88, 0xc5, 0xb2, 0x8b, 0x15, 0x2c, 0xff,
1047 0xe2, 0x35, 0xc3, 0xee, 0x9f, 0xcd, 0x82, 0xd9,
1048 0x14, 0x35, 0x2a, 0xb7, 0xf5, 0x2f, 0x7b, 0xbc,
1049 0x01, 0xfd, 0xa8, 0xe0, 0x21, 0x4e, 0x73, 0xf9,
1050 0xf2, 0xb0, 0x79, 0xc9, 0x10, 0x52, 0x8f, 0xa8,
1051 0x3e, 0x3b, 0xbe, 0xc5, 0xde, 0xf6, 0x53, 0xe3,
1052 0x1c, 0x25, 0x3a, 0x1f, 0x13, 0xbf, 0x13, 0xbb,
1053 0x94, 0xc2, 0x97, 0x43, 0x64, 0x47, 0x8f, 0x76,
1054 0xd7, 0xaa, 0xeb, 0xa4, 0x03, 0x50, 0x0c, 0x10,
1055 0x50, 0xd8, 0xf7, 0x75, 0x52, 0x42, 0xe2, 0x94,
1056 0x67, 0xf4, 0x60, 0xfb, 0x21, 0x9b, 0x7a, 0x05,
1057 0x50, 0x7c, 0x1b, 0x4a, 0x8b, 0x29, 0xe1, 0xac,
1058 0xd7, 0x99, 0xfd, 0x0d, 0x65, 0x92, 0xcd, 0x23,
1059 0xa7, 0x35, 0x8e, 0x13, 0xf2, 0xe4, 0x10, 0x74,
1060 0xc6, 0x4f, 0x19, 0xf7, 0x01, 0x0b, 0x46, 0xab,
1061 0xef, 0x8d, 0x4a, 0x4a, 0xfa, 0xda, 0xf3, 0xfb,
1062 0x40, 0x28, 0x88, 0xa2, 0x65, 0x98, 0x4d, 0x88,
1063 0xc7, 0xbf, 0x00, 0xc8, 0xd0, 0x91, 0xcb, 0x89,
1064 0x2f, 0xb0, 0x85, 0xfc, 0xa1, 0xc1, 0x9e, 0x83,
1065 0x88, 0xad, 0x95, 0xc0, 0x31, 0xa0, 0xad, 0xa2,
1066 0x42, 0xb5, 0xe7, 0x55, 0xd4, 0x93, 0x5a, 0x74,
1067 0x4e, 0x41, 0xc3, 0xcf, 0x96, 0x83, 0x46, 0xa1,
1068 0xb7, 0x5b, 0xb1, 0x34, 0x67, 0x4e, 0xb1, 0xd7,
1069 0x40, 0x20, 0x72, 0xe9, 0xc8, 0x74, 0xb7, 0xde,
1070 0x72, 0x29, 0x77, 0x4c, 0x74, 0x7e, 0xcc, 0x18,
1071 0xa5, 0x8d, 0x79, 0x8c, 0xd6, 0x6e, 0xcb, 0xd9,
1072 0xe1, 0x61, 0xe7, 0x36, 0xbc, 0x37, 0xea, 0xee,
1073 0xd8, 0x3c, 0x5e, 0x7c, 0x47, 0x50, 0xd5, 0xec,
1074 0x37, 0xc5, 0x63, 0xc3, 0xc9, 0x99, 0x23, 0x9f,
1075 0x64, 0x39, 0xdf, 0x13, 0x96, 0x6d, 0xea, 0x08,
1076 0x0c, 0x27, 0x2d, 0xfe, 0x0f, 0xc2, 0xa3, 0x97,
1077 0x04, 0x12, 0x66, 0x0d, 0x94, 0xbf, 0xbe, 0x3e,
1078 0xb9, 0xcf, 0x8e, 0xc1, 0x9d, 0xb1, 0x64, 0x17,
1079 0x54, 0x92, 0x3f, 0x0a, 0x51, 0xc8, 0xf5, 0x82,
1080 0x98, 0x73, 0x03, 0xc0, 0x5a, 0x51, 0x01, 0x67,
1081 0xb4, 0x01, 0x04, 0x06, 0xbc, 0x37, 0xde, 0x96,
1082 0x23, 0x3c, 0xce, 0x98, 0x3f, 0xd6, 0x51, 0x1b,
1083 0x01, 0x83, 0x0a, 0x1c, 0xf9, 0xeb, 0x7e, 0x72,
1084 0xa9, 0x51, 0x23, 0xc8, 0xd7, 0x2f, 0x12, 0xbc,
1085 0x08, 0xac, 0x07, 0xe7, 0xa7, 0xe6, 0x46, 0xae,
1086 0x54, 0xa3, 0xc2, 0xf2, 0x05, 0x2d, 0x06, 0x5e,
1087 0xfc, 0xe2, 0xa2, 0x23, 0xac, 0x86, 0xf2, 0x54,
1088 0x83, 0x4a, 0xb6, 0x48, 0x93, 0xa1, 0x78, 0xc2,
1089 0x07, 0xec, 0x82, 0xf0, 0x74, 0xa9, 0x18, 0xe9,
1090 0x53, 0x44, 0x49, 0xc2, 0x94, 0xf8, 0x94, 0x92,
1091 0x08, 0x3f, 0xbf, 0xa6, 0xe5, 0xc6, 0x03, 0x8a,
1092 0xc6, 0x90, 0x48, 0x6c, 0xee, 0xbd, 0x44, 0x92,
1093 0x1f, 0x2a, 0xce, 0x1d, 0xb8, 0x31, 0xa2, 0x9d,
1094 0x24, 0x93, 0xa8, 0x9f, 0x36, 0x00, 0x04, 0x7b,
1095 0xcb, 0x93, 0x59, 0xa1, 0x53, 0xdb, 0x13, 0x7a,
1096 0x54, 0xb1, 0x04, 0xdb, 0xce, 0x48, 0x4f, 0xe5,
1097 0x2f, 0xcb, 0xdf, 0x8f, 0x50, 0x7c, 0xfc, 0x76,
1098 0x80, 0xb4, 0xdc, 0x3b, 0xc8, 0x98, 0x95, 0xf5,
1099 0x50, 0xba, 0x70, 0x5a, 0x97, 0xd5, 0xfc, 0x98,
1100 0x4d, 0xf3, 0x61, 0x0f, 0xcf, 0xac, 0x49, 0x0a,
1101 0xdb, 0xc1, 0x42, 0x8f, 0xb6, 0x29, 0xd5, 0x65,
1102 0xef, 0x83, 0xf1, 0x30, 0x4b, 0x84, 0xd0, 0x69,
1103 0xde, 0xd2, 0x99, 0xe5, 0xec, 0xd3, 0x90, 0x86,
1104 0x39, 0x2a, 0x6e, 0xd5, 0x32, 0xe3, 0x0d, 0x2d,
1105 0x01, 0x8b, 0x17, 0x55, 0x1d, 0x65, 0x57, 0xbf,
1106 0xd8, 0x75, 0xa4, 0x85, 0xb6, 0x4e, 0x35, 0x14,
1107 0x58, 0xe4, 0x89, 0xb8, 0x7a, 0x58, 0x86, 0x0c,
1108 0xbd, 0x8b, 0x05, 0x7b, 0x63, 0xc0, 0x86, 0x80,
1109 0x33, 0x46, 0xd4, 0x9b, 0xb6, 0x0a, 0xeb, 0x6c,
1110 0xae, 0xd6, 0x57, 0x7a, 0xc7, 0x59, 0x33, 0xa0,
1111 0xda, 0xa4, 0x12, 0xbf, 0x52, 0x22, 0x05, 0x8d,
1112 0xeb, 0xee, 0xd5, 0xec, 0xea, 0x29, 0x9b, 0x76,
1113 0x95, 0x50, 0x6d, 0x99, 0xe1, 0x45, 0x63, 0x09,
1114 0x16, 0x5f, 0xb0, 0xf2, 0x5b, 0x08, 0x33, 0xdd,
1115 0x8f, 0xb7, 0x60, 0x7a, 0x8e, 0xc6, 0xfc, 0xac,
1116 0xa9, 0x56, 0x2c, 0xa9, 0x8b, 0x74, 0x33, 0xad,
1117 0x2a, 0x7e, 0x96, 0xb6, 0xba, 0x22, 0x28, 0xcf,
1118 0x4d, 0x96, 0xb7, 0xd1, 0xfa, 0x99, 0x4a, 0x61,
1119 0xe6, 0x84, 0xd1, 0x94, 0xca, 0xf5, 0x86, 0xb0,
1120 0xba, 0x34, 0x7a, 0x04, 0xcc, 0xd4, 0x81, 0xcd,
1121 0xd9, 0x86, 0xb6, 0xe0, 0x5a, 0x6f, 0x9b, 0x99,
1122 0xf0, 0xdf, 0x49, 0xae, 0x6d, 0xc2, 0x54, 0x67,
1123 0xe0, 0xb4, 0x34, 0x2d, 0x1c, 0x46, 0xdf, 0x73,
1124 0x3b, 0x45, 0x43, 0xe7, 0x1f, 0xa3, 0x36, 0x35,
1125 0x25, 0x33, 0xd9, 0xc0, 0x54, 0x38, 0x6e, 0x6b,
1126 0x80, 0xcf, 0x50, 0xa4, 0xb6, 0x21, 0x17, 0xfd,
1127 0x9b, 0x5c, 0x36, 0xca, 0xcc, 0x73, 0x73, 0xad,
1128 0xe0, 0x57, 0x77, 0x90, 0x0e, 0x7f, 0x0f, 0x87,
1129 0x7f, 0xdb, 0x73, 0xbf, 0xda, 0xc2, 0xb3, 0x05,
1130 0x22, 0x06, 0xf5, 0xa3, 0xfc, 0x1e, 0x8f, 0xda,
1131 0xcf, 0x49, 0xd6, 0xb3, 0x66, 0x2c, 0xb5, 0x00,
1132 0xaf, 0x85, 0x6e, 0xb8, 0x5b, 0x8c, 0xa1, 0xa4,
1133 0x21, 0xce, 0x40, 0xf3, 0x98, 0xac, 0xec, 0x88,
1134 0x62, 0x43, 0x2a, 0xac, 0xca, 0xcf, 0xb9, 0x30,
1135 0xeb, 0xfc, 0xef, 0xf0, 0x6e, 0x64, 0x6d, 0xe7,
1136 0x54, 0x88, 0x6b, 0x22, 0x29, 0xbe, 0xa5, 0x8c,
1137 0x31, 0x23, 0x3b, 0x4a, 0x80, 0x37, 0xe6, 0xd0,
1138 0x05, 0xfc, 0x10, 0x0e, 0xdd, 0xbb, 0x00, 0xc5,
1139 0x07, 0x20, 0x59, 0xd3, 0x41, 0x17, 0x86, 0x46,
1140 0xab, 0x68, 0xf6, 0x48, 0x3c, 0xea, 0x5a, 0x06,
1141 0x30, 0x21, 0x19, 0xed, 0x74, 0xbe, 0x0b, 0x97,
1142 0xee, 0x91, 0x35, 0x94, 0x1f, 0xcb, 0x68, 0x7f,
1143 0xe4, 0x48, 0xb0, 0x16, 0xfb, 0xf0, 0x74, 0xdb,
1144 0x06, 0x59, 0x2e, 0x5a, 0x9c, 0xce, 0x8f, 0x7d,
1145 0xba, 0x48, 0xd5, 0x3f, 0x5c, 0xb0, 0xc2, 0x33,
1146 0x48, 0x60, 0x17, 0x08, 0x85, 0xba, 0xff, 0xb9,
1147 0x34, 0x0a, 0x3d, 0x8f, 0x21, 0x13, 0x12, 0x1b
1150 static const uint8_t AES_CBC_ciphertext_1536B[] = {
1151 0x89, 0x93, 0x05, 0x99, 0xa9, 0xed, 0xea, 0x62,
1152 0xc9, 0xda, 0x51, 0x15, 0xce, 0x42, 0x91, 0xc3,
1153 0x80, 0xc8, 0x03, 0x88, 0xc2, 0x63, 0xda, 0x53,
1154 0x1a, 0xf3, 0xeb, 0xd5, 0xba, 0x6f, 0x23, 0xb2,
1155 0xed, 0x8f, 0x89, 0xb1, 0xb3, 0xca, 0x90, 0x7a,
1156 0xdd, 0x3f, 0xf6, 0xca, 0x86, 0x58, 0x54, 0xbc,
1157 0xab, 0x0f, 0xf4, 0xab, 0x6d, 0x5d, 0x42, 0xd0,
1158 0x17, 0x49, 0x17, 0xd1, 0x93, 0xea, 0xe8, 0x22,
1159 0xc1, 0x34, 0x9f, 0x3a, 0x3b, 0xaa, 0xe9, 0x1b,
1160 0x93, 0xff, 0x6b, 0x68, 0xba, 0xe6, 0xd2, 0x39,
1161 0x3d, 0x55, 0x34, 0x8f, 0x98, 0x86, 0xb4, 0xd8,
1162 0x7c, 0x0d, 0x3e, 0x01, 0x63, 0x04, 0x01, 0xff,
1163 0x16, 0x0f, 0x51, 0x5f, 0x73, 0x53, 0xf0, 0x3a,
1164 0x38, 0xb4, 0x4d, 0x8d, 0xaf, 0xa3, 0xca, 0x2f,
1165 0x6f, 0xdf, 0xc0, 0x41, 0x6c, 0x48, 0x60, 0x1a,
1166 0xe4, 0xe7, 0x8a, 0x65, 0x6f, 0x8d, 0xd7, 0xe1,
1167 0x10, 0xab, 0x78, 0x5b, 0xb9, 0x69, 0x1f, 0xe0,
1168 0x5c, 0xf1, 0x19, 0x12, 0x21, 0xc7, 0x51, 0xbc,
1169 0x61, 0x5f, 0xc0, 0x36, 0x17, 0xc0, 0x28, 0xd9,
1170 0x51, 0xcb, 0x43, 0xd9, 0xfa, 0xd1, 0xad, 0x79,
1171 0x69, 0x86, 0x49, 0xc5, 0xe5, 0x69, 0x27, 0xce,
1172 0x22, 0xd0, 0xe1, 0x6a, 0xf9, 0x02, 0xca, 0x6c,
1173 0x34, 0xc7, 0xb8, 0x02, 0xc1, 0x38, 0x7f, 0xd5,
1174 0x15, 0xf5, 0xd6, 0xeb, 0xf9, 0x30, 0x40, 0x43,
1175 0xea, 0x87, 0xde, 0x35, 0xf6, 0x83, 0x59, 0x09,
1176 0x68, 0x62, 0x00, 0x87, 0xb8, 0xe7, 0xca, 0x05,
1177 0x0f, 0xac, 0x42, 0x58, 0x45, 0xaa, 0xc9, 0x9b,
1178 0xfd, 0x2a, 0xda, 0x65, 0x33, 0x93, 0x9d, 0xc6,
1179 0x93, 0x8d, 0xe2, 0xc5, 0x71, 0xc1, 0x5c, 0x13,
1180 0xde, 0x7b, 0xd4, 0xb9, 0x4c, 0x35, 0x61, 0x85,
1181 0x90, 0x78, 0xf7, 0x81, 0x98, 0x45, 0x99, 0x24,
1182 0x58, 0x73, 0x28, 0xf8, 0x31, 0xab, 0x54, 0x2e,
1183 0xc0, 0x38, 0x77, 0x25, 0x5c, 0x06, 0x9c, 0xc3,
1184 0x69, 0x21, 0x92, 0x76, 0xe1, 0x16, 0xdc, 0xa9,
1185 0xee, 0xb6, 0x80, 0x66, 0x43, 0x11, 0x24, 0xb3,
1186 0x07, 0x17, 0x89, 0x0f, 0xcb, 0xe0, 0x60, 0xa8,
1187 0x9d, 0x06, 0x4b, 0x6e, 0x72, 0xb7, 0xbc, 0x4f,
1188 0xb8, 0xc0, 0x80, 0xa2, 0xfb, 0x46, 0x5b, 0x8f,
1189 0x11, 0x01, 0x92, 0x9d, 0x37, 0x09, 0x98, 0xc8,
1190 0x0a, 0x46, 0xae, 0x12, 0xac, 0x61, 0x3f, 0xe7,
1191 0x41, 0x1a, 0xaa, 0x2e, 0xdc, 0xd7, 0x2a, 0x47,
1192 0xee, 0xdf, 0x08, 0xd1, 0xff, 0xea, 0x13, 0xc6,
1193 0x05, 0xdb, 0x29, 0xcc, 0x03, 0xba, 0x7b, 0x6d,
1194 0x40, 0xc1, 0xc9, 0x76, 0x75, 0x03, 0x7a, 0x71,
1195 0xc9, 0x5f, 0xd9, 0xe0, 0x61, 0x69, 0x36, 0x8f,
1196 0xb2, 0xbc, 0x28, 0xf3, 0x90, 0x71, 0xda, 0x5f,
1197 0x08, 0xd5, 0x0d, 0xc1, 0xe6, 0xbd, 0x2b, 0xc6,
1198 0x6c, 0x42, 0xfd, 0xbf, 0x10, 0xe8, 0x5f, 0x87,
1199 0x3d, 0x21, 0x42, 0x85, 0x01, 0x0a, 0xbf, 0x8e,
1200 0x49, 0xd3, 0x9c, 0x89, 0x3b, 0xea, 0xe1, 0xbf,
1201 0xe9, 0x9b, 0x5e, 0x0e, 0xb8, 0xeb, 0xcd, 0x3a,
1202 0xf6, 0x29, 0x41, 0x35, 0xdd, 0x9b, 0x13, 0x24,
1203 0xe0, 0x1d, 0x8a, 0xcb, 0x20, 0xf8, 0x41, 0x51,
1204 0x3e, 0x23, 0x8c, 0x67, 0x98, 0x39, 0x53, 0x77,
1205 0x2a, 0x68, 0xf4, 0x3c, 0x7e, 0xd6, 0xc4, 0x6e,
1206 0xf1, 0x53, 0xe9, 0xd8, 0x5c, 0xc1, 0xa9, 0x38,
1207 0x6f, 0x5e, 0xe4, 0xd4, 0x29, 0x1c, 0x6c, 0xee,
1208 0x2f, 0xea, 0xde, 0x61, 0x71, 0x5a, 0xea, 0xce,
1209 0x23, 0x6e, 0x1b, 0x16, 0x43, 0xb7, 0xc0, 0xe3,
1210 0x87, 0xa1, 0x95, 0x1e, 0x97, 0x4d, 0xea, 0xa6,
1211 0xf7, 0x25, 0xac, 0x82, 0x2a, 0xd3, 0xa6, 0x99,
1212 0x75, 0xdd, 0xc1, 0x55, 0x32, 0x6b, 0xea, 0x33,
1213 0x88, 0xce, 0x06, 0xac, 0x15, 0x39, 0x19, 0xa3,
1214 0x59, 0xaf, 0x7a, 0x1f, 0xd9, 0x72, 0x5e, 0xf7,
1215 0x4c, 0xf3, 0x5d, 0x6b, 0xf2, 0x16, 0x92, 0xa8,
1216 0x9e, 0x3d, 0xd4, 0x4c, 0x72, 0x55, 0x4e, 0x4a,
1217 0xf7, 0x8b, 0x2f, 0x67, 0x5a, 0x90, 0xb7, 0xcf,
1218 0x16, 0xd3, 0x7b, 0x5a, 0x9a, 0xc8, 0x9f, 0xbf,
1219 0x01, 0x76, 0x3b, 0x86, 0x2c, 0x2a, 0x78, 0x10,
1220 0x70, 0x05, 0x38, 0xf9, 0xdd, 0x2a, 0x1d, 0x00,
1221 0x25, 0xb7, 0x10, 0xac, 0x3b, 0x3c, 0x4d, 0x3c,
1222 0x01, 0x68, 0x3c, 0x5a, 0x29, 0xc2, 0xa0, 0x1b,
1223 0x95, 0x67, 0xf9, 0x0a, 0x60, 0xb7, 0x11, 0x9c,
1224 0x40, 0x45, 0xd7, 0xb0, 0xda, 0x49, 0x87, 0xcd,
1225 0xb0, 0x9b, 0x61, 0x8c, 0xf4, 0x0d, 0x94, 0x1d,
1226 0x79, 0x66, 0x13, 0x0b, 0xc6, 0x6b, 0x19, 0xee,
1227 0xa0, 0x6b, 0x64, 0x7d, 0xc4, 0xff, 0x98, 0x72,
1228 0x60, 0xab, 0x7f, 0x0f, 0x4d, 0x5d, 0x6b, 0xc3,
1229 0xba, 0x5e, 0x0d, 0x04, 0xd9, 0x59, 0x17, 0xd0,
1230 0x64, 0xbe, 0xfb, 0x58, 0xfc, 0xed, 0x18, 0xf6,
1231 0xac, 0x19, 0xa4, 0xfd, 0x16, 0x59, 0x80, 0x58,
1232 0xb8, 0x0f, 0x79, 0x24, 0x60, 0x18, 0x62, 0xa9,
1233 0xa3, 0xa0, 0xe8, 0x81, 0xd6, 0xec, 0x5b, 0xfe,
1234 0x5b, 0xb8, 0xa4, 0x00, 0xa9, 0xd0, 0x90, 0x17,
1235 0xe5, 0x50, 0x3d, 0x2b, 0x12, 0x6e, 0x2a, 0x13,
1236 0x65, 0x7c, 0xdf, 0xdf, 0xa7, 0xdd, 0x9f, 0x78,
1237 0x5f, 0x8f, 0x4e, 0x90, 0xa6, 0x10, 0xe4, 0x7b,
1238 0x68, 0x6b, 0xfd, 0xa9, 0x6d, 0x47, 0xfa, 0xec,
1239 0x42, 0x35, 0x07, 0x12, 0x3e, 0x78, 0x23, 0x15,
1240 0xff, 0xe2, 0x65, 0xc7, 0x47, 0x89, 0x2f, 0x97,
1241 0x7c, 0xd7, 0x6b, 0x69, 0x35, 0x79, 0x6f, 0x85,
1242 0xb4, 0xa9, 0x75, 0x04, 0x32, 0x9a, 0xfe, 0xf0,
1243 0xce, 0xe3, 0xf1, 0xab, 0x15, 0x47, 0xe4, 0x9c,
1244 0xc1, 0x48, 0x32, 0x3c, 0xbe, 0x44, 0x72, 0xc9,
1245 0xaa, 0x50, 0x37, 0xa6, 0xbe, 0x41, 0xcf, 0xe8,
1246 0x17, 0x4e, 0x37, 0xbe, 0xf1, 0x34, 0x2c, 0xd9,
1247 0x60, 0x48, 0x09, 0xa5, 0x26, 0x00, 0x31, 0x77,
1248 0x4e, 0xac, 0x7c, 0x89, 0x75, 0xe3, 0xde, 0x26,
1249 0x4c, 0x32, 0x54, 0x27, 0x8e, 0x92, 0x26, 0x42,
1250 0x85, 0x76, 0x01, 0x76, 0x62, 0x4c, 0x29, 0xe9,
1251 0x38, 0x05, 0x51, 0x54, 0x97, 0xa3, 0x03, 0x59,
1252 0x5e, 0xec, 0x0c, 0xe4, 0x96, 0xb7, 0x15, 0xa8,
1253 0x41, 0x06, 0x2b, 0x78, 0x95, 0x24, 0xf6, 0x32,
1254 0xc5, 0xec, 0xd7, 0x89, 0x28, 0x1e, 0xec, 0xb1,
1255 0xc7, 0x21, 0x0c, 0xd3, 0x80, 0x7c, 0x5a, 0xe6,
1256 0xb1, 0x3a, 0x52, 0x33, 0x84, 0x4e, 0x32, 0x6e,
1257 0x7a, 0xf6, 0x43, 0x15, 0x5b, 0xa6, 0xba, 0xeb,
1258 0xa8, 0xe4, 0xff, 0x4f, 0xbd, 0xbd, 0xa8, 0x5e,
1259 0xbe, 0x27, 0xaf, 0xc5, 0xf7, 0x9e, 0xdf, 0x48,
1260 0x22, 0xca, 0x6a, 0x0b, 0x3c, 0xd7, 0xe0, 0xdc,
1261 0xf3, 0x71, 0x08, 0xdc, 0x28, 0x13, 0x08, 0xf2,
1262 0x08, 0x1d, 0x9d, 0x7b, 0xd9, 0xde, 0x6f, 0xe6,
1263 0xe8, 0x88, 0x18, 0xc2, 0xcd, 0x93, 0xc5, 0x38,
1264 0x21, 0x68, 0x4c, 0x9a, 0xfb, 0xb6, 0x18, 0x16,
1265 0x73, 0x2c, 0x1d, 0x6f, 0x95, 0xfb, 0x65, 0x4f,
1266 0x7c, 0xec, 0x8d, 0x6c, 0xa8, 0xc0, 0x55, 0x28,
1267 0xc6, 0xc3, 0xea, 0xeb, 0x05, 0xf5, 0x65, 0xeb,
1268 0x53, 0xe1, 0x54, 0xef, 0xb8, 0x64, 0x98, 0x2d,
1269 0x98, 0x9e, 0xc8, 0xfe, 0xa2, 0x07, 0x30, 0xf7,
1270 0xf7, 0xae, 0xdb, 0x32, 0xf8, 0x71, 0x9d, 0x06,
1271 0xdf, 0x9b, 0xda, 0x61, 0x7d, 0xdb, 0xae, 0x06,
1272 0x24, 0x63, 0x74, 0xb6, 0xf3, 0x1b, 0x66, 0x09,
1273 0x60, 0xff, 0x2b, 0x29, 0xf5, 0xa9, 0x9d, 0x61,
1274 0x5d, 0x55, 0x10, 0x82, 0x21, 0xbb, 0x64, 0x0d,
1275 0xef, 0x5c, 0xe3, 0x30, 0x1b, 0x60, 0x1e, 0x5b,
1276 0xfe, 0x6c, 0xf5, 0x15, 0xa3, 0x86, 0x27, 0x58,
1277 0x46, 0x00, 0x20, 0xcb, 0x86, 0x9a, 0x52, 0x29,
1278 0x20, 0x68, 0x4d, 0x67, 0x88, 0x70, 0xc2, 0x31,
1279 0xd8, 0xbb, 0xa5, 0xa7, 0x88, 0x7f, 0x66, 0xbc,
1280 0xaa, 0x0f, 0xe1, 0x78, 0x7b, 0x97, 0x3c, 0xb7,
1281 0xd7, 0xd8, 0x04, 0xe0, 0x09, 0x60, 0xc8, 0xd0,
1282 0x9e, 0xe5, 0x6b, 0x31, 0x7f, 0x88, 0xfe, 0xc3,
1283 0xfd, 0x89, 0xec, 0x76, 0x4b, 0xb3, 0xa7, 0x37,
1284 0x03, 0xb7, 0xc6, 0x10, 0x7c, 0x9d, 0x0c, 0x75,
1285 0xd3, 0x08, 0x14, 0x94, 0x03, 0x42, 0x25, 0x26,
1286 0x85, 0xf7, 0xf0, 0x90, 0x06, 0x3e, 0x6f, 0x60,
1287 0x52, 0x55, 0xd5, 0x0f, 0x79, 0x64, 0x69, 0x69,
1288 0x46, 0xf9, 0x7f, 0x7f, 0x03, 0xf1, 0x1f, 0xdb,
1289 0x39, 0x05, 0xba, 0x4a, 0x8f, 0x17, 0xe7, 0xba,
1290 0xe2, 0x07, 0x7c, 0x1d, 0x9e, 0xbc, 0x94, 0xc0,
1291 0x61, 0x59, 0x8e, 0x72, 0xaf, 0xfc, 0x99, 0xe4,
1292 0xd5, 0xa8, 0xee, 0x0a, 0x48, 0x2d, 0x82, 0x8b,
1293 0x34, 0x54, 0x8a, 0xce, 0xc7, 0xfa, 0xdd, 0xba,
1294 0x54, 0xdf, 0xb3, 0x30, 0x33, 0x73, 0x2e, 0xd5,
1295 0x52, 0xab, 0x49, 0x91, 0x4e, 0x0a, 0xd6, 0x2f,
1296 0x67, 0xe4, 0xdd, 0x64, 0x48, 0x16, 0xd9, 0x85,
1297 0xaa, 0x52, 0xa5, 0x0b, 0xd3, 0xb4, 0x2d, 0x77,
1298 0x5e, 0x52, 0x77, 0x17, 0xcf, 0xbe, 0x88, 0x04,
1299 0x01, 0x52, 0xe2, 0xf1, 0x46, 0xe2, 0x91, 0x30,
1300 0x65, 0xcf, 0xc0, 0x65, 0x45, 0xc3, 0x7e, 0xf4,
1301 0x2e, 0xb5, 0xaf, 0x6f, 0xab, 0x1a, 0xfa, 0x70,
1302 0x35, 0xb8, 0x4f, 0x2d, 0x78, 0x90, 0x33, 0xb5,
1303 0x9a, 0x67, 0xdb, 0x2f, 0x28, 0x32, 0xb6, 0x54,
1304 0xab, 0x4c, 0x6b, 0x85, 0xed, 0x6c, 0x3e, 0x05,
1305 0x2a, 0xc7, 0x32, 0xe8, 0xf5, 0xa3, 0x7b, 0x4e,
1306 0x7b, 0x58, 0x24, 0x73, 0xf7, 0xfd, 0xc7, 0xc8,
1307 0x6c, 0x71, 0x68, 0xb1, 0xf6, 0xc5, 0x9e, 0x1e,
1308 0xe3, 0x5c, 0x25, 0xc0, 0x5b, 0x3e, 0x59, 0xa1,
1309 0x18, 0x5a, 0xe8, 0xb5, 0xd1, 0x44, 0x13, 0xa3,
1310 0xe6, 0x05, 0x76, 0xd2, 0x8d, 0x6e, 0x54, 0x68,
1311 0x0c, 0xa4, 0x7b, 0x8b, 0xd3, 0x8c, 0x42, 0x13,
1312 0x87, 0xda, 0xdf, 0x8f, 0xa5, 0x83, 0x7a, 0x42,
1313 0x99, 0xb7, 0xeb, 0xe2, 0x79, 0xe0, 0xdb, 0xda,
1314 0x33, 0xa8, 0x50, 0x3a, 0xd7, 0xe7, 0xd3, 0x61,
1315 0x18, 0xb8, 0xaa, 0x2d, 0xc8, 0xd8, 0x2c, 0x28,
1316 0xe5, 0x97, 0x0a, 0x7c, 0x6c, 0x7f, 0x09, 0xd7,
1317 0x88, 0x80, 0xac, 0x12, 0xed, 0xf8, 0xc6, 0xb5,
1318 0x2d, 0xd6, 0x63, 0x9b, 0x98, 0x35, 0x26, 0xde,
1319 0xf6, 0x31, 0xee, 0x7e, 0xa0, 0xfb, 0x16, 0x98,
1320 0xb1, 0x96, 0x1d, 0xee, 0xe3, 0x2f, 0xfb, 0x41,
1321 0xdd, 0xea, 0x10, 0x1e, 0x03, 0x89, 0x18, 0xd2,
1322 0x47, 0x0c, 0xa0, 0x57, 0xda, 0x76, 0x3a, 0x37,
1323 0x2c, 0xe4, 0xf9, 0x77, 0xc8, 0x43, 0x5f, 0xcb,
1324 0xd6, 0x85, 0xf7, 0x22, 0xe4, 0x32, 0x25, 0xa8,
1325 0xdc, 0x21, 0xc0, 0xf5, 0x95, 0xb2, 0xf8, 0x83,
1326 0xf0, 0x65, 0x61, 0x15, 0x48, 0x94, 0xb7, 0x03,
1327 0x7f, 0x66, 0xa1, 0x39, 0x1f, 0xdd, 0xce, 0x96,
1328 0xfe, 0x58, 0x81, 0x3d, 0x41, 0x11, 0x87, 0x13,
1329 0x26, 0x1b, 0x6d, 0xf3, 0xca, 0x2e, 0x2c, 0x76,
1330 0xd3, 0x2f, 0x6d, 0x49, 0x70, 0x53, 0x05, 0x96,
1331 0xcc, 0x30, 0x2b, 0x83, 0xf2, 0xc6, 0xb2, 0x4b,
1332 0x22, 0x13, 0x95, 0x42, 0xeb, 0x56, 0x4d, 0x22,
1333 0xe6, 0x43, 0x6f, 0xba, 0xe7, 0x3b, 0xe5, 0x59,
1334 0xce, 0x57, 0x88, 0x85, 0xb6, 0xbf, 0x15, 0x37,
1335 0xb3, 0x7a, 0x7e, 0xc4, 0xbc, 0x99, 0xfc, 0xe4,
1336 0x89, 0x00, 0x68, 0x39, 0xbc, 0x5a, 0xba, 0xab,
1337 0x52, 0xab, 0xe6, 0x81, 0xfd, 0x93, 0x62, 0xe9,
1338 0xb7, 0x12, 0xd1, 0x18, 0x1a, 0xb9, 0x55, 0x4a,
1339 0x0f, 0xae, 0x35, 0x11, 0x04, 0x27, 0xf3, 0x42,
1340 0x4e, 0xca, 0xdf, 0x9f, 0x12, 0x62, 0xea, 0x03,
1341 0xc0, 0xa9, 0x22, 0x7b, 0x6c, 0x6c, 0xe3, 0xdf,
1342 0x16, 0xad, 0x03, 0xc9, 0xfe, 0xa4, 0xdd, 0x4f
1345 static const uint8_t AES_CBC_ciphertext_1792B[] = {
1346 0x59, 0xcc, 0xfe, 0x8f, 0xb4, 0x9d, 0x0e, 0xd1,
1347 0x85, 0xfc, 0x9b, 0x43, 0xc1, 0xb7, 0x54, 0x67,
1348 0x01, 0xef, 0xb8, 0x71, 0x36, 0xdb, 0x50, 0x48,
1349 0x7a, 0xea, 0xcf, 0xce, 0xba, 0x30, 0x10, 0x2e,
1350 0x96, 0x2b, 0xfd, 0xcf, 0x00, 0xe3, 0x1f, 0xac,
1351 0x66, 0x14, 0x30, 0x86, 0x49, 0xdb, 0x01, 0x8b,
1352 0x07, 0xdd, 0x00, 0x9d, 0x0d, 0x5c, 0x19, 0x11,
1353 0xe8, 0x44, 0x2b, 0x25, 0x70, 0xed, 0x7c, 0x33,
1354 0x0d, 0xe3, 0x34, 0x93, 0x63, 0xad, 0x26, 0xb1,
1355 0x11, 0x91, 0x34, 0x2e, 0x1d, 0x50, 0xaa, 0xd4,
1356 0xef, 0x3a, 0x6d, 0xd7, 0x33, 0x20, 0x0d, 0x3f,
1357 0x9b, 0xdd, 0xc3, 0xa5, 0xc5, 0xf1, 0x99, 0xdc,
1358 0xea, 0x52, 0xda, 0x55, 0xea, 0xa2, 0x7a, 0xc5,
1359 0x78, 0x44, 0x4a, 0x02, 0x33, 0x19, 0x62, 0x37,
1360 0xf8, 0x8b, 0xd1, 0x0c, 0x21, 0xdf, 0x40, 0x19,
1361 0x81, 0xea, 0xfb, 0x1c, 0xa7, 0xcc, 0x60, 0xfe,
1362 0x63, 0x25, 0x8f, 0xf3, 0x73, 0x0f, 0x45, 0xe6,
1363 0x6a, 0x18, 0xbf, 0xbe, 0xad, 0x92, 0x2a, 0x1e,
1364 0x15, 0x65, 0x6f, 0xef, 0x92, 0xcd, 0x0e, 0x19,
1365 0x3d, 0x42, 0xa8, 0xfc, 0x0d, 0x32, 0x58, 0xe0,
1366 0x56, 0x9f, 0xd6, 0x9b, 0x8b, 0xec, 0xe0, 0x45,
1367 0x4d, 0x7e, 0x73, 0x87, 0xff, 0x74, 0x92, 0x59,
1368 0x60, 0x13, 0x93, 0xda, 0xec, 0xbf, 0xfa, 0x20,
1369 0xb6, 0xe7, 0xdf, 0xc7, 0x10, 0xf5, 0x79, 0xb4,
1370 0xd7, 0xac, 0xaf, 0x2b, 0x37, 0x52, 0x30, 0x1d,
1371 0xbe, 0x0f, 0x60, 0x77, 0x3d, 0x03, 0x63, 0xa9,
1372 0xae, 0xb1, 0xf3, 0xca, 0xca, 0xb4, 0x21, 0xd7,
1373 0x6f, 0x2e, 0x5e, 0x9b, 0x68, 0x53, 0x80, 0xab,
1374 0x30, 0x23, 0x0a, 0x72, 0x6b, 0xb1, 0xd8, 0x25,
1375 0x5d, 0x3a, 0x62, 0x9b, 0x4f, 0x59, 0x3b, 0x79,
1376 0xa8, 0x9e, 0x08, 0x6d, 0x37, 0xb0, 0xfc, 0x42,
1377 0x51, 0x25, 0x86, 0xbd, 0x54, 0x5a, 0x95, 0x20,
1378 0x6c, 0xac, 0xb9, 0x30, 0x1c, 0x03, 0xc9, 0x49,
1379 0x38, 0x55, 0x31, 0x49, 0xed, 0xa9, 0x0e, 0xc3,
1380 0x65, 0xb4, 0x68, 0x6b, 0x07, 0x4c, 0x0a, 0xf9,
1381 0x21, 0x69, 0x7c, 0x9f, 0x28, 0x80, 0xe9, 0x49,
1382 0x22, 0x7c, 0xec, 0x97, 0xf7, 0x70, 0xb4, 0xb8,
1383 0x25, 0xe7, 0x80, 0x2c, 0x43, 0x24, 0x8a, 0x2e,
1384 0xac, 0xa2, 0x84, 0x20, 0xe7, 0xf4, 0x6b, 0x86,
1385 0x37, 0x05, 0xc7, 0x59, 0x04, 0x49, 0x2a, 0x99,
1386 0x80, 0x46, 0x32, 0x19, 0xe6, 0x30, 0xce, 0xc0,
1387 0xef, 0x6e, 0xec, 0xe5, 0x2f, 0x24, 0xc1, 0x78,
1388 0x45, 0x02, 0xd3, 0x64, 0x99, 0xf5, 0xc7, 0xbc,
1389 0x8f, 0x8c, 0x75, 0xb1, 0x0a, 0xc8, 0xc3, 0xbd,
1390 0x5e, 0x7e, 0xbd, 0x0e, 0xdf, 0x4b, 0x96, 0x6a,
1391 0xfd, 0x03, 0xdb, 0xd1, 0x31, 0x1e, 0x27, 0xf9,
1392 0xe5, 0x83, 0x9a, 0xfc, 0x13, 0x4c, 0xd3, 0x04,
1393 0xdb, 0xdb, 0x3f, 0x35, 0x93, 0x4e, 0x14, 0x6b,
1394 0x00, 0x5c, 0xb6, 0x11, 0x50, 0xee, 0x61, 0x5c,
1395 0x10, 0x5c, 0xd0, 0x90, 0x02, 0x2e, 0x12, 0xe0,
1396 0x50, 0x44, 0xad, 0x75, 0xcd, 0x94, 0xcf, 0x92,
1397 0xcb, 0xe3, 0xe8, 0x77, 0x4b, 0xd7, 0x1a, 0x7c,
1398 0xdd, 0x6b, 0x49, 0x21, 0x7c, 0xe8, 0x2c, 0x25,
1399 0x49, 0x86, 0x1e, 0x54, 0xae, 0xfc, 0x0e, 0x80,
1400 0xb1, 0xd5, 0xa5, 0x23, 0xcf, 0xcc, 0x0e, 0x11,
1401 0xe2, 0x7c, 0x3c, 0x25, 0x78, 0x64, 0x03, 0xa1,
1402 0xdd, 0x9f, 0x74, 0x12, 0x7b, 0x21, 0xb5, 0x73,
1403 0x15, 0x3c, 0xed, 0xad, 0x07, 0x62, 0x21, 0x79,
1404 0xd4, 0x2f, 0x0d, 0x72, 0xe9, 0x7c, 0x6b, 0x96,
1405 0x6e, 0xe5, 0x36, 0x4a, 0xd2, 0x38, 0xe1, 0xff,
1406 0x6e, 0x26, 0xa4, 0xac, 0x83, 0x07, 0xe6, 0x67,
1407 0x74, 0x6c, 0xec, 0x8b, 0x4b, 0x79, 0x33, 0x50,
1408 0x2f, 0x8f, 0xa0, 0x8f, 0xfa, 0x38, 0x6a, 0xa2,
1409 0x3a, 0x42, 0x85, 0x15, 0x90, 0xd0, 0xb3, 0x0d,
1410 0x8a, 0xe4, 0x60, 0x03, 0xef, 0xf9, 0x65, 0x8a,
1411 0x4e, 0x50, 0x8c, 0x65, 0xba, 0x61, 0x16, 0xc3,
1412 0x93, 0xb7, 0x75, 0x21, 0x98, 0x25, 0x60, 0x6e,
1413 0x3d, 0x68, 0xba, 0x7c, 0xe4, 0xf3, 0xd9, 0x9b,
1414 0xfb, 0x7a, 0xed, 0x1f, 0xb3, 0x4b, 0x88, 0x74,
1415 0x2c, 0xb8, 0x8c, 0x22, 0x95, 0xce, 0x90, 0xf1,
1416 0xdb, 0x80, 0xa6, 0x39, 0xae, 0x82, 0xa1, 0xef,
1417 0x75, 0xec, 0xfe, 0xf1, 0xe8, 0x04, 0xfd, 0x99,
1418 0x1b, 0x5f, 0x45, 0x87, 0x4f, 0xfa, 0xa2, 0x3e,
1419 0x3e, 0xb5, 0x01, 0x4b, 0x46, 0xeb, 0x13, 0x9a,
1420 0xe4, 0x7d, 0x03, 0x87, 0xb1, 0x59, 0x91, 0x8e,
1421 0x37, 0xd3, 0x16, 0xce, 0xef, 0x4b, 0xe9, 0x46,
1422 0x8d, 0x2a, 0x50, 0x2f, 0x41, 0xd3, 0x7b, 0xcf,
1423 0xf0, 0xb7, 0x8b, 0x65, 0x0f, 0xa3, 0x27, 0x10,
1424 0xe9, 0xa9, 0xe9, 0x2c, 0xbe, 0xbb, 0x82, 0xe3,
1425 0x7b, 0x0b, 0x81, 0x3e, 0xa4, 0x6a, 0x4f, 0x3b,
1426 0xd5, 0x61, 0xf8, 0x47, 0x04, 0x99, 0x5b, 0xff,
1427 0xf3, 0x14, 0x6e, 0x57, 0x5b, 0xbf, 0x1b, 0xb4,
1428 0x3f, 0xf9, 0x31, 0xf6, 0x95, 0xd5, 0x10, 0xa9,
1429 0x72, 0x28, 0x23, 0xa9, 0x6a, 0xa2, 0xcf, 0x7d,
1430 0xe3, 0x18, 0x95, 0xda, 0xbc, 0x6f, 0xe9, 0xd8,
1431 0xef, 0x49, 0x3f, 0xd3, 0xef, 0x1f, 0xe1, 0x50,
1432 0xe8, 0x8a, 0xc0, 0xce, 0xcc, 0xb7, 0x5e, 0x0e,
1433 0x8b, 0x95, 0x80, 0xfd, 0x58, 0x2a, 0x9b, 0xc8,
1434 0xb4, 0x17, 0x04, 0x46, 0x74, 0xd4, 0x68, 0x91,
1435 0x33, 0xc8, 0x31, 0x15, 0x84, 0x16, 0x35, 0x03,
1436 0x64, 0x6d, 0xa9, 0x4e, 0x20, 0xeb, 0xa9, 0x3f,
1437 0x21, 0x5e, 0x9b, 0x09, 0xc3, 0x45, 0xf8, 0x7c,
1438 0x59, 0x62, 0x29, 0x9a, 0x5c, 0xcf, 0xb4, 0x27,
1439 0x5e, 0x13, 0xea, 0xb3, 0xef, 0xd9, 0x01, 0x2a,
1440 0x65, 0x5f, 0x14, 0xf4, 0xbf, 0x28, 0x89, 0x3d,
1441 0xdd, 0x9d, 0x52, 0xbd, 0x9e, 0x5b, 0x3b, 0xd2,
1442 0xc2, 0x81, 0x35, 0xb6, 0xac, 0xdd, 0x27, 0xc3,
1443 0x7b, 0x01, 0x5a, 0x6d, 0x4c, 0x5e, 0x2c, 0x30,
1444 0xcb, 0x3a, 0xfa, 0xc1, 0xd7, 0x31, 0x67, 0x3e,
1445 0x08, 0x6a, 0xe8, 0x8c, 0x75, 0xac, 0x1a, 0x6a,
1446 0x52, 0xf7, 0x51, 0xcd, 0x85, 0x3f, 0x3c, 0xa7,
1447 0xea, 0xbc, 0xd7, 0x18, 0x9e, 0x27, 0x73, 0xe6,
1448 0x2b, 0x58, 0xb6, 0xd2, 0x29, 0x68, 0xd5, 0x8f,
1449 0x00, 0x4d, 0x55, 0xf6, 0x61, 0x5a, 0xcc, 0x51,
1450 0xa6, 0x5e, 0x85, 0xcb, 0x0b, 0xfd, 0x06, 0xca,
1451 0xf5, 0xbf, 0x0d, 0x13, 0x74, 0x78, 0x6d, 0x9e,
1452 0x20, 0x11, 0x84, 0x3e, 0x78, 0x17, 0x04, 0x4f,
1453 0x64, 0x2c, 0x3b, 0x3e, 0x93, 0x7b, 0x58, 0x33,
1454 0x07, 0x52, 0xf7, 0x60, 0x6a, 0xa8, 0x3b, 0x19,
1455 0x27, 0x7a, 0x93, 0xc5, 0x53, 0xad, 0xec, 0xf6,
1456 0xc8, 0x94, 0xee, 0x92, 0xea, 0xee, 0x7e, 0xea,
1457 0xb9, 0x5f, 0xac, 0x59, 0x5d, 0x2e, 0x78, 0x53,
1458 0x72, 0x81, 0x92, 0xdd, 0x1c, 0x63, 0xbe, 0x02,
1459 0xeb, 0xa8, 0x1b, 0x2a, 0x6e, 0x72, 0xe3, 0x2d,
1460 0x84, 0x0d, 0x8a, 0x22, 0xf6, 0xba, 0xab, 0x04,
1461 0x8e, 0x04, 0x24, 0xdb, 0xcc, 0xe2, 0x69, 0xeb,
1462 0x4e, 0xfa, 0x6b, 0x5b, 0xc8, 0xc0, 0xd9, 0x25,
1463 0xcb, 0x40, 0x8d, 0x4b, 0x8e, 0xa0, 0xd4, 0x72,
1464 0x98, 0x36, 0x46, 0x3b, 0x4f, 0x5f, 0x96, 0x84,
1465 0x03, 0x28, 0x86, 0x4d, 0xa1, 0x8a, 0xd7, 0xb2,
1466 0x5b, 0x27, 0x01, 0x80, 0x62, 0x49, 0x56, 0xb9,
1467 0xa0, 0xa1, 0xe3, 0x6e, 0x22, 0x2a, 0x5d, 0x03,
1468 0x86, 0x40, 0x36, 0x22, 0x5e, 0xd2, 0xe5, 0xc0,
1469 0x6b, 0xfa, 0xac, 0x80, 0x4e, 0x09, 0x99, 0xbc,
1470 0x2f, 0x9b, 0xcc, 0xf3, 0x4e, 0xf7, 0x99, 0x98,
1471 0x11, 0x6e, 0x6f, 0x62, 0x22, 0x6b, 0x92, 0x95,
1472 0x3b, 0xc3, 0xd2, 0x8e, 0x0f, 0x07, 0xc2, 0x51,
1473 0x5c, 0x4d, 0xb2, 0x6e, 0xc0, 0x27, 0x73, 0xcd,
1474 0x57, 0xb7, 0xf0, 0xe9, 0x2e, 0xc8, 0xe2, 0x0c,
1475 0xd1, 0xb5, 0x0f, 0xff, 0xf9, 0xec, 0x38, 0xba,
1476 0x97, 0xd6, 0x94, 0x9b, 0xd1, 0x79, 0xb6, 0x6a,
1477 0x01, 0x17, 0xe4, 0x7e, 0xa6, 0xd5, 0x86, 0x19,
1478 0xae, 0xf3, 0xf0, 0x62, 0x73, 0xc0, 0xf0, 0x0a,
1479 0x7a, 0x96, 0x93, 0x72, 0x89, 0x7e, 0x25, 0x57,
1480 0xf8, 0xf7, 0xd5, 0x1e, 0xe5, 0xac, 0xd6, 0x38,
1481 0x4f, 0xe8, 0x81, 0xd1, 0x53, 0x41, 0x07, 0x2d,
1482 0x58, 0x34, 0x1c, 0xef, 0x74, 0x2e, 0x61, 0xca,
1483 0xd3, 0xeb, 0xd6, 0x93, 0x0a, 0xf2, 0xf2, 0x86,
1484 0x9c, 0xe3, 0x7a, 0x52, 0xf5, 0x42, 0xf1, 0x8b,
1485 0x10, 0xf2, 0x25, 0x68, 0x7e, 0x61, 0xb1, 0x19,
1486 0xcf, 0x8f, 0x5a, 0x53, 0xb7, 0x68, 0x4f, 0x1a,
1487 0x71, 0xe9, 0x83, 0x91, 0x3a, 0x78, 0x0f, 0xf7,
1488 0xd4, 0x74, 0xf5, 0x06, 0xd2, 0x88, 0xb0, 0x06,
1489 0xe5, 0xc0, 0xfb, 0xb3, 0x91, 0xad, 0xc0, 0x84,
1490 0x31, 0xf2, 0x3a, 0xcf, 0x63, 0xe6, 0x4a, 0xd3,
1491 0x78, 0xbe, 0xde, 0x73, 0x3e, 0x02, 0x8e, 0xb8,
1492 0x3a, 0xf6, 0x55, 0xa7, 0xf8, 0x5a, 0xb5, 0x0e,
1493 0x0c, 0xc5, 0xe5, 0x66, 0xd5, 0xd2, 0x18, 0xf3,
1494 0xef, 0xa5, 0xc9, 0x68, 0x69, 0xe0, 0xcd, 0x00,
1495 0x33, 0x99, 0x6e, 0xea, 0xcb, 0x06, 0x7a, 0xe1,
1496 0xe1, 0x19, 0x0b, 0xe7, 0x08, 0xcd, 0x09, 0x1b,
1497 0x85, 0xec, 0xc4, 0xd4, 0x75, 0xf0, 0xd6, 0xfb,
1498 0x84, 0x95, 0x07, 0x44, 0xca, 0xa5, 0x2a, 0x6c,
1499 0xc2, 0x00, 0x58, 0x08, 0x87, 0x9e, 0x0a, 0xd4,
1500 0x06, 0xe2, 0x91, 0x5f, 0xb7, 0x1b, 0x11, 0xfa,
1501 0x85, 0xfc, 0x7c, 0xf2, 0x0f, 0x6e, 0x3c, 0x8a,
1502 0xe1, 0x0f, 0xa0, 0x33, 0x84, 0xce, 0x81, 0x4d,
1503 0x32, 0x4d, 0xeb, 0x41, 0xcf, 0x5a, 0x05, 0x60,
1504 0x47, 0x6c, 0x2a, 0xc4, 0x17, 0xd5, 0x16, 0x3a,
1505 0xe4, 0xe7, 0xab, 0x84, 0x94, 0x22, 0xff, 0x56,
1506 0xb0, 0x0c, 0x92, 0x6c, 0x19, 0x11, 0x4c, 0xb3,
1507 0xed, 0x58, 0x48, 0x84, 0x2a, 0xe2, 0x19, 0x2a,
1508 0xe1, 0xc0, 0x56, 0x82, 0x3c, 0x83, 0xb4, 0x58,
1509 0x2d, 0xf0, 0xb5, 0x1e, 0x76, 0x85, 0x51, 0xc2,
1510 0xe4, 0x95, 0x27, 0x96, 0xd1, 0x90, 0xc3, 0x17,
1511 0x75, 0xa1, 0xbb, 0x46, 0x5f, 0xa6, 0xf2, 0xef,
1512 0x71, 0x56, 0x92, 0xc5, 0x8a, 0x85, 0x52, 0xe4,
1513 0x63, 0x21, 0x6f, 0x55, 0x85, 0x2b, 0x6b, 0x0d,
1514 0xc9, 0x92, 0x77, 0x67, 0xe3, 0xff, 0x2a, 0x2b,
1515 0x90, 0x01, 0x3d, 0x74, 0x63, 0x04, 0x61, 0x3c,
1516 0x8e, 0xf8, 0xfc, 0x04, 0xdd, 0x21, 0x85, 0x92,
1517 0x1e, 0x4d, 0x51, 0x8d, 0xb5, 0x6b, 0xf1, 0xda,
1518 0x96, 0xf5, 0x8e, 0x3c, 0x38, 0x5a, 0xac, 0x9b,
1519 0xba, 0x0c, 0x84, 0x5d, 0x50, 0x12, 0xc7, 0xc5,
1520 0x7a, 0xcb, 0xb1, 0xfa, 0x16, 0x93, 0xdf, 0x98,
1521 0xda, 0x3f, 0x49, 0xa3, 0x94, 0x78, 0x70, 0xc7,
1522 0x0b, 0xb6, 0x91, 0xa6, 0x16, 0x2e, 0xcf, 0xfd,
1523 0x51, 0x6a, 0x5b, 0xad, 0x7a, 0xdd, 0xa9, 0x48,
1524 0x48, 0xac, 0xd6, 0x45, 0xbc, 0x23, 0x31, 0x1d,
1525 0x86, 0x54, 0x8a, 0x7f, 0x04, 0x97, 0x71, 0x9e,
1526 0xbc, 0x2e, 0x6b, 0xd9, 0x33, 0xc8, 0x20, 0xc9,
1527 0xe0, 0x25, 0x86, 0x59, 0x15, 0xcf, 0x63, 0xe5,
1528 0x99, 0xf1, 0x24, 0xf1, 0xba, 0xc4, 0x15, 0x02,
1529 0xe2, 0xdb, 0xfe, 0x4a, 0xf8, 0x3b, 0x91, 0x13,
1530 0x8d, 0x03, 0x81, 0x9f, 0xb3, 0x3f, 0x04, 0x03,
1531 0x58, 0xc0, 0xef, 0x27, 0x82, 0x14, 0xd2, 0x7f,
1532 0x93, 0x70, 0xb7, 0xb2, 0x02, 0x21, 0xb3, 0x07,
1533 0x7f, 0x1c, 0xef, 0x88, 0xee, 0x29, 0x7a, 0x0b,
1534 0x3d, 0x75, 0x5a, 0x93, 0xfe, 0x7f, 0x14, 0xf7,
1535 0x4e, 0x4b, 0x7f, 0x21, 0x02, 0xad, 0xf9, 0x43,
1536 0x29, 0x1a, 0xe8, 0x1b, 0xf5, 0x32, 0xb2, 0x96,
1537 0xe6, 0xe8, 0x96, 0x20, 0x9b, 0x96, 0x8e, 0x7b,
1538 0xfe, 0xd8, 0xc9, 0x9c, 0x65, 0x16, 0xd6, 0x68,
1539 0x95, 0xf8, 0x22, 0xe2, 0xae, 0x84, 0x03, 0xfd,
1540 0x87, 0xa2, 0x72, 0x79, 0x74, 0x95, 0xfa, 0xe1,
1541 0xfe, 0xd0, 0x4e, 0x3d, 0x39, 0x2e, 0x67, 0x55,
1542 0x71, 0x6c, 0x89, 0x33, 0x49, 0x0c, 0x1b, 0x46,
1543 0x92, 0x31, 0x6f, 0xa6, 0xf0, 0x09, 0xbd, 0x2d,
1544 0xe2, 0xca, 0xda, 0x18, 0x33, 0xce, 0x67, 0x37,
1545 0xfd, 0x6f, 0xcb, 0x9d, 0xbd, 0x42, 0xbc, 0xb2,
1546 0x9c, 0x28, 0xcd, 0x65, 0x3c, 0x61, 0xbc, 0xde,
1547 0x9d, 0xe1, 0x2a, 0x3e, 0xbf, 0xee, 0x3c, 0xcb,
1548 0xb1, 0x50, 0xa9, 0x2c, 0xbe, 0xb5, 0x43, 0xd0,
1549 0xec, 0x29, 0xf9, 0x16, 0x6f, 0x31, 0xd9, 0x9b,
1550 0x92, 0xb1, 0x32, 0xae, 0x0f, 0xb6, 0x9d, 0x0e,
1551 0x25, 0x7f, 0x89, 0x1f, 0x1d, 0x01, 0x68, 0xab,
1552 0x3d, 0xd1, 0x74, 0x5b, 0x4c, 0x38, 0x7f, 0x3d,
1553 0x33, 0xa5, 0xa2, 0x9f, 0xda, 0x84, 0xa5, 0x82,
1554 0x2d, 0x16, 0x66, 0x46, 0x08, 0x30, 0x14, 0x48,
1555 0x5e, 0xca, 0xe3, 0xf4, 0x8c, 0xcb, 0x32, 0xc6,
1556 0xf1, 0x43, 0x62, 0xc6, 0xef, 0x16, 0xfa, 0x43,
1557 0xae, 0x9c, 0x53, 0xe3, 0x49, 0x45, 0x80, 0xfd,
1558 0x1d, 0x8c, 0xa9, 0x6d, 0x77, 0x76, 0xaa, 0x40,
1559 0xc4, 0x4e, 0x7b, 0x78, 0x6b, 0xe0, 0x1d, 0xce,
1560 0x56, 0x3d, 0xf0, 0x11, 0xfe, 0x4f, 0x6a, 0x6d,
1561 0x0f, 0x4f, 0x90, 0x38, 0x92, 0x17, 0xfa, 0x56,
1562 0x12, 0xa6, 0xa1, 0x0a, 0xea, 0x2f, 0x50, 0xf9,
1563 0x60, 0x66, 0x6c, 0x7d, 0x5a, 0x08, 0x8e, 0x3c,
1564 0xf3, 0xf0, 0x33, 0x02, 0x11, 0x02, 0xfe, 0x4c,
1565 0x56, 0x2b, 0x9f, 0x0c, 0xbd, 0x65, 0x8a, 0x83,
1566 0xde, 0x7c, 0x05, 0x26, 0x93, 0x19, 0xcc, 0xf3,
1567 0x71, 0x0e, 0xad, 0x2f, 0xb3, 0xc9, 0x38, 0x50,
1568 0x64, 0xd5, 0x4c, 0x60, 0x5f, 0x02, 0x13, 0x34,
1569 0xc9, 0x75, 0xc4, 0x60, 0xab, 0x2e, 0x17, 0x7d
1572 static const uint8_t AES_CBC_ciphertext_2048B[] = {
1573 0x8b, 0x55, 0xbd, 0xfd, 0x2b, 0x35, 0x76, 0x5c,
1574 0xd1, 0x90, 0xd7, 0x6a, 0x63, 0x1e, 0x39, 0x71,
1575 0x0d, 0x5c, 0xd8, 0x03, 0x00, 0x75, 0xf1, 0x07,
1576 0x03, 0x8d, 0x76, 0xeb, 0x3b, 0x00, 0x1e, 0x33,
1577 0x88, 0xfc, 0x8f, 0x08, 0x4d, 0x33, 0xf1, 0x3c,
1578 0xee, 0xd0, 0x5d, 0x19, 0x8b, 0x3c, 0x50, 0x86,
1579 0xfd, 0x8d, 0x58, 0x21, 0xb4, 0xae, 0x0f, 0x81,
1580 0xe9, 0x9f, 0xc9, 0xc0, 0x90, 0xf7, 0x04, 0x6f,
1581 0x39, 0x1d, 0x8a, 0x3f, 0x8d, 0x32, 0x23, 0xb5,
1582 0x1f, 0xcc, 0x8a, 0x12, 0x2d, 0x46, 0x82, 0x5e,
1583 0x6a, 0x34, 0x8c, 0xb1, 0x93, 0x70, 0x3b, 0xde,
1584 0x55, 0xaf, 0x16, 0x35, 0x99, 0x84, 0xd5, 0x88,
1585 0xc9, 0x54, 0xb1, 0xb2, 0xd3, 0xeb, 0x9e, 0x55,
1586 0x9a, 0xa9, 0xa7, 0xf5, 0xda, 0x29, 0xcf, 0xe1,
1587 0x98, 0x64, 0x45, 0x77, 0xf2, 0x12, 0x69, 0x8f,
1588 0x78, 0xd8, 0x82, 0x41, 0xb2, 0x9f, 0xe2, 0x1c,
1589 0x63, 0x9b, 0x24, 0x81, 0x67, 0x95, 0xa2, 0xff,
1590 0x26, 0x9d, 0x65, 0x48, 0x61, 0x30, 0x66, 0x41,
1591 0x68, 0x84, 0xbb, 0x59, 0x14, 0x8e, 0x9a, 0x62,
1592 0xb6, 0xca, 0xda, 0xbe, 0x7c, 0x41, 0x52, 0x6e,
1593 0x1b, 0x86, 0xbf, 0x08, 0xeb, 0x37, 0x84, 0x60,
1594 0xe4, 0xc4, 0x1e, 0xa8, 0x4c, 0x84, 0x60, 0x2f,
1595 0x70, 0x90, 0xf2, 0x26, 0xe7, 0x65, 0x0c, 0xc4,
1596 0x58, 0x36, 0x8e, 0x4d, 0xdf, 0xff, 0x9a, 0x39,
1597 0x93, 0x01, 0xcf, 0x6f, 0x6d, 0xde, 0xef, 0x79,
1598 0xb0, 0xce, 0xe2, 0x98, 0xdb, 0x85, 0x8d, 0x62,
1599 0x9d, 0xb9, 0x63, 0xfd, 0xf0, 0x35, 0xb5, 0xa9,
1600 0x1b, 0xf9, 0xe5, 0xd4, 0x2e, 0x22, 0x2d, 0xcc,
1601 0x42, 0xbf, 0x0e, 0x51, 0xf7, 0x15, 0x07, 0x32,
1602 0x75, 0x5b, 0x74, 0xbb, 0x00, 0xef, 0xd4, 0x66,
1603 0x8b, 0xad, 0x71, 0x53, 0x94, 0xd7, 0x7d, 0x2c,
1604 0x40, 0x3e, 0x69, 0xa0, 0x4c, 0x86, 0x5e, 0x06,
1605 0xed, 0xdf, 0x22, 0xe2, 0x24, 0x25, 0x4e, 0x9b,
1606 0x5f, 0x49, 0x74, 0xba, 0xed, 0xb1, 0xa6, 0xeb,
1607 0xae, 0x3f, 0xc6, 0x9e, 0x0b, 0x29, 0x28, 0x9a,
1608 0xb6, 0xb2, 0x74, 0x58, 0xec, 0xa6, 0x4a, 0xed,
1609 0xe5, 0x10, 0x00, 0x85, 0xe1, 0x63, 0x41, 0x61,
1610 0x30, 0x7c, 0x97, 0xcf, 0x75, 0xcf, 0xb6, 0xf3,
1611 0xf7, 0xda, 0x35, 0x3f, 0x85, 0x8c, 0x64, 0xca,
1612 0xb7, 0xea, 0x7f, 0xe4, 0xa3, 0x4d, 0x30, 0x84,
1613 0x8c, 0x9c, 0x80, 0x5a, 0x50, 0xa5, 0x64, 0xae,
1614 0x26, 0xd3, 0xb5, 0x01, 0x73, 0x36, 0x8a, 0x92,
1615 0x49, 0xc4, 0x1a, 0x94, 0x81, 0x9d, 0xf5, 0x6c,
1616 0x50, 0xe1, 0x58, 0x0b, 0x75, 0xdd, 0x6b, 0x6a,
1617 0xca, 0x69, 0xea, 0xc3, 0x33, 0x90, 0x9f, 0x3b,
1618 0x65, 0x5d, 0x5e, 0xee, 0x31, 0xb7, 0x32, 0xfd,
1619 0x56, 0x83, 0xb6, 0xfb, 0xa8, 0x04, 0xfc, 0x1e,
1620 0x11, 0xfb, 0x02, 0x23, 0x53, 0x49, 0x45, 0xb1,
1621 0x07, 0xfc, 0xba, 0xe7, 0x5f, 0x5d, 0x2d, 0x7f,
1622 0x9e, 0x46, 0xba, 0xe9, 0xb0, 0xdb, 0x32, 0x04,
1623 0xa4, 0xa7, 0x98, 0xab, 0x91, 0xcd, 0x02, 0x05,
1624 0xf5, 0x74, 0x31, 0x98, 0x83, 0x3d, 0x33, 0x11,
1625 0x0e, 0xe3, 0x8d, 0xa8, 0xc9, 0x0e, 0xf3, 0xb9,
1626 0x47, 0x67, 0xe9, 0x79, 0x2b, 0x34, 0xcd, 0x9b,
1627 0x45, 0x75, 0x29, 0xf0, 0xbf, 0xcc, 0xda, 0x3a,
1628 0x91, 0xb2, 0x15, 0x27, 0x7a, 0xe5, 0xf5, 0x6a,
1629 0x5e, 0xbe, 0x2c, 0x98, 0xe8, 0x40, 0x96, 0x4f,
1630 0x8a, 0x09, 0xfd, 0xf6, 0xb2, 0xe7, 0x45, 0xb6,
1631 0x08, 0xc1, 0x69, 0xe1, 0xb3, 0xc4, 0x24, 0x34,
1632 0x07, 0x85, 0xd5, 0xa9, 0x78, 0xca, 0xfa, 0x4b,
1633 0x01, 0x19, 0x4d, 0x95, 0xdc, 0xa5, 0xc1, 0x9c,
1634 0xec, 0x27, 0x5b, 0xa6, 0x54, 0x25, 0xbd, 0xc8,
1635 0x0a, 0xb7, 0x11, 0xfb, 0x4e, 0xeb, 0x65, 0x2e,
1636 0xe1, 0x08, 0x9c, 0x3a, 0x45, 0x44, 0x33, 0xef,
1637 0x0d, 0xb9, 0xff, 0x3e, 0x68, 0x9c, 0x61, 0x2b,
1638 0x11, 0xb8, 0x5c, 0x47, 0x0f, 0x94, 0xf2, 0xf8,
1639 0x0b, 0xbb, 0x99, 0x18, 0x85, 0xa3, 0xba, 0x44,
1640 0xf3, 0x79, 0xb3, 0x63, 0x2c, 0x1f, 0x2a, 0x35,
1641 0x3b, 0x23, 0x98, 0xab, 0xf4, 0x16, 0x36, 0xf8,
1642 0xde, 0x86, 0xa4, 0xd4, 0x75, 0xff, 0x51, 0xf9,
1643 0xeb, 0x42, 0x5f, 0x55, 0xe2, 0xbe, 0xd1, 0x5b,
1644 0xb5, 0x38, 0xeb, 0xb4, 0x4d, 0xec, 0xec, 0x99,
1645 0xe1, 0x39, 0x43, 0xaa, 0x64, 0xf7, 0xc9, 0xd8,
1646 0xf2, 0x9a, 0x71, 0x43, 0x39, 0x17, 0xe8, 0xa8,
1647 0xa2, 0xe2, 0xa4, 0x2c, 0x18, 0x11, 0x49, 0xdf,
1648 0x18, 0xdd, 0x85, 0x6e, 0x65, 0x96, 0xe2, 0xba,
1649 0xa1, 0x0a, 0x2c, 0xca, 0xdc, 0x5f, 0xe4, 0xf4,
1650 0x35, 0x03, 0xb2, 0xa9, 0xda, 0xcf, 0xb7, 0x6d,
1651 0x65, 0x82, 0x82, 0x67, 0x9d, 0x0e, 0xf3, 0xe8,
1652 0x85, 0x6c, 0x69, 0xb8, 0x4c, 0xa6, 0xc6, 0x2e,
1653 0x40, 0xb5, 0x54, 0x28, 0x95, 0xe4, 0x57, 0xe0,
1654 0x5b, 0xf8, 0xde, 0x59, 0xe0, 0xfd, 0x89, 0x48,
1655 0xac, 0x56, 0x13, 0x54, 0xb9, 0x1b, 0xf5, 0x59,
1656 0x97, 0xb6, 0xb3, 0xe8, 0xac, 0x2d, 0xfc, 0xd2,
1657 0xea, 0x57, 0x96, 0x57, 0xa8, 0x26, 0x97, 0x2c,
1658 0x01, 0x89, 0x56, 0xea, 0xec, 0x8c, 0x53, 0xd5,
1659 0xd7, 0x9e, 0xc9, 0x98, 0x0b, 0xad, 0x03, 0x75,
1660 0xa0, 0x6e, 0x98, 0x8b, 0x97, 0x8d, 0x8d, 0x85,
1661 0x7d, 0x74, 0xa7, 0x2d, 0xde, 0x67, 0x0c, 0xcd,
1662 0x54, 0xb8, 0x15, 0x7b, 0xeb, 0xf5, 0x84, 0xb9,
1663 0x78, 0xab, 0xd8, 0x68, 0x91, 0x1f, 0x6a, 0xa6,
1664 0x28, 0x22, 0xf7, 0x00, 0x49, 0x00, 0xbe, 0x41,
1665 0x71, 0x0a, 0xf5, 0xe7, 0x9f, 0xb4, 0x11, 0x41,
1666 0x3f, 0xcd, 0xa9, 0xa9, 0x01, 0x8b, 0x6a, 0xeb,
1667 0x54, 0x4c, 0x58, 0x92, 0x68, 0x02, 0x0e, 0xe9,
1668 0xed, 0x65, 0x4c, 0xfb, 0x95, 0x48, 0x58, 0xa2,
1669 0xaa, 0x57, 0x69, 0x13, 0x82, 0x0c, 0x2c, 0x4b,
1670 0x5d, 0x4e, 0x18, 0x30, 0xef, 0x1c, 0xb1, 0x9d,
1671 0x05, 0x05, 0x02, 0x1c, 0x97, 0xc9, 0x48, 0xfe,
1672 0x5e, 0x7b, 0x77, 0xa3, 0x1f, 0x2a, 0x81, 0x42,
1673 0xf0, 0x4b, 0x85, 0x12, 0x9c, 0x1f, 0x44, 0xb1,
1674 0x14, 0x91, 0x92, 0x65, 0x77, 0xb1, 0x87, 0xa2,
1675 0xfc, 0xa4, 0xe7, 0xd2, 0x9b, 0xf2, 0x17, 0xf0,
1676 0x30, 0x1c, 0x8d, 0x33, 0xbc, 0x25, 0x28, 0x48,
1677 0xfd, 0x30, 0x79, 0x0a, 0x99, 0x3e, 0xb4, 0x0f,
1678 0x1e, 0xa6, 0x68, 0x76, 0x19, 0x76, 0x29, 0xac,
1679 0x5d, 0xb8, 0x1e, 0x42, 0xd6, 0x85, 0x04, 0xbf,
1680 0x64, 0x1c, 0x2d, 0x53, 0xe9, 0x92, 0x78, 0xf8,
1681 0xc3, 0xda, 0x96, 0x92, 0x10, 0x6f, 0x45, 0x85,
1682 0xaf, 0x5e, 0xcc, 0xa8, 0xc0, 0xc6, 0x2e, 0x73,
1683 0x51, 0x3f, 0x5e, 0xd7, 0x52, 0x33, 0x71, 0x12,
1684 0x6d, 0x85, 0xee, 0xea, 0x85, 0xa8, 0x48, 0x2b,
1685 0x40, 0x64, 0x6d, 0x28, 0x73, 0x16, 0xd7, 0x82,
1686 0xd9, 0x90, 0xed, 0x1f, 0xa7, 0x5c, 0xb1, 0x5c,
1687 0x27, 0xb9, 0x67, 0x8b, 0xb4, 0x17, 0x13, 0x83,
1688 0x5f, 0x09, 0x72, 0x0a, 0xd7, 0xa0, 0xec, 0x81,
1689 0x59, 0x19, 0xb9, 0xa6, 0x5a, 0x37, 0x34, 0x14,
1690 0x47, 0xf6, 0xe7, 0x6c, 0xd2, 0x09, 0x10, 0xe7,
1691 0xdd, 0xbb, 0x02, 0xd1, 0x28, 0xfa, 0x01, 0x2c,
1692 0x93, 0x64, 0x2e, 0x1b, 0x4c, 0x02, 0x52, 0xcb,
1693 0x07, 0xa1, 0xb6, 0x46, 0x02, 0x80, 0xd9, 0x8f,
1694 0x5c, 0x62, 0xbe, 0x78, 0x9e, 0x75, 0xc4, 0x97,
1695 0x91, 0x39, 0x12, 0x65, 0xb9, 0x3b, 0xc2, 0xd1,
1696 0xaf, 0xf2, 0x1f, 0x4e, 0x4d, 0xd1, 0xf0, 0x9f,
1697 0xb7, 0x12, 0xfd, 0xe8, 0x75, 0x18, 0xc0, 0x9d,
1698 0x8c, 0x70, 0xff, 0x77, 0x05, 0xb6, 0x1a, 0x1f,
1699 0x96, 0x48, 0xf6, 0xfe, 0xd5, 0x5d, 0x98, 0xa5,
1700 0x72, 0x1c, 0x84, 0x76, 0x3e, 0xb8, 0x87, 0x37,
1701 0xdd, 0xd4, 0x3a, 0x45, 0xdd, 0x09, 0xd8, 0xe7,
1702 0x09, 0x2f, 0x3e, 0x33, 0x9e, 0x7b, 0x8c, 0xe4,
1703 0x85, 0x12, 0x4e, 0xf8, 0x06, 0xb7, 0xb1, 0x85,
1704 0x24, 0x96, 0xd8, 0xfe, 0x87, 0x92, 0x81, 0xb1,
1705 0xa3, 0x38, 0xb9, 0x56, 0xe1, 0xf6, 0x36, 0x41,
1706 0xbb, 0xd6, 0x56, 0x69, 0x94, 0x57, 0xb3, 0xa4,
1707 0xca, 0xa4, 0xe1, 0x02, 0x3b, 0x96, 0x71, 0xe0,
1708 0xb2, 0x2f, 0x85, 0x48, 0x1b, 0x4a, 0x41, 0x80,
1709 0x4b, 0x9c, 0xe0, 0xc9, 0x39, 0xb8, 0xb1, 0xca,
1710 0x64, 0x77, 0x46, 0x58, 0xe6, 0x84, 0xd5, 0x2b,
1711 0x65, 0xce, 0xe9, 0x09, 0xa3, 0xaa, 0xfb, 0x83,
1712 0xa9, 0x28, 0x68, 0xfd, 0xcd, 0xfd, 0x76, 0x83,
1713 0xe1, 0x20, 0x22, 0x77, 0x3a, 0xa3, 0xb2, 0x93,
1714 0x14, 0x91, 0xfc, 0xe2, 0x17, 0x63, 0x2b, 0xa6,
1715 0x29, 0x38, 0x7b, 0x9b, 0x8b, 0x15, 0x77, 0xd6,
1716 0xaa, 0x92, 0x51, 0x53, 0x50, 0xff, 0xa0, 0x35,
1717 0xa0, 0x59, 0x7d, 0xf0, 0x11, 0x23, 0x49, 0xdf,
1718 0x5a, 0x21, 0xc2, 0xfe, 0x35, 0xa0, 0x1d, 0xe2,
1719 0xae, 0xa2, 0x8a, 0x61, 0x5b, 0xf7, 0xf1, 0x1c,
1720 0x1c, 0xec, 0xc4, 0xf6, 0xdc, 0xaa, 0xc8, 0xc2,
1721 0xe5, 0xa1, 0x2e, 0x14, 0xe5, 0xc6, 0xc9, 0x73,
1722 0x03, 0x78, 0xeb, 0xed, 0xe0, 0x3e, 0xc5, 0xf4,
1723 0xf1, 0x50, 0xb2, 0x01, 0x91, 0x96, 0xf5, 0xbb,
1724 0xe1, 0x32, 0xcd, 0xa8, 0x66, 0xbf, 0x73, 0x85,
1725 0x94, 0xd6, 0x7e, 0x68, 0xc5, 0xe4, 0xed, 0xd5,
1726 0xe3, 0x67, 0x4c, 0xa5, 0xb3, 0x1f, 0xdf, 0xf8,
1727 0xb3, 0x73, 0x5a, 0xac, 0xeb, 0x46, 0x16, 0x24,
1728 0xab, 0xca, 0xa4, 0xdd, 0x87, 0x0e, 0x24, 0x83,
1729 0x32, 0x04, 0x4c, 0xd8, 0xda, 0x7d, 0xdc, 0xe3,
1730 0x01, 0x93, 0xf3, 0xc1, 0x5b, 0xbd, 0xc3, 0x1d,
1731 0x40, 0x62, 0xde, 0x94, 0x03, 0x85, 0x91, 0x2a,
1732 0xa0, 0x25, 0x10, 0xd3, 0x32, 0x9f, 0x93, 0x00,
1733 0xa7, 0x8a, 0xfa, 0x77, 0x7c, 0xaf, 0x4d, 0xc8,
1734 0x7a, 0xf3, 0x16, 0x2b, 0xba, 0xeb, 0x74, 0x51,
1735 0xb8, 0xdd, 0x32, 0xad, 0x68, 0x7d, 0xdd, 0xca,
1736 0x60, 0x98, 0xc9, 0x9b, 0xb6, 0x5d, 0x4d, 0x3a,
1737 0x66, 0x8a, 0xbe, 0x05, 0xf9, 0x0c, 0xc5, 0xba,
1738 0x52, 0x82, 0x09, 0x1f, 0x5a, 0x66, 0x89, 0x69,
1739 0xa3, 0x5d, 0x93, 0x50, 0x7d, 0x44, 0xc3, 0x2a,
1740 0xb8, 0xab, 0xec, 0xa6, 0x5a, 0xae, 0x4a, 0x6a,
1741 0xcd, 0xfd, 0xb6, 0xff, 0x3d, 0x98, 0x05, 0xd9,
1742 0x5b, 0x29, 0xc4, 0x6f, 0xe0, 0x76, 0xe2, 0x3f,
1743 0xec, 0xd7, 0xa4, 0x91, 0x63, 0xf5, 0x4e, 0x4b,
1744 0xab, 0x20, 0x8c, 0x3a, 0x41, 0xed, 0x8b, 0x4b,
1745 0xb9, 0x01, 0x21, 0xc0, 0x6d, 0xfd, 0x70, 0x5b,
1746 0x20, 0x92, 0x41, 0x89, 0x74, 0xb7, 0xe9, 0x8b,
1747 0xfc, 0x6d, 0x17, 0x3f, 0x7f, 0x89, 0x3d, 0x6b,
1748 0x8f, 0xbc, 0xd2, 0x57, 0xe9, 0xc9, 0x6e, 0xa7,
1749 0x19, 0x26, 0x18, 0xad, 0xef, 0xb5, 0x87, 0xbf,
1750 0xb8, 0xa8, 0xd6, 0x7d, 0xdd, 0x5f, 0x94, 0x54,
1751 0x09, 0x92, 0x2b, 0xf5, 0x04, 0xf7, 0x36, 0x69,
1752 0x8e, 0xf4, 0xdc, 0x1d, 0x6e, 0x55, 0xbb, 0xe9,
1753 0x13, 0x05, 0x83, 0x35, 0x9c, 0xed, 0xcf, 0x8c,
1754 0x26, 0x8c, 0x7b, 0xc7, 0x0b, 0xba, 0xfd, 0xe2,
1755 0x84, 0x5c, 0x2a, 0x79, 0x43, 0x99, 0xb2, 0xc3,
1756 0x82, 0x87, 0xc8, 0xcd, 0x37, 0x6d, 0xa1, 0x2b,
1757 0x39, 0xb2, 0x38, 0x99, 0xd9, 0xfc, 0x02, 0x15,
1758 0x55, 0x21, 0x62, 0x59, 0xeb, 0x00, 0x86, 0x08,
1759 0x20, 0xbe, 0x1a, 0x62, 0x4d, 0x7e, 0xdf, 0x68,
1760 0x73, 0x5b, 0x5f, 0xaf, 0x84, 0x96, 0x2e, 0x1f,
1761 0x6b, 0x03, 0xc9, 0xa6, 0x75, 0x18, 0xe9, 0xd4,
1762 0xbd, 0xc8, 0xec, 0x9a, 0x5a, 0xb3, 0x99, 0xab,
1763 0x5f, 0x7c, 0x08, 0x7f, 0x69, 0x4d, 0x52, 0xa2,
1764 0x30, 0x17, 0x3b, 0x16, 0x15, 0x1b, 0x11, 0x62,
1765 0x3e, 0x80, 0x4b, 0x85, 0x7c, 0x9c, 0xd1, 0x3a,
1766 0x13, 0x01, 0x5e, 0x45, 0xf1, 0xc8, 0x5f, 0xcd,
1767 0x0e, 0x21, 0xf5, 0x82, 0xd4, 0x7b, 0x5c, 0x45,
1768 0x27, 0x6b, 0xef, 0xfe, 0xb8, 0xc0, 0x6f, 0xdc,
1769 0x60, 0x7b, 0xe4, 0xd5, 0x75, 0x71, 0xe6, 0xe8,
1770 0x7d, 0x6b, 0x6d, 0x80, 0xaf, 0x76, 0x41, 0x58,
1771 0xb7, 0xac, 0xb7, 0x13, 0x2f, 0x81, 0xcc, 0xf9,
1772 0x19, 0x97, 0xe8, 0xee, 0x40, 0x91, 0xfc, 0x89,
1773 0x13, 0x1e, 0x67, 0x9a, 0xdb, 0x8f, 0x8f, 0xc7,
1774 0x4a, 0xc9, 0xaf, 0x2f, 0x67, 0x01, 0x3c, 0xb8,
1775 0xa8, 0x3e, 0x78, 0x93, 0x1b, 0xdf, 0xbb, 0x34,
1776 0x0b, 0x1a, 0xfa, 0xc2, 0x2d, 0xc5, 0x1c, 0xec,
1777 0x97, 0x4f, 0x48, 0x41, 0x15, 0x0e, 0x75, 0xed,
1778 0x66, 0x8c, 0x17, 0x7f, 0xb1, 0x48, 0x13, 0xc1,
1779 0xfb, 0x60, 0x06, 0xf9, 0x72, 0x41, 0x3e, 0xcf,
1780 0x6e, 0xb6, 0xc8, 0xeb, 0x4b, 0x5a, 0xd2, 0x0c,
1781 0x28, 0xda, 0x02, 0x7a, 0x46, 0x21, 0x42, 0xb5,
1782 0x34, 0xda, 0xcb, 0x5e, 0xbd, 0x66, 0x5c, 0xca,
1783 0xff, 0x52, 0x43, 0x89, 0xf9, 0x10, 0x9a, 0x9e,
1784 0x9b, 0xe3, 0xb0, 0x51, 0xe9, 0xf3, 0x0a, 0x35,
1785 0x77, 0x54, 0xcc, 0xac, 0xa6, 0xf1, 0x2e, 0x36,
1786 0x89, 0xac, 0xc5, 0xc6, 0x62, 0x5a, 0xc0, 0x6d,
1787 0xc4, 0xe1, 0xf7, 0x64, 0x30, 0xff, 0x11, 0x40,
1788 0x13, 0x89, 0xd8, 0xd7, 0x73, 0x3f, 0x93, 0x08,
1789 0x68, 0xab, 0x66, 0x09, 0x1a, 0xea, 0x78, 0xc9,
1790 0x52, 0xf2, 0xfd, 0x93, 0x1b, 0x94, 0xbe, 0x5c,
1791 0xe5, 0x00, 0x6e, 0x00, 0xb9, 0xea, 0x27, 0xaa,
1792 0xb3, 0xee, 0xe3, 0xc8, 0x6a, 0xb0, 0xc1, 0x8e,
1793 0x9b, 0x54, 0x40, 0x10, 0x96, 0x06, 0xe8, 0xb3,
1794 0xf5, 0x55, 0x77, 0xd7, 0x5c, 0x94, 0xc1, 0x74,
1795 0xf3, 0x07, 0x64, 0xac, 0x1c, 0xde, 0xc7, 0x22,
1796 0xb0, 0xbf, 0x2a, 0x5a, 0xc0, 0x8f, 0x8a, 0x83,
1797 0x50, 0xc2, 0x5e, 0x97, 0xa0, 0xbe, 0x49, 0x7e,
1798 0x47, 0xaf, 0xa7, 0x20, 0x02, 0x35, 0xa4, 0x57,
1799 0xd9, 0x26, 0x63, 0xdb, 0xf1, 0x34, 0x42, 0x89,
1800 0x36, 0xd1, 0x77, 0x6f, 0xb1, 0xea, 0x79, 0x7e,
1801 0x95, 0x10, 0x5a, 0xee, 0xa3, 0xae, 0x6f, 0xba,
1802 0xa9, 0xef, 0x5a, 0x7e, 0x34, 0x03, 0x04, 0x07,
1803 0x92, 0xd6, 0x07, 0x79, 0xaa, 0x14, 0x90, 0x97,
1804 0x05, 0x4d, 0xa6, 0x27, 0x10, 0x5c, 0x25, 0x24,
1805 0xcb, 0xcc, 0xf6, 0x77, 0x9e, 0x43, 0x23, 0xd4,
1806 0x98, 0xef, 0x22, 0xa8, 0xad, 0xf2, 0x26, 0x08,
1807 0x59, 0x69, 0xa4, 0xc3, 0x97, 0xe0, 0x5c, 0x6f,
1808 0xeb, 0x3d, 0xd4, 0x62, 0x6e, 0x80, 0x61, 0x02,
1809 0xf4, 0xfc, 0x94, 0x79, 0xbb, 0x4e, 0x6d, 0xd7,
1810 0x30, 0x5b, 0x10, 0x11, 0x5a, 0x3d, 0xa7, 0x50,
1811 0x1d, 0x9a, 0x13, 0x5f, 0x4f, 0xa8, 0xa7, 0xb6,
1812 0x39, 0xc7, 0xea, 0xe6, 0x19, 0x61, 0x69, 0xc7,
1813 0x9a, 0x3a, 0xeb, 0x9d, 0xdc, 0xf7, 0x06, 0x37,
1814 0xbd, 0xac, 0xe3, 0x18, 0xff, 0xfe, 0x11, 0xdb,
1815 0x67, 0x42, 0xb4, 0xea, 0xa8, 0xbd, 0xb0, 0x76,
1816 0xd2, 0x74, 0x32, 0xc2, 0xa4, 0x9c, 0xe7, 0x60,
1817 0xc5, 0x30, 0x9a, 0x57, 0x66, 0xcd, 0x0f, 0x02,
1818 0x4c, 0xea, 0xe9, 0xd3, 0x2a, 0x5c, 0x09, 0xc2,
1819 0xff, 0x6a, 0xde, 0x5d, 0xb7, 0xe9, 0x75, 0x6b,
1820 0x29, 0x94, 0xd6, 0xf7, 0xc3, 0xdf, 0xfb, 0x70,
1821 0xec, 0xb5, 0x8c, 0xb0, 0x78, 0x7a, 0xee, 0x52,
1822 0x5f, 0x8c, 0xae, 0x85, 0xe5, 0x98, 0xa2, 0xb7,
1823 0x7c, 0x02, 0x2a, 0xcc, 0x9e, 0xde, 0x99, 0x5f,
1824 0x84, 0x20, 0xbb, 0xdc, 0xf2, 0xd2, 0x13, 0x46,
1825 0x3c, 0xd6, 0x4d, 0xe7, 0x50, 0xef, 0x55, 0xc3,
1826 0x96, 0x9f, 0xec, 0x6c, 0xd8, 0xe2, 0xea, 0xed,
1827 0xc7, 0x33, 0xc9, 0xb3, 0x1c, 0x4f, 0x1d, 0x83,
1828 0x1d, 0xe4, 0xdd, 0xb2, 0x24, 0x8f, 0xf9, 0xf5
1832 static const uint8_t HMAC_SHA256_ciphertext_64B_digest[] = {
1833 0xc5, 0x6d, 0x4f, 0x29, 0xf4, 0xd2, 0xcc, 0x87,
1834 0x3c, 0x81, 0x02, 0x6d, 0x38, 0x7a, 0x67, 0x3e,
1835 0x95, 0x9c, 0x5c, 0x8f, 0xda, 0x5c, 0x06, 0xe0,
1836 0x65, 0xf1, 0x6c, 0x51, 0x52, 0x49, 0x3e, 0x5f
1839 static const uint8_t HMAC_SHA256_ciphertext_128B_digest[] = {
1840 0x76, 0x64, 0x2d, 0x69, 0x71, 0x5d, 0x6a, 0xd8,
1841 0x9f, 0x74, 0x11, 0x2f, 0x58, 0xe0, 0x4a, 0x2f,
1842 0x6c, 0x88, 0x5e, 0x4d, 0x9c, 0x79, 0x83, 0x1c,
1843 0x8a, 0x14, 0xd0, 0x07, 0xfb, 0xbf, 0x6c, 0x8f
1846 static const uint8_t HMAC_SHA256_ciphertext_256B_digest[] = {
1847 0x05, 0xa7, 0x44, 0xcd, 0x91, 0x8c, 0x95, 0xcf,
1848 0x7b, 0x8f, 0xd3, 0x90, 0x86, 0x7e, 0x7b, 0xb9,
1849 0x05, 0xd6, 0x6e, 0x7a, 0xc1, 0x7b, 0x26, 0xff,
1850 0xd3, 0x4b, 0xe0, 0x22, 0x8b, 0xa8, 0x47, 0x52
1853 static const uint8_t HMAC_SHA256_ciphertext_512B_digest[] = {
1854 0x08, 0xb7, 0x29, 0x54, 0x18, 0x7e, 0x97, 0x49,
1855 0xc6, 0x7c, 0x9f, 0x94, 0xa5, 0x4f, 0xa2, 0x25,
1856 0xd0, 0xe2, 0x30, 0x7b, 0xad, 0x93, 0xc9, 0x12,
1857 0x0f, 0xf0, 0xf0, 0x71, 0xc2, 0xf6, 0x53, 0x8f
1860 static const uint8_t HMAC_SHA256_ciphertext_768B_digest[] = {
1861 0xe4, 0x3e, 0x73, 0x93, 0x03, 0xaf, 0x6f, 0x9c,
1862 0xca, 0x57, 0x3b, 0x4a, 0x6e, 0x83, 0x58, 0xf5,
1863 0x66, 0xc2, 0xb4, 0xa7, 0xe0, 0xee, 0x63, 0x6b,
1864 0x48, 0xb7, 0x50, 0x45, 0x69, 0xdf, 0x5c, 0x5b
1867 static const uint8_t HMAC_SHA256_ciphertext_1024B_digest[] = {
1868 0x03, 0xb9, 0x96, 0x26, 0xdc, 0x1c, 0xab, 0xe2,
1869 0xf5, 0x70, 0x55, 0x15, 0x67, 0x6e, 0x48, 0x11,
1870 0xe7, 0x67, 0xea, 0xfa, 0x5c, 0x6b, 0x28, 0x22,
1871 0xc9, 0x0e, 0x67, 0x04, 0xb3, 0x71, 0x7f, 0x88
1874 static const uint8_t HMAC_SHA256_ciphertext_1280B_digest[] = {
1875 0x01, 0x91, 0xb8, 0x78, 0xd3, 0x21, 0x74, 0xa5,
1876 0x1c, 0x8b, 0xd4, 0xd2, 0xc0, 0x49, 0xd7, 0xd2,
1877 0x16, 0x46, 0x66, 0x85, 0x50, 0x6d, 0x08, 0xcc,
1878 0xc7, 0x0a, 0xa3, 0x71, 0xcc, 0xde, 0xee, 0xdc
1881 static const uint8_t HMAC_SHA256_ciphertext_1536B_digest[] = {
1882 0xf2, 0xe5, 0xe9, 0x57, 0x53, 0xd7, 0x69, 0x28,
1883 0x7b, 0x69, 0xb5, 0x49, 0xa3, 0x31, 0x56, 0x5f,
1884 0xa4, 0xe9, 0x87, 0x26, 0x2f, 0xe0, 0x2d, 0xd6,
1885 0x08, 0x44, 0x01, 0x71, 0x0c, 0x93, 0x85, 0x84
1888 static const uint8_t HMAC_SHA256_ciphertext_1792B_digest[] = {
1889 0xf6, 0x57, 0x62, 0x01, 0xbf, 0x2d, 0xea, 0x4a,
1890 0xef, 0x43, 0x85, 0x60, 0x18, 0xdf, 0x8b, 0xb4,
1891 0x60, 0xc0, 0xfd, 0x2f, 0x90, 0x15, 0xe6, 0x91,
1892 0x56, 0x61, 0x68, 0x7f, 0x5e, 0x92, 0xa8, 0xdd
1895 static const uint8_t HMAC_SHA256_ciphertext_2048B_digest[] = {
1896 0x81, 0x1a, 0x29, 0xbc, 0x6b, 0x9f, 0xbb, 0xb8,
1897 0xef, 0x71, 0x7b, 0x1f, 0x6f, 0xd4, 0x7e, 0x68,
1898 0x3a, 0x9c, 0xb9, 0x98, 0x22, 0x81, 0xfa, 0x95,
1899 0xee, 0xbc, 0x7f, 0x23, 0x29, 0x88, 0x76, 0xb8
1902 struct crypto_data_params {
1905 const char *plaintext;
1906 struct crypto_expected_output {
1907 const uint8_t *ciphertext;
1908 const uint8_t *digest;
1912 #define MAX_PACKET_SIZE_INDEX 10
1914 struct crypto_data_params aes_cbc_hmac_sha256_output[MAX_PACKET_SIZE_INDEX] = {
1915 { "64B", 64, &plaintext_quote[sizeof(plaintext_quote) - 1 - 64],
1916 { AES_CBC_ciphertext_64B, HMAC_SHA256_ciphertext_64B_digest } },
1917 { "128B", 128, &plaintext_quote[sizeof(plaintext_quote) - 1 - 128],
1918 { AES_CBC_ciphertext_128B, HMAC_SHA256_ciphertext_128B_digest } },
1919 { "256B", 256, &plaintext_quote[sizeof(plaintext_quote) - 1 - 256],
1920 { AES_CBC_ciphertext_256B, HMAC_SHA256_ciphertext_256B_digest } },
1921 { "512B", 512, &plaintext_quote[sizeof(plaintext_quote) - 1 - 512],
1922 { AES_CBC_ciphertext_512B, HMAC_SHA256_ciphertext_512B_digest } },
1923 { "768B", 768, &plaintext_quote[sizeof(plaintext_quote) - 1 - 768],
1924 { AES_CBC_ciphertext_768B, HMAC_SHA256_ciphertext_768B_digest } },
1925 { "1024B", 1024, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1024],
1926 { AES_CBC_ciphertext_1024B, HMAC_SHA256_ciphertext_1024B_digest } },
1927 { "1280B", 1280, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1280],
1928 { AES_CBC_ciphertext_1280B, HMAC_SHA256_ciphertext_1280B_digest } },
1929 { "1536B", 1536, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1536],
1930 { AES_CBC_ciphertext_1536B, HMAC_SHA256_ciphertext_1536B_digest } },
1931 { "1792B", 1792, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1792],
1932 { AES_CBC_ciphertext_1792B, HMAC_SHA256_ciphertext_1792B_digest } },
1933 { "2048B", 2048, &plaintext_quote[sizeof(plaintext_quote) - 1 - 2048],
1934 { AES_CBC_ciphertext_2048B, HMAC_SHA256_ciphertext_2048B_digest } }
1938 test_perf_crypto_qp_vary_burst_size(uint16_t dev_num)
1940 uint32_t num_to_submit = 4096;
1941 struct rte_crypto_op *c_ops[num_to_submit];
1942 struct rte_crypto_op *proc_ops[num_to_submit];
1943 uint64_t failed_polls, retries, start_cycles, end_cycles, total_cycles = 0;
1944 uint32_t burst_sent, burst_received;
1945 uint32_t i, burst_size, num_sent, num_received;
1946 struct crypto_testsuite_params *ts_params = &testsuite_params;
1947 struct crypto_unittest_params *ut_params = &unittest_params;
1948 struct crypto_data_params *data_params = aes_cbc_hmac_sha256_output;
1950 if (rte_cryptodev_count() == 0) {
1951 printf("\nNo crypto devices available. Is kernel driver loaded?\n");
1955 /* Setup Cipher Parameters */
1956 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1957 ut_params->cipher_xform.next = &ut_params->auth_xform;
1959 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1960 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1961 ut_params->cipher_xform.cipher.key.data = aes_cbc_128_key;
1962 ut_params->cipher_xform.cipher.key.length = CIPHER_IV_LENGTH_AES_CBC;
1963 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1964 ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1966 /* Setup HMAC Parameters */
1967 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1968 ut_params->auth_xform.next = NULL;
1970 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1971 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA256_HMAC;
1972 ut_params->auth_xform.auth.key.data = hmac_sha256_key;
1973 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA256;
1974 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA256;
1976 /* Create Crypto session*/
1978 test_crypto_session = rte_cryptodev_sym_session_create(ts_params->sess_mp);
1980 rte_cryptodev_sym_session_init(ts_params->dev_id, test_crypto_session,
1981 &ut_params->cipher_xform, ts_params->sess_mp);
1983 TEST_ASSERT_NOT_NULL(test_crypto_session, "Session creation failed");
1985 /* Generate Crypto op data structure(s) */
1986 for (i = 0; i < num_to_submit ; i++) {
1987 struct rte_mbuf *m = setup_test_string(ts_params->mbuf_mp,
1988 data_params[0].expected.ciphertext,
1989 data_params[0].length, 0);
1990 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
1992 ut_params->digest = (uint8_t *)rte_pktmbuf_append(m,
1993 DIGEST_BYTE_LENGTH_SHA256);
1994 TEST_ASSERT_NOT_NULL(ut_params->digest,
1995 "no room to append digest");
1997 rte_memcpy(ut_params->digest, data_params[0].expected.digest,
1998 DIGEST_BYTE_LENGTH_SHA256);
2001 struct rte_crypto_op *op =
2002 rte_crypto_op_alloc(ts_params->op_mpool,
2003 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2005 rte_crypto_op_attach_sym_session(op, test_crypto_session);
2007 op->sym->auth.digest.data = ut_params->digest;
2008 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m,
2009 data_params[0].length);
2011 op->sym->auth.data.offset = 0;
2012 op->sym->auth.data.length = data_params[0].length;
2014 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
2015 aes_cbc_128_iv, CIPHER_IV_LENGTH_AES_CBC);
2017 op->sym->cipher.data.offset = 0;
2018 op->sym->cipher.data.length = data_params[0].length;
2025 printf("\nTest to measure the IA cycle cost using AES128_CBC_SHA256_HMAC "
2026 "algorithm with a constant request size of %u.",
2027 data_params[0].length);
2028 printf("\nThis test will keep retries at 0 and only measure IA cycle "
2029 "cost for each request.");
2030 printf("\nDev No\tQP No\tNum Sent\tNum Received\tTx/Rx burst");
2031 printf("\tRetries (Device Busy)\tAverage IA cycle cost "
2032 "(assuming 0 retries)");
2033 for (i = 2; i <= 128 ; i *= 2) {
2040 while (num_sent < num_to_submit) {
2041 start_cycles = rte_rdtsc_precise();
2042 burst_sent = rte_cryptodev_enqueue_burst(dev_num,
2043 0, &c_ops[num_sent],
2044 ((num_to_submit-num_sent) < burst_size) ?
2045 num_to_submit-num_sent : burst_size);
2046 if (burst_sent == 0)
2049 num_sent += burst_sent;
2050 end_cycles = rte_rdtsc_precise();
2051 total_cycles += (end_cycles - start_cycles);
2053 * Wait until requests have been sent.
2057 start_cycles = rte_rdtsc_precise();
2058 burst_received = rte_cryptodev_dequeue_burst(
2059 dev_num, 0, proc_ops, burst_size);
2060 if (burst_received == 0)
2063 num_received += burst_received;
2064 end_cycles = rte_rdtsc_precise();
2065 total_cycles += end_cycles - start_cycles;
2068 while (num_received != num_to_submit) {
2069 if (gbl_driver_id ==
2070 rte_cryptodev_driver_id_get(
2071 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
2072 rte_cryptodev_enqueue_burst(dev_num, 0,
2075 burst_received = rte_cryptodev_dequeue_burst(
2076 dev_num, 0, proc_ops, burst_size);
2077 if (burst_received == 0)
2080 num_received += burst_received;
2083 printf("\n%u\t%u\t%u\t\t%u\t\t%u", dev_num, 0,
2084 num_sent, num_received, burst_size);
2085 printf("\t\t%"PRIu64, retries);
2086 printf("\t\t\t%"PRIu64, total_cycles/num_received);
2090 for (i = 0; i < num_to_submit ; i++) {
2091 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2092 rte_crypto_op_free(c_ops[i]);
2094 return TEST_SUCCESS;
2098 test_perf_snow3G_optimise_cyclecount(struct perf_test_params *pparams)
2100 uint32_t num_to_submit = pparams->total_operations;
2101 struct rte_crypto_op *c_ops[num_to_submit];
2102 struct rte_crypto_op *proc_ops[num_to_submit];
2103 uint64_t failed_polls, retries, start_cycles, end_cycles, total_cycles = 0;
2104 uint32_t burst_sent = 0, burst_received = 0;
2105 uint32_t i, burst_size, num_sent, num_ops_received;
2106 struct crypto_testsuite_params *ts_params = &testsuite_params;
2107 static struct rte_cryptodev_sym_session *sess;
2109 if (rte_cryptodev_count() == 0) {
2110 printf("\nNo crypto devices found. Is PMD build configured?\n");
2111 printf("\nAnd is kernel driver loaded for HW PMDs?\n");
2115 /* Create Crypto session*/
2116 if (test_perf_create_snow3g_session(ts_params->dev_id,
2117 pparams->chain, pparams->cipher_algo,
2118 pparams->key_length, pparams->auth_algo) == 0)
2119 sess = test_crypto_session;
2122 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2124 /* Generate Crypto op data structure(s)*/
2125 for (i = 0; i < num_to_submit ; i++) {
2126 struct rte_mbuf *m = test_perf_create_pktmbuf(
2129 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2131 struct rte_crypto_op *op =
2132 rte_crypto_op_alloc(ts_params->op_mpool,
2133 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2134 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2136 op = test_perf_set_crypto_op_snow3g(op, m, sess, pparams->buf_size);
2137 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2142 if (pparams->chain == AEAD)
2143 printf("\nOn %s dev%u qp%u, %s, aead algo:%s, "
2144 "Packet Size %u bytes",
2145 pmd_name(gbl_driver_id),
2146 ts_params->dev_id, 0,
2147 chain_mode_name(pparams->chain),
2148 rte_crypto_aead_algorithm_strings[pparams->aead_algo],
2151 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, auth_algo:%s, "
2152 "Packet Size %u bytes",
2153 pmd_name(gbl_driver_id),
2154 ts_params->dev_id, 0,
2155 chain_mode_name(pparams->chain),
2156 rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
2157 rte_crypto_auth_algorithm_strings[pparams->auth_algo],
2159 printf("\nOps Tx\tOps Rx\tOps/burst ");
2160 printf("Retries EmptyPolls\tIACycles/CyOp\tIACycles/Burst\tIACycles/Byte");
2162 for (i = 2; i <= 128 ; i *= 2) {
2164 num_ops_received = 0;
2169 while (num_sent < num_to_submit) {
2170 start_cycles = rte_rdtsc_precise();
2171 burst_sent = rte_cryptodev_enqueue_burst(ts_params->dev_id,
2172 0, &c_ops[num_sent],
2173 ((num_to_submit-num_sent) < burst_size) ?
2174 num_to_submit-num_sent : burst_size);
2175 end_cycles = rte_rdtsc_precise();
2176 if (burst_sent == 0)
2178 num_sent += burst_sent;
2179 total_cycles += (end_cycles - start_cycles);
2181 /* Wait until requests have been sent. */
2185 start_cycles = rte_rdtsc_precise();
2186 burst_received = rte_cryptodev_dequeue_burst(
2187 ts_params->dev_id, 0, proc_ops, burst_size);
2188 end_cycles = rte_rdtsc_precise();
2189 if (burst_received < burst_sent)
2191 num_ops_received += burst_received;
2193 total_cycles += end_cycles - start_cycles;
2196 while (num_ops_received != num_to_submit) {
2197 if (gbl_driver_id ==
2198 rte_cryptodev_driver_id_get(
2199 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
2200 rte_cryptodev_enqueue_burst(ts_params->dev_id, 0,
2202 start_cycles = rte_rdtsc_precise();
2203 burst_received = rte_cryptodev_dequeue_burst(
2204 ts_params->dev_id, 0, proc_ops, burst_size);
2205 end_cycles = rte_rdtsc_precise();
2206 total_cycles += end_cycles - start_cycles;
2207 if (burst_received == 0)
2209 num_ops_received += burst_received;
2212 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2213 printf("\t\t%"PRIu64, retries);
2214 printf("\t%"PRIu64, failed_polls);
2215 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2216 printf("\t\t%"PRIu64, (total_cycles/num_ops_received)*burst_size);
2217 printf("\t\t%"PRIu64, total_cycles/(num_ops_received*pparams->buf_size));
2221 for (i = 0; i < num_to_submit ; i++) {
2222 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2223 rte_crypto_op_free(c_ops[i]);
2226 rte_cryptodev_sym_session_clear(ts_params->dev_id,
2228 rte_cryptodev_sym_session_free(sess);
2230 return TEST_SUCCESS;
2234 test_perf_snow3G_vary_burst_size(void)
2236 unsigned total_operations = 4096;
2237 /*no need to vary pkt size for QAT, should have no effect on IA cycles */
2238 uint16_t buf_lengths[] = {40};
2241 struct perf_test_params params_set[] = {
2243 .chain = CIPHER_ONLY,
2244 .cipher_algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2246 .auth_algo = RTE_CRYPTO_AUTH_NULL,
2250 .cipher_algo = RTE_CRYPTO_CIPHER_NULL,
2251 .auth_algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2256 printf("\n\nStart %s.", __func__);
2257 printf("\nThis Test measures the average IA cycle cost using a "
2258 "constant request(packet) size. ");
2259 printf("Cycle cost is only valid when indicators show device is not busy,"
2260 " i.e. Retries and EmptyPolls = 0");
2262 for (i = 0; i < RTE_DIM(params_set); i++) {
2264 params_set[i].total_operations = total_operations;
2267 j < RTE_DIM(buf_lengths);
2270 params_set[i].buf_size = buf_lengths[j];
2272 test_perf_snow3G_optimise_cyclecount(¶ms_set[i]);
2281 test_perf_openssl_optimise_cyclecount(struct perf_test_params *pparams)
2283 uint32_t num_to_submit = pparams->total_operations;
2284 struct rte_crypto_op *c_ops[num_to_submit];
2285 struct rte_crypto_op *proc_ops[num_to_submit];
2286 uint64_t failed_polls, retries, start_cycles,
2287 end_cycles, total_cycles = 0;
2288 uint32_t burst_sent = 0, burst_received = 0;
2289 uint32_t i, burst_size, num_sent, num_ops_received;
2291 struct crypto_testsuite_params *ts_params = &testsuite_params;
2293 static struct rte_cryptodev_sym_session *sess;
2295 static struct rte_crypto_op *(*test_perf_set_crypto_op)
2296 (struct rte_crypto_op *, struct rte_mbuf *,
2297 struct rte_cryptodev_sym_session *,
2301 if (rte_cryptodev_count() == 0) {
2302 printf("\nNo crypto devices found. Is PMD build configured?\n");
2306 /* Create Crypto session*/
2307 if (test_perf_create_openssl_session(ts_params->dev_id,
2308 pparams->chain, pparams->cipher_algo,
2309 pparams->key_length, pparams->auth_algo,
2310 pparams->aead_algo) == 0)
2311 sess = test_crypto_session;
2314 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2316 /* Generate Crypto op data structure(s)*/
2317 for (i = 0; i < num_to_submit ; i++) {
2318 struct rte_mbuf *m = test_perf_create_pktmbuf(
2321 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2323 struct rte_crypto_op *op =
2324 rte_crypto_op_alloc(ts_params->op_mpool,
2325 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2326 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2328 if (pparams->chain == AEAD)
2329 test_perf_set_crypto_op =
2330 test_perf_set_crypto_op_aes_gcm;
2332 switch (pparams->cipher_algo) {
2333 case RTE_CRYPTO_CIPHER_3DES_CBC:
2334 case RTE_CRYPTO_CIPHER_3DES_CTR:
2335 test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
2337 case RTE_CRYPTO_CIPHER_AES_CBC:
2338 case RTE_CRYPTO_CIPHER_AES_CTR:
2339 test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
2346 op = test_perf_set_crypto_op(op, m, sess, pparams->buf_size,
2348 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2353 if (pparams->chain == AEAD)
2354 printf("\nOn %s dev%u qp%u, %s, aead_algo:%s, "
2355 "key length:%u, Packet Size %u bytes",
2356 pmd_name(gbl_driver_id),
2357 ts_params->dev_id, 0,
2358 chain_mode_name(pparams->chain),
2359 rte_crypto_aead_algorithm_strings[pparams->aead_algo],
2360 pparams->key_length,
2363 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, auth_algo:%s, "
2364 "key length:%u, Packet Size %u bytes",
2365 pmd_name(gbl_driver_id),
2366 ts_params->dev_id, 0,
2367 chain_mode_name(pparams->chain),
2368 rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
2369 rte_crypto_auth_algorithm_strings[pparams->auth_algo],
2370 pparams->key_length,
2372 printf("\nOps Tx\tOps Rx\tOps/burst ");
2373 printf("Retries EmptyPolls\tIACycles/CyOp\tIACycles/Burst\t"
2376 for (i = 2; i <= 128 ; i *= 2) {
2378 num_ops_received = 0;
2383 while (num_sent < num_to_submit) {
2384 start_cycles = rte_rdtsc_precise();
2385 burst_sent = rte_cryptodev_enqueue_burst(
2387 0, &c_ops[num_sent],
2388 ((num_to_submit - num_sent) <
2390 num_to_submit - num_sent : burst_size);
2391 end_cycles = rte_rdtsc_precise();
2392 if (burst_sent == 0)
2394 num_sent += burst_sent;
2395 total_cycles += (end_cycles - start_cycles);
2397 /* Wait until requests have been sent. */
2400 start_cycles = rte_rdtsc_precise();
2401 burst_received = rte_cryptodev_dequeue_burst(
2402 ts_params->dev_id, 0, proc_ops,
2404 end_cycles = rte_rdtsc_precise();
2405 if (burst_received < burst_sent)
2407 num_ops_received += burst_received;
2409 total_cycles += end_cycles - start_cycles;
2412 while (num_ops_received != num_to_submit) {
2413 /* Sending 0 length burst to flush sw crypto device */
2414 rte_cryptodev_enqueue_burst(ts_params->dev_id, 0,
2417 start_cycles = rte_rdtsc_precise();
2418 burst_received = rte_cryptodev_dequeue_burst(
2419 ts_params->dev_id, 0, proc_ops,
2421 end_cycles = rte_rdtsc_precise();
2423 total_cycles += end_cycles - start_cycles;
2424 if (burst_received == 0)
2426 num_ops_received += burst_received;
2429 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2430 printf("\t\t%"PRIu64, retries);
2431 printf("\t%"PRIu64, failed_polls);
2432 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2433 printf("\t\t%"PRIu64, (total_cycles/num_ops_received) *
2435 printf("\t\t%"PRIu64,
2437 (num_ops_received * pparams->buf_size));
2441 for (i = 0; i < num_to_submit ; i++) {
2442 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2443 rte_crypto_op_free(c_ops[i]);
2446 rte_cryptodev_sym_session_clear(ts_params->dev_id, sess);
2447 rte_cryptodev_sym_session_free(sess);
2449 return TEST_SUCCESS;
2453 test_perf_armv8_optimise_cyclecount(struct perf_test_params *pparams)
2455 uint32_t num_to_submit = pparams->total_operations;
2456 struct rte_crypto_op *c_ops[num_to_submit];
2457 struct rte_crypto_op *proc_ops[num_to_submit];
2458 uint64_t failed_polls, retries, start_cycles, end_cycles,
2460 uint32_t burst_sent = 0, burst_received = 0;
2461 uint32_t i, burst_size, num_sent, num_ops_received;
2464 struct crypto_testsuite_params *ts_params = &testsuite_params;
2466 static struct rte_cryptodev_sym_session *sess;
2468 if (rte_cryptodev_count() == 0) {
2469 printf("\nNo crypto devices found. Is PMD build configured?\n");
2473 /* Create Crypto session*/
2474 if (test_perf_create_armv8_session(ts_params->dev_id,
2475 pparams->chain, pparams->cipher_algo,
2476 pparams->key_length, pparams->auth_algo) == 0)
2477 sess = test_crypto_session;
2481 /* Generate Crypto op data structure(s)*/
2482 for (i = 0; i < num_to_submit ; i++) {
2483 struct rte_mbuf *m = test_perf_create_pktmbuf(
2486 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2488 struct rte_crypto_op *op =
2489 rte_crypto_op_alloc(ts_params->op_mpool,
2490 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2491 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2493 op = test_perf_set_crypto_op_aes(op, m, sess, pparams->buf_size,
2495 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2500 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, cipher key length:%u, "
2501 "auth_algo:%s, Packet Size %u bytes",
2502 pmd_name(gbl_driver_id),
2503 ts_params->dev_id, 0,
2504 chain_mode_name(pparams->chain),
2505 rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
2506 pparams->key_length,
2507 rte_crypto_auth_algorithm_strings[pparams->auth_algo],
2509 printf("\nOps Tx\tOps Rx\tOps/burst ");
2511 "EmptyPolls\tIACycles/CyOp\tIACycles/Burst\tIACycles/Byte");
2513 for (i = 2; i <= 128 ; i *= 2) {
2515 num_ops_received = 0;
2520 while (num_sent < num_to_submit) {
2521 if ((num_to_submit - num_sent) < burst_size)
2522 nb_ops = num_to_submit - num_sent;
2524 nb_ops = burst_size;
2526 start_cycles = rte_rdtsc();
2527 burst_sent = rte_cryptodev_enqueue_burst(
2529 0, &c_ops[num_sent],
2531 end_cycles = rte_rdtsc();
2533 if (burst_sent == 0)
2535 num_sent += burst_sent;
2536 total_cycles += (end_cycles - start_cycles);
2538 start_cycles = rte_rdtsc();
2539 burst_received = rte_cryptodev_dequeue_burst(
2540 ts_params->dev_id, 0, proc_ops,
2542 end_cycles = rte_rdtsc();
2543 if (burst_received < burst_sent)
2545 num_ops_received += burst_received;
2547 total_cycles += end_cycles - start_cycles;
2550 while (num_ops_received != num_to_submit) {
2551 /* Sending 0 length burst to flush sw crypto device */
2552 rte_cryptodev_enqueue_burst(
2553 ts_params->dev_id, 0, NULL, 0);
2555 start_cycles = rte_rdtsc();
2556 burst_received = rte_cryptodev_dequeue_burst(
2557 ts_params->dev_id, 0, proc_ops, burst_size);
2558 end_cycles = rte_rdtsc();
2560 total_cycles += end_cycles - start_cycles;
2561 if (burst_received == 0)
2563 num_ops_received += burst_received;
2566 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2567 printf("\t\t%"PRIu64, retries);
2568 printf("\t%"PRIu64, failed_polls);
2569 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2570 printf("\t\t%"PRIu64,
2571 (total_cycles/num_ops_received)*burst_size);
2572 printf("\t\t%"PRIu64,
2573 total_cycles/(num_ops_received*pparams->buf_size));
2577 for (i = 0; i < num_to_submit ; i++) {
2578 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2579 rte_crypto_op_free(c_ops[i]);
2582 return TEST_SUCCESS;
2585 static uint32_t get_auth_key_max_length(enum rte_crypto_auth_algorithm algo)
2588 case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
2590 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2592 case RTE_CRYPTO_AUTH_SHA224_HMAC:
2594 case RTE_CRYPTO_AUTH_SHA256_HMAC:
2596 case RTE_CRYPTO_AUTH_SHA384_HMAC:
2598 case RTE_CRYPTO_AUTH_SHA512_HMAC:
2605 static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo)
2608 case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
2610 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2611 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA1;
2612 case RTE_CRYPTO_AUTH_SHA224_HMAC:
2613 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA224;
2614 case RTE_CRYPTO_AUTH_SHA256_HMAC:
2615 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA256;
2616 case RTE_CRYPTO_AUTH_SHA384_HMAC:
2617 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA384;
2618 case RTE_CRYPTO_AUTH_SHA512_HMAC:
2619 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA512;
2625 static uint32_t get_aead_digest_length(enum rte_crypto_aead_algorithm algo)
2628 case RTE_CRYPTO_AEAD_AES_GCM:
2629 return DIGEST_BYTE_LENGTH_AES_GCM;
2635 static uint8_t aes_key[] = {
2636 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2637 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2638 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2639 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2642 static uint8_t aes_iv[] = {
2643 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2644 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2647 static uint8_t aes_gcm_aad[] = {
2648 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2649 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2652 static uint8_t triple_des_key[] = {
2653 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2654 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2655 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2658 static uint8_t triple_des_iv[] = {
2659 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2662 static uint8_t hmac_sha_key[] = {
2663 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2664 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2665 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2666 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2667 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2668 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2669 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2670 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2671 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2672 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2673 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2674 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2675 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2676 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2677 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2678 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2681 static uint8_t snow3g_cipher_key[] = {
2682 0x2B, 0xD6, 0x45, 0x9F, 0x82, 0xC5, 0xB3, 0x00,
2683 0x95, 0x2C, 0x49, 0x10, 0x48, 0x81, 0xFF, 0x48
2686 static uint8_t snow3g_iv[] = {
2687 0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00,
2688 0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00
2691 static uint8_t snow3g_hash_key[] = {
2692 0xC7, 0x36, 0xC6, 0xAA, 0xB2, 0x2B, 0xFF, 0xF9,
2693 0x1E, 0x26, 0x98, 0xD2, 0xE2, 0x2A, 0xD5, 0x7E
2697 test_perf_create_aes_sha_session(uint8_t dev_id, enum chain_mode chain,
2698 enum rte_crypto_cipher_algorithm cipher_algo,
2699 unsigned cipher_key_len,
2700 enum rte_crypto_auth_algorithm auth_algo)
2702 struct crypto_testsuite_params *ts_params = &testsuite_params;
2703 struct rte_crypto_sym_xform cipher_xform = { 0 };
2704 struct rte_crypto_sym_xform auth_xform = { 0 };
2707 /* Setup Cipher Parameters */
2708 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2709 cipher_xform.cipher.algo = cipher_algo;
2710 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2712 cipher_xform.cipher.key.data = aes_key;
2713 cipher_xform.cipher.key.length = cipher_key_len;
2714 cipher_xform.cipher.iv.offset = IV_OFFSET;
2715 cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH;
2716 if (chain != CIPHER_ONLY) {
2717 /* Setup HMAC Parameters */
2718 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2719 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2720 auth_xform.auth.algo = auth_algo;
2721 auth_xform.auth.key.data = hmac_sha_key;
2722 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2723 auth_xform.auth.digest_length =
2724 get_auth_digest_length(auth_algo);
2727 test_crypto_session = rte_cryptodev_sym_session_create(ts_params->sess_mp);
2730 cipher_xform.next = &auth_xform;
2731 auth_xform.next = NULL;
2732 /* Create Crypto session*/
2733 return rte_cryptodev_sym_session_init(dev_id,
2734 test_crypto_session, &cipher_xform,
2735 ts_params->sess_mp);
2737 auth_xform.next = &cipher_xform;
2738 cipher_xform.next = NULL;
2739 /* Create Crypto session*/
2740 return rte_cryptodev_sym_session_init(dev_id,
2741 test_crypto_session, &auth_xform,
2742 ts_params->sess_mp);
2744 cipher_xform.next = NULL;
2745 /* Create Crypto session*/
2746 return rte_cryptodev_sym_session_init(dev_id,
2747 test_crypto_session, &cipher_xform,
2748 ts_params->sess_mp);
2754 #define SNOW3G_CIPHER_IV_LENGTH 16
2757 test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
2758 enum rte_crypto_cipher_algorithm cipher_algo, unsigned cipher_key_len,
2759 enum rte_crypto_auth_algorithm auth_algo)
2761 struct crypto_testsuite_params *ts_params = &testsuite_params;
2762 struct rte_crypto_sym_xform cipher_xform = {0};
2763 struct rte_crypto_sym_xform auth_xform = {0};
2766 /* Setup Cipher Parameters */
2767 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2768 cipher_xform.cipher.algo = cipher_algo;
2769 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2771 cipher_xform.cipher.key.data = snow3g_cipher_key;
2772 cipher_xform.cipher.key.length = cipher_key_len;
2773 cipher_xform.cipher.iv.offset = IV_OFFSET;
2774 cipher_xform.cipher.iv.length = SNOW3G_CIPHER_IV_LENGTH;
2777 /* Setup HMAC Parameters */
2778 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2779 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2780 auth_xform.auth.algo = auth_algo;
2782 auth_xform.auth.key.data = snow3g_hash_key;
2783 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2784 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2785 /* Auth IV will be after cipher IV */
2786 auth_xform.auth.iv.offset = IV_OFFSET + SNOW3G_CIPHER_IV_LENGTH;
2787 auth_xform.auth.iv.length = SNOW3G_CIPHER_IV_LENGTH;
2789 test_crypto_session = rte_cryptodev_sym_session_create(ts_params->sess_mp);
2792 cipher_xform.next = &auth_xform;
2793 auth_xform.next = NULL;
2794 /* Create Crypto session*/
2795 return rte_cryptodev_sym_session_init(dev_id,
2796 test_crypto_session, &cipher_xform,
2797 ts_params->sess_mp);
2799 auth_xform.next = &cipher_xform;
2800 cipher_xform.next = NULL;
2801 /* Create Crypto session*/
2802 return rte_cryptodev_sym_session_init(dev_id,
2803 test_crypto_session, &auth_xform,
2804 ts_params->sess_mp);
2806 cipher_xform.next = NULL;
2807 /* Create Crypto session*/
2808 return rte_cryptodev_sym_session_init(dev_id,
2809 test_crypto_session, &cipher_xform,
2810 ts_params->sess_mp);
2812 auth_xform.next = NULL;
2813 /* Create Crypto session */
2814 return rte_cryptodev_sym_session_init(dev_id,
2815 test_crypto_session, &auth_xform,
2816 ts_params->sess_mp);
2823 test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain,
2824 enum rte_crypto_cipher_algorithm cipher_algo,
2825 unsigned int key_len,
2826 enum rte_crypto_auth_algorithm auth_algo,
2827 enum rte_crypto_aead_algorithm aead_algo)
2829 struct crypto_testsuite_params *ts_params = &testsuite_params;
2830 struct rte_crypto_sym_xform cipher_xform = { 0 };
2831 struct rte_crypto_sym_xform auth_xform = { 0 };
2832 struct rte_crypto_sym_xform aead_xform = { 0 };
2834 if (chain == CIPHER_HASH || chain == HASH_CIPHER) {
2835 /* Setup Cipher Parameters */
2836 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2837 cipher_xform.cipher.algo = cipher_algo;
2838 cipher_xform.cipher.iv.offset = IV_OFFSET;
2839 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2841 switch (cipher_algo) {
2842 case RTE_CRYPTO_CIPHER_3DES_CBC:
2843 case RTE_CRYPTO_CIPHER_3DES_CTR:
2844 cipher_xform.cipher.key.data = triple_des_key;
2845 cipher_xform.cipher.iv.length = TRIPLE_DES_CIPHER_IV_LENGTH;
2847 case RTE_CRYPTO_CIPHER_AES_CBC:
2848 case RTE_CRYPTO_CIPHER_AES_CTR:
2849 cipher_xform.cipher.key.data = aes_key;
2850 cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH;
2856 cipher_xform.cipher.key.length = key_len;
2858 /* Setup Auth Parameters */
2859 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2860 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2861 auth_xform.auth.algo = auth_algo;
2863 switch (auth_algo) {
2864 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2865 auth_xform.auth.key.data = hmac_sha_key;
2871 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2872 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2873 } else if (chain == AEAD) {
2874 /* Setup AEAD Parameters */
2875 aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
2876 aead_xform.aead.op = RTE_CRYPTO_AEAD_OP_ENCRYPT;
2877 aead_xform.aead.algo = aead_algo;
2878 aead_xform.aead.iv.offset = IV_OFFSET;
2880 switch (aead_algo) {
2881 case RTE_CRYPTO_AEAD_AES_GCM:
2882 aead_xform.aead.key.data = aes_key;
2883 aead_xform.aead.iv.length = AES_CIPHER_IV_LENGTH;
2884 aead_xform.aead.aad_length = AES_GCM_AAD_LENGTH;
2885 aead_xform.aead.digest_length = get_aead_digest_length(aead_algo);
2891 aead_xform.aead.key.length = key_len;
2894 test_crypto_session = rte_cryptodev_sym_session_create(ts_params->sess_mp);
2897 cipher_xform.next = &auth_xform;
2898 auth_xform.next = NULL;
2899 /* Create Crypto session*/
2900 return rte_cryptodev_sym_session_init(dev_id,
2901 test_crypto_session, &cipher_xform,
2902 ts_params->sess_mp);
2904 auth_xform.next = &cipher_xform;
2905 cipher_xform.next = NULL;
2906 /* Create Crypto session*/
2907 return rte_cryptodev_sym_session_init(dev_id,
2908 test_crypto_session, &auth_xform,
2909 ts_params->sess_mp);
2911 /* Create Crypto session*/
2912 return rte_cryptodev_sym_session_init(dev_id,
2913 test_crypto_session, &aead_xform,
2914 ts_params->sess_mp);
2921 test_perf_create_armv8_session(uint8_t dev_id, enum chain_mode chain,
2922 enum rte_crypto_cipher_algorithm cipher_algo,
2923 unsigned int cipher_key_len,
2924 enum rte_crypto_auth_algorithm auth_algo)
2926 struct crypto_testsuite_params *ts_params = &testsuite_params;
2927 struct rte_crypto_sym_xform cipher_xform = { 0 };
2928 struct rte_crypto_sym_xform auth_xform = { 0 };
2930 /* Setup Cipher Parameters */
2931 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2932 cipher_xform.cipher.algo = cipher_algo;
2934 switch (cipher_algo) {
2935 case RTE_CRYPTO_CIPHER_AES_CBC:
2936 cipher_xform.cipher.key.data = aes_cbc_128_key;
2942 cipher_xform.cipher.key.length = cipher_key_len;
2943 cipher_xform.cipher.iv.offset = IV_OFFSET;
2944 cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH;
2946 /* Setup Auth Parameters */
2947 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2948 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2949 auth_xform.auth.algo = auth_algo;
2951 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2953 test_crypto_session = rte_cryptodev_sym_session_create(ts_params->sess_mp);
2957 cipher_xform.next = &auth_xform;
2958 auth_xform.next = NULL;
2959 /* Encrypt and hash the result */
2960 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2961 /* Create Crypto session*/
2962 return rte_cryptodev_sym_session_init(dev_id,
2963 test_crypto_session, &cipher_xform,
2964 ts_params->sess_mp);
2966 auth_xform.next = &cipher_xform;
2967 cipher_xform.next = NULL;
2968 /* Hash encrypted message and decrypt */
2969 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2970 /* Create Crypto session*/
2971 return rte_cryptodev_sym_session_init(dev_id,
2972 test_crypto_session, &auth_xform,
2973 ts_params->sess_mp);
2979 static struct rte_mbuf *
2980 test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz)
2982 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
2984 if (rte_pktmbuf_append(m, buf_sz) == NULL) {
2985 rte_pktmbuf_free(m);
2989 memset(rte_pktmbuf_mtod(m, uint8_t *), 0, buf_sz);
2994 static inline struct rte_crypto_op *
2995 test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m,
2996 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
2997 enum chain_mode chain)
2999 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3000 rte_crypto_op_free(op);
3004 /* Authentication Parameters */
3005 if (chain == CIPHER_ONLY) {
3006 op->sym->auth.digest.data = NULL;
3007 op->sym->auth.digest.phys_addr = 0;
3008 op->sym->auth.data.offset = 0;
3009 op->sym->auth.data.length = 0;
3011 op->sym->auth.digest.data = rte_pktmbuf_mtod_offset(m,
3012 uint8_t *, data_len);
3013 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m,
3015 op->sym->auth.data.offset = 0;
3016 op->sym->auth.data.length = data_len;
3020 /* Copy the IV at the end of the crypto operation */
3021 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
3022 aes_iv, AES_CIPHER_IV_LENGTH);
3024 /* Cipher Parameters */
3025 op->sym->cipher.data.offset = 0;
3026 op->sym->cipher.data.length = data_len;
3033 static inline struct rte_crypto_op *
3034 test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
3035 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
3036 enum chain_mode chain __rte_unused)
3038 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3039 rte_crypto_op_free(op);
3043 /* Authentication Parameters */
3044 op->sym->aead.digest.data = (uint8_t *)m->buf_addr +
3045 (m->data_off + data_len);
3046 op->sym->aead.digest.phys_addr =
3047 rte_pktmbuf_mtophys_offset(m, data_len);
3048 op->sym->aead.aad.data = aes_gcm_aad;
3050 /* Copy IV at the end of the crypto operation */
3051 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
3052 aes_iv, AES_CIPHER_IV_LENGTH);
3054 /* Data lengths/offsets Parameters */
3055 op->sym->aead.data.offset = 0;
3056 op->sym->aead.data.length = data_len;
3063 static inline struct rte_crypto_op *
3064 test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
3065 struct rte_cryptodev_sym_session *sess, unsigned int data_len)
3067 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
3068 uint8_t *, IV_OFFSET);
3070 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3071 rte_crypto_op_free(op);
3075 rte_memcpy(iv_ptr, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
3077 /* Authentication Parameters */
3078 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
3079 (m->data_off + data_len);
3080 op->sym->auth.digest.phys_addr =
3081 rte_pktmbuf_mtophys_offset(m, data_len);
3083 /* Data lengths/offsets Parameters */
3084 op->sym->auth.data.offset = 0;
3085 op->sym->auth.data.length = data_len << 3;
3087 op->sym->cipher.data.offset = 0;
3088 op->sym->cipher.data.length = data_len << 3;
3095 static inline struct rte_crypto_op *
3096 test_perf_set_crypto_op_snow3g_cipher(struct rte_crypto_op *op,
3098 struct rte_cryptodev_sym_session *sess,
3101 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3102 rte_crypto_op_free(op);
3106 /* Copy IV at the end of the crypto operation */
3107 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
3108 snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
3110 /* Cipher Parameters */
3111 op->sym->cipher.data.offset = 0;
3112 op->sym->cipher.data.length = data_len << 3;
3114 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
3116 SNOW3G_CIPHER_IV_LENGTH);
3124 static inline struct rte_crypto_op *
3125 test_perf_set_crypto_op_snow3g_hash(struct rte_crypto_op *op,
3127 struct rte_cryptodev_sym_session *sess,
3128 unsigned int data_len)
3130 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
3131 uint8_t *, IV_OFFSET);
3133 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3134 rte_crypto_op_free(op);
3138 rte_memcpy(iv_ptr, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
3140 /* Authentication Parameters */
3142 op->sym->auth.digest.data =
3143 (uint8_t *)rte_pktmbuf_mtod_offset(m, uint8_t *,
3145 op->sym->auth.digest.phys_addr =
3146 rte_pktmbuf_mtophys_offset(m, data_len +
3147 SNOW3G_CIPHER_IV_LENGTH);
3149 /* Data lengths/offsets Parameters */
3150 op->sym->auth.data.offset = 0;
3151 op->sym->auth.data.length = data_len << 3;
3159 static inline struct rte_crypto_op *
3160 test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
3161 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
3162 enum chain_mode chain __rte_unused)
3164 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3165 rte_crypto_op_free(op);
3169 /* Authentication Parameters */
3170 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
3171 (m->data_off + data_len);
3172 op->sym->auth.digest.phys_addr =
3173 rte_pktmbuf_mtophys_offset(m, data_len);
3175 /* Copy IV at the end of the crypto operation */
3176 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
3177 triple_des_iv, TRIPLE_DES_CIPHER_IV_LENGTH);
3179 /* Data lengths/offsets Parameters */
3180 op->sym->auth.data.offset = 0;
3181 op->sym->auth.data.length = data_len;
3183 op->sym->cipher.data.offset = 0;
3184 op->sym->cipher.data.length = data_len;
3191 /* An mbuf set is used in each burst. An mbuf can be used by multiple bursts at
3192 * same time, i.e. as they're not dereferenced there's no need to wait until
3193 * finished with to re-use */
3194 #define NUM_MBUF_SETS 8
3197 test_perf_aes_sha(uint8_t dev_id, uint16_t queue_id,
3198 struct perf_test_params *pparams)
3200 uint16_t i, k, l, m;
3202 uint16_t ops_unused = 0;
3204 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3205 uint64_t processed = 0, failed_polls = 0, retries = 0;
3206 uint64_t tsc_start = 0, tsc_end = 0;
3208 uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
3210 struct rte_crypto_op *ops[pparams->burst_size];
3211 struct rte_crypto_op *proc_ops[pparams->burst_size];
3213 struct rte_mbuf *mbufs[pparams->burst_size * 8];
3215 struct crypto_testsuite_params *ts_params = &testsuite_params;
3217 static struct rte_cryptodev_sym_session *sess;
3219 if (rte_cryptodev_count() == 0) {
3220 printf("\nNo crypto devices available. Is kernel driver loaded?\n");
3224 /* Create Crypto session*/
3225 if (test_perf_create_aes_sha_session(ts_params->dev_id,
3226 pparams->chain, pparams->cipher_algo,
3227 pparams->key_length, pparams->auth_algo) == 0)
3228 sess = test_crypto_session;
3231 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3233 /* Generate a burst of crypto operations */
3234 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3235 mbufs[i] = test_perf_create_pktmbuf(
3239 if (mbufs[i] == NULL) {
3240 printf("\nFailed to get mbuf - freeing the rest.\n");
3241 for (k = 0; k < i; k++)
3242 rte_pktmbuf_free(mbufs[k]);
3246 /* Make room for Digest in mbuf */
3247 if (pparams->chain != CIPHER_ONLY)
3248 rte_pktmbuf_append(mbufs[i], digest_length);
3252 tsc_start = rte_rdtsc_precise();
3254 while (total_enqueued < pparams->total_operations) {
3255 uint16_t burst_size =
3256 total_enqueued+pparams->burst_size <= pparams->total_operations ?
3257 pparams->burst_size : pparams->total_operations-total_enqueued;
3258 uint16_t ops_needed = burst_size-ops_unused;
3260 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3261 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3262 printf("\nFailed to alloc enough ops, finish dequeuing "
3263 "and free ops below.");
3265 for (i = 0; i < ops_needed; i++)
3266 ops[i] = test_perf_set_crypto_op_aes(ops[i],
3267 mbufs[i + (pparams->burst_size *
3268 (j % NUM_MBUF_SETS))],
3269 sess, pparams->buf_size,
3273 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3274 queue_id, ops, burst_size);
3276 if (burst_enqueued < burst_size)
3279 ops_unused = burst_size-burst_enqueued;
3280 total_enqueued += burst_enqueued;
3284 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3285 proc_ops, pparams->burst_size);
3286 if (burst_dequeued == 0)
3289 processed += burst_dequeued;
3291 for (l = 0; l < burst_dequeued; l++)
3292 rte_crypto_op_free(proc_ops[l]);
3297 /* Dequeue any operations still in the crypto device */
3298 while (processed < pparams->total_operations) {
3299 /* Sending 0 length burst to flush sw crypto device */
3300 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3303 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3304 proc_ops, pparams->burst_size);
3305 if (burst_dequeued == 0)
3308 processed += burst_dequeued;
3310 for (m = 0; m < burst_dequeued; m++)
3311 rte_crypto_op_free(proc_ops[m]);
3315 tsc_end = rte_rdtsc_precise();
3317 double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
3318 double throughput = (ops_s * pparams->buf_size * 8) / 1000000000;
3320 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size, ops_s/1000000,
3321 throughput, retries, failed_polls);
3323 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3324 rte_pktmbuf_free(mbufs[i]);
3326 rte_cryptodev_sym_session_clear(ts_params->dev_id, sess);
3327 rte_cryptodev_sym_session_free(sess);
3330 return TEST_SUCCESS;
3335 test_perf_snow3g(uint8_t dev_id, uint16_t queue_id,
3336 struct perf_test_params *pparams)
3338 uint16_t i, k, l, m;
3340 uint16_t ops_unused = 0;
3341 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3342 uint64_t processed = 0, failed_polls = 0, retries = 0;
3343 uint64_t tsc_start = 0, tsc_end = 0;
3345 uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
3347 struct rte_crypto_op *ops[pparams->burst_size];
3348 struct rte_crypto_op *proc_ops[pparams->burst_size];
3350 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3352 struct crypto_testsuite_params *ts_params = &testsuite_params;
3354 static struct rte_cryptodev_sym_session *sess;
3356 if (rte_cryptodev_count() == 0) {
3357 printf("\nNo crypto devices found. Is PMD build configured?\n");
3358 printf("\nAnd is kernel driver loaded for HW PMDs?\n");
3362 /* Create Crypto session*/
3363 if (test_perf_create_snow3g_session(ts_params->dev_id,
3364 pparams->chain, pparams->cipher_algo,
3365 pparams->key_length, pparams->auth_algo) == 0)
3366 sess = test_crypto_session;
3369 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3371 /* Generate a burst of crypto operations */
3372 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3374 * Buffer size is allocated, for perf tests they
3375 * are equal + digest len.
3377 mbufs[i] = test_perf_create_pktmbuf(
3382 if (mbufs[i] == NULL) {
3383 printf("\nFailed to get mbuf - freeing the rest.\n");
3384 for (k = 0; k < i; k++)
3385 rte_pktmbuf_free(mbufs[k]);
3391 tsc_start = rte_rdtsc_precise();
3393 while (total_enqueued < pparams->total_operations) {
3394 uint16_t burst_size =
3395 (total_enqueued+pparams->burst_size)
3396 <= pparams->total_operations ?
3397 pparams->burst_size : pparams->total_operations-total_enqueued;
3398 uint16_t ops_needed = burst_size-ops_unused;
3399 /* Handle the last burst correctly */
3400 uint16_t op_offset = pparams->burst_size - burst_size;
3403 rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3404 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
3405 ops+op_offset, ops_needed)) {
3406 printf("\nFailed to alloc enough ops.");
3407 /*Don't exit, dequeue, more ops should become available*/
3409 for (i = 0; i < ops_needed; i++) {
3410 if (pparams->chain == HASH_ONLY)
3412 test_perf_set_crypto_op_snow3g_hash(ops[i+op_offset],
3414 (pparams->burst_size * (j % NUM_MBUF_SETS))],
3417 else if (pparams->chain == CIPHER_ONLY)
3419 test_perf_set_crypto_op_snow3g_cipher(ops[i+op_offset],
3421 (pparams->burst_size * (j % NUM_MBUF_SETS))],
3430 rte_cryptodev_enqueue_burst(dev_id, queue_id,
3431 ops+op_offset, burst_size);
3433 if (burst_enqueued < burst_size)
3436 ops_unused = burst_size-burst_enqueued;
3437 total_enqueued += burst_enqueued;
3441 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3442 proc_ops, pparams->burst_size);
3443 if (burst_dequeued == 0) {
3446 processed += burst_dequeued;
3447 for (l = 0; l < burst_dequeued; l++)
3448 rte_crypto_op_free(proc_ops[l]);
3453 /* Dequeue any operations still in the crypto device */
3454 while (processed < pparams->total_operations) {
3455 /* Sending 0 length burst to flush sw crypto device */
3456 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3459 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3460 proc_ops, pparams->burst_size);
3461 if (burst_dequeued == 0)
3464 processed += burst_dequeued;
3465 for (m = 0; m < burst_dequeued; m++)
3466 rte_crypto_op_free(proc_ops[m]);
3470 tsc_end = rte_rdtsc_precise();
3472 double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
3473 double cycles_burst = (double) (tsc_end - tsc_start) /
3474 (double) processed * pparams->burst_size;
3475 double cycles_buff = (double) (tsc_end - tsc_start) / (double) processed;
3476 double cycles_B = cycles_buff / pparams->buf_size;
3477 double throughput = (ops_s * pparams->buf_size * 8) / 1000000;
3479 if (gbl_driver_id == rte_cryptodev_driver_id_get(
3480 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD))) {
3481 /* Cycle count misleading on HW devices for this test, so don't print */
3482 printf("%4u\t%6.2f\t%10.2f\t n/a \t\t n/a "
3483 "\t\t n/a \t\t%8"PRIu64"\t%8"PRIu64,
3484 pparams->buf_size, ops_s/1000000,
3485 throughput, retries, failed_polls);
3487 printf("%4u\t%6.2f\t%10.2f\t%10.2f\t%8.2f"
3488 "\t%8.2f\t%8"PRIu64"\t%8"PRIu64,
3489 pparams->buf_size, ops_s/1000000, throughput, cycles_burst,
3490 cycles_buff, cycles_B, retries, failed_polls);
3493 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3494 rte_pktmbuf_free(mbufs[i]);
3496 rte_cryptodev_sym_session_clear(ts_params->dev_id, sess);
3497 rte_cryptodev_sym_session_free(sess);
3500 return TEST_SUCCESS;
3504 test_perf_openssl(uint8_t dev_id, uint16_t queue_id,
3505 struct perf_test_params *pparams)
3507 uint16_t i, k, l, m;
3509 uint16_t ops_unused = 0;
3511 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3512 uint64_t processed = 0, failed_polls = 0, retries = 0;
3513 uint64_t tsc_start = 0, tsc_end = 0;
3515 struct rte_crypto_op *ops[pparams->burst_size];
3516 struct rte_crypto_op *proc_ops[pparams->burst_size];
3518 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3520 struct crypto_testsuite_params *ts_params = &testsuite_params;
3522 static struct rte_cryptodev_sym_session *sess;
3524 static struct rte_crypto_op *(*test_perf_set_crypto_op)
3525 (struct rte_crypto_op *, struct rte_mbuf *,
3526 struct rte_cryptodev_sym_session *,
3530 if (pparams->chain == AEAD)
3531 test_perf_set_crypto_op =
3532 test_perf_set_crypto_op_aes_gcm;
3534 switch (pparams->cipher_algo) {
3535 case RTE_CRYPTO_CIPHER_3DES_CBC:
3536 case RTE_CRYPTO_CIPHER_3DES_CTR:
3537 test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
3539 case RTE_CRYPTO_CIPHER_AES_CBC:
3540 case RTE_CRYPTO_CIPHER_AES_CTR:
3541 test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
3548 if (rte_cryptodev_count() == 0) {
3549 printf("\nNo crypto devices found. Is PMD build configured?\n");
3553 /* Create Crypto session*/
3554 if (test_perf_create_openssl_session(ts_params->dev_id,
3555 pparams->chain, pparams->cipher_algo,
3556 pparams->key_length, pparams->auth_algo,
3557 pparams->aead_algo) == 0)
3558 sess = test_crypto_session;
3561 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3563 /* Generate a burst of crypto operations */
3564 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3565 mbufs[i] = test_perf_create_pktmbuf(
3569 if (mbufs[i] == NULL) {
3570 printf("\nFailed to get mbuf - freeing the rest.\n");
3571 for (k = 0; k < i; k++)
3572 rte_pktmbuf_free(mbufs[k]);
3577 tsc_start = rte_rdtsc_precise();
3579 while (total_enqueued < pparams->total_operations) {
3580 uint16_t burst_size =
3581 total_enqueued + pparams->burst_size <=
3582 pparams->total_operations ? pparams->burst_size :
3583 pparams->total_operations - total_enqueued;
3584 uint16_t ops_needed = burst_size - ops_unused;
3586 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3587 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3588 printf("\nFailed to alloc enough ops, finish dequeuing "
3589 "and free ops below.");
3591 for (i = 0; i < ops_needed; i++)
3592 ops[i] = test_perf_set_crypto_op(ops[i],
3593 mbufs[i + (pparams->burst_size *
3594 (j % NUM_MBUF_SETS))],
3595 sess, pparams->buf_size,
3599 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3600 queue_id, ops, burst_size);
3602 if (burst_enqueued < burst_size)
3605 ops_unused = burst_size - burst_enqueued;
3606 total_enqueued += burst_enqueued;
3610 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3611 proc_ops, pparams->burst_size);
3612 if (burst_dequeued == 0)
3615 processed += burst_dequeued;
3617 for (l = 0; l < burst_dequeued; l++)
3618 rte_crypto_op_free(proc_ops[l]);
3623 /* Dequeue any operations still in the crypto device */
3624 while (processed < pparams->total_operations) {
3625 /* Sending 0 length burst to flush sw crypto device */
3626 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3629 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3630 proc_ops, pparams->burst_size);
3631 if (burst_dequeued == 0)
3634 processed += burst_dequeued;
3636 for (m = 0; m < burst_dequeued; m++)
3637 rte_crypto_op_free(proc_ops[m]);
3641 tsc_end = rte_rdtsc_precise();
3643 double ops_s = ((double)processed / (tsc_end - tsc_start))
3645 double throughput = (ops_s * pparams->buf_size * NUM_MBUF_SETS)
3648 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size,
3649 ops_s / 1000000, throughput, retries, failed_polls);
3651 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3652 rte_pktmbuf_free(mbufs[i]);
3654 rte_cryptodev_sym_session_clear(ts_params->dev_id, sess);
3655 rte_cryptodev_sym_session_free(sess);
3658 return TEST_SUCCESS;
3662 test_perf_armv8(uint8_t dev_id, uint16_t queue_id,
3663 struct perf_test_params *pparams)
3665 uint16_t i, k, l, m;
3667 uint16_t ops_unused = 0;
3668 uint16_t burst_size;
3669 uint16_t ops_needed;
3671 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3672 uint64_t processed = 0, failed_polls = 0, retries = 0;
3673 uint64_t tsc_start = 0, tsc_end = 0;
3675 struct rte_crypto_op *ops[pparams->burst_size];
3676 struct rte_crypto_op *proc_ops[pparams->burst_size];
3678 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3680 struct crypto_testsuite_params *ts_params = &testsuite_params;
3682 static struct rte_cryptodev_sym_session *sess;
3684 if (rte_cryptodev_count() == 0) {
3685 printf("\nNo crypto devices found. Is PMD build configured?\n");
3689 /* Create Crypto session*/
3690 if (test_perf_create_armv8_session(ts_params->dev_id,
3691 pparams->chain, pparams->cipher_algo,
3692 pparams->key_length, pparams->auth_algo) == 0)
3693 sess = test_crypto_session;
3696 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3698 /* Generate a burst of crypto operations */
3699 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3700 mbufs[i] = test_perf_create_pktmbuf(
3704 if (mbufs[i] == NULL) {
3705 printf("\nFailed to get mbuf - freeing the rest.\n");
3706 for (k = 0; k < i; k++)
3707 rte_pktmbuf_free(mbufs[k]);
3712 tsc_start = rte_rdtsc();
3714 while (total_enqueued < pparams->total_operations) {
3715 if ((total_enqueued + pparams->burst_size) <=
3716 pparams->total_operations)
3717 burst_size = pparams->burst_size;
3719 burst_size = pparams->total_operations - total_enqueued;
3721 ops_needed = burst_size - ops_unused;
3723 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3724 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3725 printf("\nFailed to alloc enough ops, finish dequeuing "
3726 "and free ops below.");
3728 for (i = 0; i < ops_needed; i++)
3729 ops[i] = test_perf_set_crypto_op_aes(ops[i],
3730 mbufs[i + (pparams->burst_size *
3731 (j % NUM_MBUF_SETS))], sess,
3736 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3737 queue_id, ops, burst_size);
3739 if (burst_enqueued < burst_size)
3742 ops_unused = burst_size - burst_enqueued;
3743 total_enqueued += burst_enqueued;
3747 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3748 proc_ops, pparams->burst_size);
3749 if (burst_dequeued == 0)
3752 processed += burst_dequeued;
3754 for (l = 0; l < burst_dequeued; l++)
3755 rte_crypto_op_free(proc_ops[l]);
3760 /* Dequeue any operations still in the crypto device */
3761 while (processed < pparams->total_operations) {
3762 /* Sending 0 length burst to flush sw crypto device */
3763 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3766 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3767 proc_ops, pparams->burst_size);
3768 if (burst_dequeued == 0)
3771 processed += burst_dequeued;
3773 for (m = 0; m < burst_dequeued; m++)
3774 rte_crypto_op_free(proc_ops[m]);
3778 tsc_end = rte_rdtsc();
3780 double ops_s = ((double)processed / (tsc_end - tsc_start))
3782 double throughput = (ops_s * pparams->buf_size * NUM_MBUF_SETS)
3785 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size,
3786 ops_s / 1000000, throughput, retries, failed_polls);
3788 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3789 rte_pktmbuf_free(mbufs[i]);
3792 return TEST_SUCCESS;
3797 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA1);
3798 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_256);
3799 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_512);
3801 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA1);
3802 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_256);
3803 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_512);
3805 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA1);
3806 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_256);
3807 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_512);
3810 test_perf_aes_cbc_encrypt_digest_vary_pkt_size(void)
3812 unsigned total_operations = 1000000;
3813 unsigned burst_size = 32;
3814 unsigned buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536, 1792, 2048 };
3817 struct perf_test_params params_set[] = {
3819 .chain = CIPHER_ONLY,
3820 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3822 .auth_algo = RTE_CRYPTO_AUTH_NULL
3825 .chain = CIPHER_HASH,
3826 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3828 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3831 .chain = CIPHER_HASH,
3833 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3835 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
3838 .chain = CIPHER_HASH,
3840 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3842 .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
3845 .chain = CIPHER_HASH,
3847 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3849 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3852 .chain = CIPHER_HASH,
3854 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3856 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
3859 .chain = CIPHER_HASH,
3861 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3863 .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
3867 for (i = 0; i < RTE_DIM(params_set); i++) {
3869 params_set[i].total_operations = total_operations;
3870 params_set[i].burst_size = burst_size;
3871 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
3872 " burst_size: %d ops\n",
3873 chain_mode_name(params_set[i].chain),
3874 rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
3875 rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
3876 params_set[i].key_length,
3878 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
3879 "Retries\tEmptyPolls\n");
3880 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3881 params_set[i].buf_size = buf_lengths[j];
3882 test_perf_aes_sha(testsuite_params.dev_id, 0,
3890 test_perf_snow3G_vary_pkt_size(void)
3892 unsigned total_operations = 1000000;
3895 uint16_t burst_sizes[] = { 64 };
3896 uint16_t buf_lengths[] = { 40, 64, 80, 120, 240, 256, 400, 512, 600, 1024, 2048 };
3898 struct perf_test_params params_set[] = {
3900 .chain = CIPHER_ONLY,
3901 .cipher_algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3903 .auth_algo = RTE_CRYPTO_AUTH_NULL,
3907 .cipher_algo = RTE_CRYPTO_CIPHER_NULL,
3908 .auth_algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3913 printf("\n\nStart %s.", __func__);
3914 printf("\nTest to measure max throughput at various pkt sizes.");
3915 printf("\nOn HW devices t'put maximised when high Retries and EmptyPolls"
3916 " so cycle cost not relevant (n/a displayed).");
3918 for (i = 0; i < RTE_DIM(params_set); i++) {
3920 params_set[i].total_operations = total_operations;
3921 for (k = 0; k < RTE_DIM(burst_sizes); k++) {
3922 enum rte_crypto_cipher_algorithm cipher_algo =
3923 params_set[i].cipher_algo;
3924 enum rte_crypto_auth_algorithm auth_algo =
3925 params_set[i].auth_algo;
3926 printf("\nOn %s dev%u qp%u, %s, "
3927 "cipher algo:%s, auth algo:%s, burst_size: %d ops",
3928 pmd_name(gbl_driver_id),
3929 testsuite_params.dev_id, 0,
3930 chain_mode_name(params_set[i].chain),
3931 rte_crypto_cipher_algorithm_strings[cipher_algo],
3932 rte_crypto_auth_algorithm_strings[auth_algo],
3935 params_set[i].burst_size = burst_sizes[k];
3936 printf("\nPktSzB\tOp/s(M)\tThruput(Mbps)\tCycles/Burst\t"
3937 "Cycles/buf\tCycles/B\tRetries\t\tEmptyPolls\n");
3938 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3940 params_set[i].buf_size = buf_lengths[j];
3942 test_perf_snow3g(testsuite_params.dev_id, 0, ¶ms_set[i]);
3951 test_perf_openssl_vary_pkt_size(void)
3953 unsigned int total_operations = 10000;
3954 unsigned int burst_size = { 64 };
3955 unsigned int buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536,
3959 struct perf_test_params params_set[] = {
3961 .chain = CIPHER_HASH,
3963 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3965 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3968 .chain = CIPHER_HASH,
3970 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3972 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3975 .chain = CIPHER_HASH,
3977 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3979 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3982 .chain = CIPHER_HASH,
3984 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3986 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3989 .chain = CIPHER_HASH,
3991 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3993 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3996 .chain = CIPHER_HASH,
3998 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
4000 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4005 .aead_algo = RTE_CRYPTO_AEAD_AES_GCM,
4010 for (i = 0; i < RTE_DIM(params_set); i++) {
4011 params_set[i].total_operations = total_operations;
4012 params_set[i].burst_size = burst_size;
4013 if (params_set[i].chain == AEAD) {
4014 enum rte_crypto_aead_algorithm aead_algo =
4015 params_set[i].aead_algo;
4016 printf("\n%s. aead algo: %s key size=%u."
4017 " burst_size: %d ops\n",
4018 chain_mode_name(params_set[i].chain),
4019 rte_crypto_aead_algorithm_strings[aead_algo],
4020 params_set[i].key_length,
4023 enum rte_crypto_cipher_algorithm cipher_algo =
4024 params_set[i].cipher_algo;
4025 enum rte_crypto_auth_algorithm auth_algo =
4026 params_set[i].auth_algo;
4027 printf("\n%s. cipher algo: %s auth algo: %s key size=%u."
4028 " burst_size: %d ops\n",
4029 chain_mode_name(params_set[i].chain),
4030 rte_crypto_cipher_algorithm_strings[cipher_algo],
4031 rte_crypto_auth_algorithm_strings[auth_algo],
4032 params_set[i].key_length,
4035 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t"
4037 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4038 params_set[i].buf_size = buf_lengths[j];
4039 test_perf_openssl(testsuite_params.dev_id, 0,
4048 test_perf_openssl_vary_burst_size(void)
4050 unsigned int total_operations = 4096;
4051 uint16_t buf_lengths[] = { 40 };
4054 struct perf_test_params params_set[] = {
4056 .chain = CIPHER_HASH,
4058 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
4060 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4063 .chain = CIPHER_HASH,
4065 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
4067 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4070 .chain = CIPHER_HASH,
4072 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
4074 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4077 .chain = CIPHER_HASH,
4079 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
4081 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4084 .chain = CIPHER_HASH,
4086 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
4088 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4091 .chain = CIPHER_HASH,
4093 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
4095 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4100 .aead_algo = RTE_CRYPTO_AEAD_AES_GCM,
4105 printf("\n\nStart %s.", __func__);
4106 printf("\nThis Test measures the average IA cycle cost using a "
4107 "constant request(packet) size. ");
4108 printf("Cycle cost is only valid when indicators show device is not"
4109 " busy, i.e. Retries and EmptyPolls = 0");
4111 for (i = 0; i < RTE_DIM(params_set); i++) {
4113 params_set[i].total_operations = total_operations;
4115 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4116 params_set[i].buf_size = buf_lengths[j];
4117 test_perf_openssl_optimise_cyclecount(¶ms_set[i]);
4125 test_perf_armv8_vary_pkt_size(void)
4127 unsigned int total_operations = 100000;
4128 unsigned int burst_size = { 64 };
4129 unsigned int buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536,
4133 struct perf_test_params params_set[] = {
4135 .chain = CIPHER_HASH,
4137 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4139 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4142 .chain = HASH_CIPHER,
4144 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4146 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4149 .chain = CIPHER_HASH,
4151 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4153 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4156 .chain = HASH_CIPHER,
4158 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4160 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4164 for (i = 0; i < RTE_DIM(params_set); i++) {
4165 params_set[i].total_operations = total_operations;
4166 params_set[i].burst_size = burst_size;
4167 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
4168 " burst_size: %d ops\n",
4169 chain_mode_name(params_set[i].chain),
4170 rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
4171 rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
4172 params_set[i].key_length,
4174 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t"
4176 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4177 params_set[i].buf_size = buf_lengths[j];
4178 test_perf_armv8(testsuite_params.dev_id, 0,
4187 test_perf_armv8_vary_burst_size(void)
4189 unsigned int total_operations = 4096;
4190 uint16_t buf_lengths[] = { 64 };
4193 struct perf_test_params params_set[] = {
4195 .chain = CIPHER_HASH,
4197 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4199 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4202 .chain = HASH_CIPHER,
4204 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4206 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4209 .chain = CIPHER_HASH,
4211 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4213 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4216 .chain = HASH_CIPHER,
4218 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4220 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4224 printf("\n\nStart %s.", __func__);
4225 printf("\nThis Test measures the average IA cycle cost using a "
4226 "constant request(packet) size. ");
4227 printf("Cycle cost is only valid when indicators show device is "
4228 "not busy, i.e. Retries and EmptyPolls = 0");
4230 for (i = 0; i < RTE_DIM(params_set); i++) {
4232 params_set[i].total_operations = total_operations;
4234 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4235 params_set[i].buf_size = buf_lengths[j];
4236 test_perf_armv8_optimise_cyclecount(¶ms_set[i]);
4244 test_perf_aes_cbc_vary_burst_size(void)
4246 return test_perf_crypto_qp_vary_burst_size(testsuite_params.dev_id);
4250 static struct rte_cryptodev_sym_session *
4251 test_perf_create_session(uint8_t dev_id, struct perf_test_params *pparams)
4253 struct crypto_testsuite_params *ts_params = &testsuite_params;
4254 struct rte_crypto_sym_xform aead_xform = { 0 };
4256 uint8_t aead_key[pparams->session_attrs->key_aead_len];
4258 memcpy(aead_key, pparams->session_attrs->key_aead_data,
4259 pparams->session_attrs->key_aead_len);
4261 aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
4262 aead_xform.next = NULL;
4264 aead_xform.aead.algo = pparams->session_attrs->aead_algorithm;
4265 aead_xform.aead.op = pparams->session_attrs->aead;
4266 aead_xform.aead.key.data = aead_key;
4267 aead_xform.aead.key.length = pparams->session_attrs->key_aead_len;
4268 aead_xform.aead.iv.length = pparams->session_attrs->iv_len;
4269 aead_xform.aead.iv.offset = IV_OFFSET;
4270 aead_xform.aead.aad_length = pparams->session_attrs->aad_len;
4271 aead_xform.aead.digest_length = pparams->session_attrs->digest_len;
4273 test_crypto_session = rte_cryptodev_sym_session_create(ts_params->sess_mp);
4275 rte_cryptodev_sym_session_init(dev_id, test_crypto_session,
4276 &aead_xform, ts_params->sess_mp);
4278 return test_crypto_session;
4281 static inline struct rte_crypto_op *
4282 perf_gcm_set_crypto_op(struct rte_crypto_op *op, struct rte_mbuf *m,
4283 struct rte_cryptodev_sym_session *sess,
4284 struct crypto_params *m_hlp,
4285 struct perf_test_params *params)
4287 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
4288 uint8_t *, IV_OFFSET);
4290 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
4291 rte_crypto_op_free(op);
4295 op->sym->aead.digest.data = m_hlp->digest;
4296 op->sym->aead.digest.phys_addr = rte_pktmbuf_mtophys_offset(
4298 params->session_attrs->aad_len +
4299 params->symmetric_op->p_len);
4302 op->sym->aead.aad.data = m_hlp->aad;
4303 op->sym->aead.aad.phys_addr = rte_pktmbuf_mtophys(m);
4305 rte_memcpy(op->sym->aead.aad.data, params->symmetric_op->aad_data,
4306 params->session_attrs->aad_len);
4308 rte_memcpy(iv_ptr, params->session_attrs->iv_data,
4309 params->session_attrs->iv_len);
4310 if (params->session_attrs->iv_len == 12)
4313 op->sym->aead.data.offset =
4314 params->session_attrs->aad_len;
4315 op->sym->aead.data.length = params->symmetric_op->p_len;
4322 static struct rte_mbuf *
4323 test_perf_create_pktmbuf_fill(struct rte_mempool *mpool,
4324 struct perf_test_params *params,
4325 unsigned buf_sz, struct crypto_params *m_hlp)
4327 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
4328 uint16_t aad_len = params->session_attrs->aad_len;
4329 uint16_t digest_size = params->symmetric_op->t_len;
4332 p = rte_pktmbuf_append(m, aad_len);
4334 rte_pktmbuf_free(m);
4337 m_hlp->aad = (uint8_t *)p;
4339 p = rte_pktmbuf_append(m, buf_sz);
4341 rte_pktmbuf_free(m);
4344 rte_memcpy(p, params->symmetric_op->p_data, buf_sz);
4346 p = rte_pktmbuf_append(m, digest_size);
4348 rte_pktmbuf_free(m);
4351 m_hlp->digest = (uint8_t *)p;
4357 perf_AES_GCM(uint8_t dev_id, uint16_t queue_id,
4358 struct perf_test_params *pparams, uint32_t test_ops)
4361 struct crypto_testsuite_params *ts_params = &testsuite_params;
4362 struct rte_cryptodev_sym_session *sess;
4363 struct rte_crypto_op *ops[pparams->burst_size];
4364 struct rte_crypto_op *proc_ops[pparams->burst_size];
4365 uint32_t total_operations = pparams->total_operations;
4367 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
4368 uint64_t processed = 0, failed_polls = 0, retries = 0;
4369 uint64_t tsc_start = 0, tsc_end = 0;
4371 uint16_t i = 0, l = 0, m = 0;
4372 uint16_t burst = pparams->burst_size * NUM_MBUF_SETS;
4373 uint16_t ops_unused = 0;
4375 struct rte_mbuf *mbufs[burst];
4376 struct crypto_params m_hlp[burst];
4378 if (rte_cryptodev_count() == 0) {
4379 printf("\nNo crypto devices available. "
4380 "Is kernel driver loaded?\n");
4384 sess = test_perf_create_session(dev_id, pparams);
4385 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
4387 for (i = 0; i < burst; i++) {
4388 mbufs[i] = test_perf_create_pktmbuf_fill(
4390 pparams, pparams->symmetric_op->p_len,
4395 total_operations = test_ops;
4397 tsc_start = rte_rdtsc_precise();
4398 while (total_enqueued < total_operations) {
4399 uint16_t burst_size =
4400 total_enqueued+pparams->burst_size <= total_operations ?
4401 pparams->burst_size : total_operations-total_enqueued;
4402 uint16_t ops_needed = burst_size-ops_unused;
4404 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
4405 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
4406 printf("\nFailed to alloc enough ops, "
4407 "finish dequeuing");
4409 for (i = 0; i < ops_needed; i++)
4410 ops[i] = perf_gcm_set_crypto_op(ops[i],
4411 mbufs[i + (pparams->burst_size *
4412 (j % NUM_MBUF_SETS))],
4413 sess, &m_hlp[i + (pparams->burst_size *
4414 (j % NUM_MBUF_SETS))], pparams);
4417 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
4418 queue_id, ops, burst_size);
4420 if (burst_enqueued < burst_size)
4423 ops_unused = burst_size-burst_enqueued;
4424 total_enqueued += burst_enqueued;
4428 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
4429 proc_ops, pparams->burst_size);
4430 if (burst_dequeued == 0)
4433 processed += burst_dequeued;
4435 for (l = 0; l < burst_dequeued; l++)
4436 rte_crypto_op_free(proc_ops[l]);
4442 /* Dequeue any operations still in the crypto device */
4443 while (processed < total_operations) {
4444 /* Sending 0 length burst to flush sw crypto device */
4445 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
4448 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
4449 proc_ops, pparams->burst_size);
4450 if (burst_dequeued == 0)
4453 processed += burst_dequeued;
4455 for (m = 0; m < burst_dequeued; m++) {
4457 uint8_t *pkt = rte_pktmbuf_mtod(
4458 proc_ops[m]->sym->m_src,
4461 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4462 pparams->symmetric_op->c_data,
4464 pparams->session_attrs->aad_len,
4465 pparams->symmetric_op->c_len,
4466 "GCM Ciphertext data not as expected");
4468 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4469 pparams->symmetric_op->t_data,
4471 pparams->session_attrs->aad_len +
4472 pparams->symmetric_op->c_len,
4473 pparams->symmetric_op->t_len,
4474 "GCM MAC data not as expected");
4477 rte_crypto_op_free(proc_ops[m]);
4482 tsc_end = rte_rdtsc_precise();
4484 double ops_s = ((double)processed / (tsc_end - tsc_start))
4486 double throughput = (ops_s * pparams->symmetric_op->p_len * 8)
4490 printf("\n%u\t\t%6.2f\t%16.2f\t%8"PRIu64"\t%10"PRIu64,
4491 pparams->symmetric_op->p_len,
4492 ops_s/1000000, throughput, retries, failed_polls);
4495 for (i = 0; i < burst; i++)
4496 rte_pktmbuf_free(mbufs[i]);
4498 rte_cryptodev_sym_session_clear(ts_params->dev_id, sess);
4499 rte_cryptodev_sym_session_free(sess);
4505 test_perf_AES_GCM(int continual_buf_len, int continual_size)
4507 uint16_t i, j, k, loops = 1;
4509 uint16_t buf_lengths[] = { 64, 128, 256, 512, 1024, 1536, 2048 };
4511 static const struct cryptodev_perf_test_data *gcm_tests[] = {
4512 &AES_GCM_128_12IV_0AAD
4515 if (continual_buf_len)
4516 loops = continual_size;
4518 int TEST_CASES_GCM = RTE_DIM(gcm_tests);
4520 const unsigned burst_size = 32;
4522 struct symmetric_op ops_set[TEST_CASES_GCM];
4523 struct perf_test_params params_set[TEST_CASES_GCM];
4524 struct symmetric_session_attrs session_attrs[TEST_CASES_GCM];
4525 static const struct cryptodev_perf_test_data *gcm_test;
4527 for (i = 0; i < TEST_CASES_GCM; ++i) {
4529 gcm_test = gcm_tests[i];
4531 session_attrs[i].aead =
4532 RTE_CRYPTO_AEAD_OP_ENCRYPT;
4533 session_attrs[i].aead_algorithm =
4534 RTE_CRYPTO_AEAD_AES_GCM;
4535 session_attrs[i].key_aead_data =
4537 session_attrs[i].key_aead_len =
4539 session_attrs[i].aad_len = gcm_test->aad.len;
4540 session_attrs[i].digest_len =
4541 gcm_test->auth_tag.len;
4542 session_attrs[i].iv_len = gcm_test->iv.len;
4543 session_attrs[i].iv_data = gcm_test->iv.data;
4545 ops_set[i].aad_data = gcm_test->aad.data;
4546 ops_set[i].p_data = gcm_test->plaintext.data;
4547 ops_set[i].p_len = buf_lengths[i];
4548 ops_set[i].c_data = gcm_test->ciphertext.data;
4549 ops_set[i].c_len = buf_lengths[i];
4550 ops_set[i].t_data = gcm_test->auth_tags[i].data;
4551 ops_set[i].t_len = gcm_test->auth_tags[i].len;
4553 params_set[i].chain = AEAD;
4554 params_set[i].session_attrs = &session_attrs[i];
4555 params_set[i].symmetric_op = &ops_set[i];
4556 if (continual_buf_len)
4557 params_set[i].total_operations = 0xFFFFFF;
4559 params_set[i].total_operations = 1000000;
4561 params_set[i].burst_size = burst_size;
4565 if (continual_buf_len)
4566 printf("\nCipher algo: %s Cipher hash: %s cipher key size: %ub"
4567 " burst size: %u", "AES_GCM", "AES_GCM",
4568 gcm_test->key.len << 3, burst_size);
4570 for (i = 0; i < RTE_DIM(gcm_tests); i++) {
4572 if (!continual_buf_len) {
4573 printf("\nCipher algo: %s Cipher hash: %s cipher key size: %ub"
4574 " burst size: %u", "AES_GCM", "AES_GCM",
4575 gcm_test->key.len << 3, burst_size);
4576 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
4577 " Retries\tEmptyPolls");
4580 uint16_t len = RTE_DIM(buf_lengths);
4583 if (continual_buf_len) {
4584 for (k = 0; k < RTE_DIM(buf_lengths); k++)
4585 if (buf_lengths[k] == continual_buf_len) {
4591 for (j = p; j < len; ++j) {
4593 params_set[i].symmetric_op->c_len = buf_lengths[j];
4594 params_set[i].symmetric_op->p_len = buf_lengths[j];
4596 ops_set[i].t_data = gcm_tests[i]->auth_tags[j].data;
4597 ops_set[i].t_len = gcm_tests[i]->auth_tags[j].len;
4599 /* Run is twice, one for encryption/hash checks,
4602 if (perf_AES_GCM(testsuite_params.dev_id, 0,
4606 for (k = 0; k < loops; k++) {
4607 if (continual_buf_len)
4608 printf("\n\nBuffer Size(B)\tOPS(M)\t"
4609 "Throughput(Gbps)\t"
4610 "Retries\tEmptyPolls");
4611 if (perf_AES_GCM(testsuite_params.dev_id, 0,
4614 if (continual_buf_len)
4615 printf("\n\nCompleted loop %i of %i ...",
4625 static int test_cryptodev_perf_AES_GCM(void)
4627 return test_perf_AES_GCM(0, 0);
4630 * This function calls AES GCM performance tests providing
4631 * size of packet as an argument. If size of packet is not
4632 * in the buf_lengths array, all sizes will be used
4634 static int test_continual_perf_AES_GCM(void)
4636 return test_perf_AES_GCM(1024, 10);
4640 test_perf_continual_performance_test(void)
4642 unsigned int total_operations = 0xFFFFFF;
4643 unsigned int total_loops = 10;
4644 unsigned int burst_size = 32;
4647 struct perf_test_params params_set = {
4648 .total_operations = total_operations,
4649 .burst_size = burst_size,
4652 .chain = CIPHER_HASH,
4654 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4656 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4659 for (i = 1; i <= total_loops; ++i) {
4660 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
4661 " burst_size: %d ops\n",
4662 chain_mode_name(params_set.chain),
4663 rte_crypto_cipher_algorithm_strings[params_set.cipher_algo],
4664 rte_crypto_auth_algorithm_strings[params_set.auth_algo],
4665 params_set.key_length,
4667 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
4668 "Retries\tEmptyPolls\n");
4669 test_perf_aes_sha(testsuite_params.dev_id, 0,
4671 printf("\nCompleted loop %i of %i ...", i, total_loops);
4676 static struct unit_test_suite cryptodev_qat_continual_testsuite = {
4677 .suite_name = "Crypto Device Continual Performance Test",
4678 .setup = testsuite_setup,
4679 .teardown = testsuite_teardown,
4680 .unit_test_cases = {
4681 TEST_CASE_ST(ut_setup, ut_teardown,
4682 test_perf_continual_performance_test),
4683 TEST_CASE_ST(ut_setup, ut_teardown,
4684 test_continual_perf_AES_GCM),
4685 TEST_CASES_END() /**< NULL terminate unit test array */
4689 static struct unit_test_suite cryptodev_testsuite = {
4690 .suite_name = "Crypto Device Unit Test Suite",
4691 .setup = testsuite_setup,
4692 .teardown = testsuite_teardown,
4693 .unit_test_cases = {
4694 TEST_CASE_ST(ut_setup, ut_teardown,
4695 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4696 TEST_CASE_ST(ut_setup, ut_teardown,
4697 test_cryptodev_perf_AES_GCM),
4698 TEST_CASE_ST(ut_setup, ut_teardown,
4699 test_perf_aes_cbc_vary_burst_size),
4700 TEST_CASES_END() /**< NULL terminate unit test array */
4704 static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = {
4705 .suite_name = "Crypto Device DPAA2_SEC Unit Test Suite",
4706 .setup = testsuite_setup,
4707 .teardown = testsuite_teardown,
4708 .unit_test_cases = {
4709 TEST_CASE_ST(ut_setup, ut_teardown,
4710 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4711 TEST_CASES_END() /**< NULL terminate unit test array */
4715 static struct unit_test_suite cryptodev_gcm_testsuite = {
4716 .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
4717 .setup = testsuite_setup,
4718 .teardown = testsuite_teardown,
4719 .unit_test_cases = {
4720 TEST_CASE_ST(ut_setup, ut_teardown,
4721 test_cryptodev_perf_AES_GCM),
4722 TEST_CASES_END() /**< NULL terminate unit test array */
4726 static struct unit_test_suite cryptodev_aes_testsuite = {
4727 .suite_name = "Crypto Device AESNI MB Unit Test Suite",
4728 .setup = testsuite_setup,
4729 .teardown = testsuite_teardown,
4730 .unit_test_cases = {
4731 TEST_CASE_ST(ut_setup, ut_teardown,
4732 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4733 TEST_CASES_END() /**< NULL terminate unit test array */
4737 static struct unit_test_suite cryptodev_snow3g_testsuite = {
4738 .suite_name = "Crypto Device SNOW3G Unit Test Suite",
4739 .setup = testsuite_setup,
4740 .teardown = testsuite_teardown,
4741 .unit_test_cases = {
4742 TEST_CASE_ST(ut_setup, ut_teardown,
4743 test_perf_snow3G_vary_pkt_size),
4744 TEST_CASE_ST(ut_setup, ut_teardown,
4745 test_perf_snow3G_vary_burst_size),
4746 TEST_CASES_END() /**< NULL terminate unit test array */
4750 static struct unit_test_suite cryptodev_openssl_testsuite = {
4751 .suite_name = "Crypto Device OPENSSL Unit Test Suite",
4752 .setup = testsuite_setup,
4753 .teardown = testsuite_teardown,
4754 .unit_test_cases = {
4755 TEST_CASE_ST(ut_setup, ut_teardown,
4756 test_perf_openssl_vary_pkt_size),
4757 TEST_CASE_ST(ut_setup, ut_teardown,
4758 test_perf_openssl_vary_burst_size),
4759 TEST_CASES_END() /**< NULL terminate unit test array */
4763 static struct unit_test_suite cryptodev_armv8_testsuite = {
4764 .suite_name = "Crypto Device ARMv8 Unit Test Suite",
4765 .setup = testsuite_setup,
4766 .teardown = testsuite_teardown,
4767 .unit_test_cases = {
4768 TEST_CASE_ST(ut_setup, ut_teardown,
4769 test_perf_armv8_vary_pkt_size),
4770 TEST_CASE_ST(ut_setup, ut_teardown,
4771 test_perf_armv8_vary_burst_size),
4772 TEST_CASES_END() /**< NULL terminate unit test array */
4777 perftest_aesni_gcm_cryptodev(void)
4779 gbl_driver_id = rte_cryptodev_driver_id_get(
4780 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
4782 if (gbl_driver_id == -1) {
4783 RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded. Check if "
4784 "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM is enabled "
4785 "in config file to run this testsuite.\n");
4789 return unit_test_suite_runner(&cryptodev_gcm_testsuite);
4793 perftest_aesni_mb_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4795 gbl_driver_id = rte_cryptodev_driver_id_get(
4796 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
4798 if (gbl_driver_id == -1) {
4799 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded. Check if "
4800 "CONFIG_RTE_LIBRTE_PMD_AESNI_MB is enabled "
4801 "in config file to run this testsuite.\n");
4805 return unit_test_suite_runner(&cryptodev_aes_testsuite);
4809 perftest_qat_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4811 gbl_driver_id = rte_cryptodev_driver_id_get(
4812 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
4814 if (gbl_driver_id == -1) {
4815 RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check if "
4816 "CONFIG_RTE_LIBRTE_PMD_QAT is enabled "
4817 "in config file to run this testsuite.\n");
4821 return unit_test_suite_runner(&cryptodev_testsuite);
4825 perftest_sw_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4827 gbl_driver_id = rte_cryptodev_driver_id_get(
4828 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
4830 if (gbl_driver_id == -1) {
4831 RTE_LOG(ERR, USER1, "SNOW3G PMD must be loaded. Check if "
4832 "CONFIG_RTE_LIBRTE_PMD_SNOW3G is enabled "
4833 "in config file to run this testsuite.\n");
4837 return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
4841 perftest_qat_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4843 gbl_driver_id = rte_cryptodev_driver_id_get(
4844 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
4846 if (gbl_driver_id == -1) {
4847 RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check if "
4848 "CONFIG_RTE_LIBRTE_PMD_QAT is enabled "
4849 "in config file to run this testsuite.\n");
4853 return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
4857 perftest_openssl_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4859 gbl_driver_id = rte_cryptodev_driver_id_get(
4860 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
4862 if (gbl_driver_id == -1) {
4863 RTE_LOG(ERR, USER1, "OpenSSL PMD must be loaded. Check if "
4864 "CONFIG_RTE_LIBRTE_PMD_OPENSSL is enabled "
4865 "in config file to run this testsuite.\n");
4869 return unit_test_suite_runner(&cryptodev_openssl_testsuite);
4873 perftest_qat_continual_cryptodev(void)
4875 gbl_driver_id = rte_cryptodev_driver_id_get(
4876 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
4878 if (gbl_driver_id == -1) {
4879 RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check if "
4880 "CONFIG_RTE_LIBRTE_PMD_QAT is enabled "
4881 "in config file to run this testsuite.\n");
4885 return unit_test_suite_runner(&cryptodev_qat_continual_testsuite);
4889 perftest_sw_armv8_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4891 gbl_driver_id = rte_cryptodev_driver_id_get(
4892 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
4894 if (gbl_driver_id == -1) {
4895 RTE_LOG(ERR, USER1, "ARMV8 PMD must be loaded. Check if "
4896 "CONFIG_RTE_LIBRTE_PMD_ARMV8 is enabled "
4897 "in config file to run this testsuite.\n");
4901 return unit_test_suite_runner(&cryptodev_armv8_testsuite);
4905 perftest_dpaa2_sec_cryptodev(void)
4907 gbl_driver_id = rte_cryptodev_driver_id_get(
4908 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
4910 if (gbl_driver_id == -1) {
4911 RTE_LOG(ERR, USER1, "DPAA2 SEC PMD must be loaded. Check if "
4912 "CONFIG_RTE_LIBRTE_PMD_DPAA2_SEC is enabled "
4913 "in config file to run this testsuite.\n");
4917 return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
4920 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_perftest, perftest_aesni_mb_cryptodev);
4921 REGISTER_TEST_COMMAND(cryptodev_qat_perftest, perftest_qat_cryptodev);
4922 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_perftest, perftest_sw_snow3g_cryptodev);
4923 REGISTER_TEST_COMMAND(cryptodev_qat_snow3g_perftest, perftest_qat_snow3g_cryptodev);
4924 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_perftest, perftest_aesni_gcm_cryptodev);
4925 REGISTER_TEST_COMMAND(cryptodev_openssl_perftest,
4926 perftest_openssl_cryptodev);
4927 REGISTER_TEST_COMMAND(cryptodev_qat_continual_perftest,
4928 perftest_qat_continual_cryptodev);
4929 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_perftest,
4930 perftest_sw_armv8_cryptodev);
4931 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_perftest,
4932 perftest_dpaa2_sec_cryptodev);